Index: src/Parser/Parser.cc =================================================================== --- src/Parser/Parser.cc (revision 00cc023285120a85a7e80e417220f36483ebd413) +++ src/Parser/Parser.cc (revision 56c393547addff0a409b2886d25499bdf0079ca7) @@ -10,6 +10,6 @@ // Created On : Sat May 16 14:54:28 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat May 16 14:55:59 2015 -// Update Count : 2 +// Last Modified On : Sun May 31 23:45:19 2015 +// Update Count : 4 // @@ -17,5 +17,5 @@ #include "TypedefTable.h" #include "lex.h" -#include "cfa.tab.h" +#include "parser.h" // global variables in cfa.y Index: src/Parser/cfa.y =================================================================== --- src/Parser/cfa.y (revision 00cc023285120a85a7e80e417220f36483ebd413) +++ (revision ) @@ -1,2735 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// cfa.y -- -// -// Author : Peter A. Buhr -// Created On : Sat Sep 1 20:22:55 2001 -// Last Modified By : Peter A. Buhr -// Last Modified On : Wed May 27 09:20:53 2015 -// Update Count : 1015 -// - -// This grammar is based on the ANSI99/11 C grammar, specifically parts of EXPRESSION and STATEMENTS, and on -// the C grammar by James A. Roskind, specifically parts of DECLARATIONS and EXTERNAL DEFINITIONS. While -// parts have been copied, important changes have been made in all sections; these changes are sufficient to -// constitute a new grammar. In particular, this grammar attempts to be more syntactically precise, i.e., it -// parses less incorrect language syntax that must be subsequently rejected by semantic checks. Nevertheless, -// there are still several semantic checks required and many are noted in the grammar. Finally, the grammar is -// extended with GCC and CFA language extensions. - -// Acknowledgments to Richard Bilson, Glen Ditchfield, and Rodolfo Gabriel Esteves who all helped when I got -// stuck with the grammar. - -// The root language for this grammar is ANSI99/11 C. All of ANSI99/11 is parsed, except for: -// -// 1. designation with '=' (use ':' instead) -// -// Most of the syntactic extensions from ANSI90 to ANSI11 C are marked with the comment "C99/C11". This -// grammar also has two levels of extensions. The first extensions cover most of the GCC C extensions, except for: -// -// 1. nested functions -// 2. generalized lvalues -// 3. designation with and without '=' (use ':' instead) -// 4. attributes not allowed in parenthesis of declarator -// -// All of the syntactic extensions for GCC C are marked with the comment "GCC". The second extensions are for -// Cforall (CFA), which fixes several of C's outstanding problems and extends C with many modern language -// concepts. All of the syntactic extensions for CFA C are marked with the comment "CFA". As noted above, -// there is one unreconcileable parsing problem between C99 and CFA with respect to designators; this is -// discussed in detail before the "designation" grammar rule. - -%{ -#define YYDEBUG_LEXER_TEXT (yylval) // lexer loads this up each time -#define YYDEBUG 1 // get the pretty debugging code to compile - -#undef __GNUC_MINOR__ - -#include -#include -#include "TypedefTable.h" -#include "lex.h" -#include "ParseNode.h" -#include "LinkageSpec.h" - -DeclarationNode *theTree = 0; // the resulting parse tree -LinkageSpec::Type linkage = LinkageSpec::Cforall; -std::stack< LinkageSpec::Type > linkageStack; -TypedefTable typedefTable; -%} - -//************************* TERMINAL TOKENS ******************************** - -// keywords -%token TYPEDEF -%token AUTO EXTERN REGISTER STATIC -%token INLINE // C99 -%token FORTRAN // C99, extension ISO/IEC 9899:1999 Section J.5.9(1) -%token CONST VOLATILE -%token RESTRICT // C99 -%token FORALL LVALUE // CFA -%token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED -%token BOOL COMPLEX IMAGINARY // C99 -%token TYPEOF LABEL // GCC -%token ENUM STRUCT UNION -%token TYPE FTYPE DTYPE CONTEXT // CFA -%token SIZEOF -%token ATTRIBUTE EXTENSION // GCC -%token IF ELSE SWITCH CASE DEFAULT DO WHILE FOR BREAK CONTINUE GOTO RETURN -%token CHOOSE FALLTHRU TRY CATCH FINALLY THROW // CFA -%token ASM // C99, extension ISO/IEC 9899:1999 Section J.5.10(1) -%token ALIGNAS ALIGNOF ATOMIC GENERIC NORETURN STATICASSERT THREADLOCAL // C11 - -// names and constants: lexer differentiates between identifier and typedef names -%token IDENTIFIER QUOTED_IDENTIFIER TYPEDEFname TYPEGENname -%token ATTR_IDENTIFIER ATTR_TYPEDEFname ATTR_TYPEGENname -%token INTEGERconstant FLOATINGconstant CHARACTERconstant STRINGliteral -%token ZERO ONE // CFA - -// multi-character operators -%token ARROW // -> -%token ICR DECR // ++ -- -%token LS RS // << >> -%token LE GE EQ NE // <= >= == != -%token ANDAND OROR // && || -%token ELLIPSIS // ... - -%token MULTassign DIVassign MODassign // *= /= %=/ -%token PLUSassign MINUSassign // += -= -%token LSassign RSassign // <<= >>= -%token ANDassign ERassign ORassign // &= ^= |= - -// Types declaration -%union -{ - Token tok; - ParseNode *pn; - ExpressionNode *en; - DeclarationNode *decl; - DeclarationNode::TyCon aggKey; - DeclarationNode::TypeClass tclass; - StatementNode *sn; - ConstantNode *constant; - InitializerNode *in; -} - -%type zero_one identifier no_attr_identifier no_01_identifier -%type identifier_or_typedef_name no_attr_identifier_or_typedef_name no_01_identifier_or_typedef_name -%type string_literal_list - -// expressions -%type constant -%type tuple tuple_expression_list -%type unary_operator assignment_operator -%type primary_expression postfix_expression unary_expression -%type cast_expression multiplicative_expression additive_expression shift_expression -%type relational_expression equality_expression AND_expression exclusive_OR_expression -%type inclusive_OR_expression logical_AND_expression logical_OR_expression conditional_expression -%type constant_expression assignment_expression assignment_expression_opt -%type comma_expression comma_expression_opt -%type argument_expression_list argument_expression for_control_expression assignment_opt -%type subrange - -// statements -%type labeled_statement compound_statement expression_statement selection_statement -%type iteration_statement jump_statement exception_statement asm_statement -%type fall_through_opt fall_through -%type statement statement_list -%type block_item_list block_item -%type case_clause -%type case_value case_value_list -%type case_label case_label_list -%type switch_clause_list_opt switch_clause_list choose_clause_list_opt choose_clause_list -%type handler_list handler_clause finally_clause - -// declarations -%type abstract_array abstract_declarator abstract_function abstract_parameter_array -%type abstract_parameter_declaration abstract_parameter_declarator abstract_parameter_function -%type abstract_parameter_ptr abstract_ptr - -%type aggregate_key -%type aggregate_name - -%type array_dimension array_parameter_1st_dimension array_parameter_dimension multi_array_dimension - -%type assertion assertion_list_opt - -%type bit_subrange_size_opt bit_subrange_size - -%type basic_declaration_specifier basic_type_name basic_type_specifier direct_type_name indirect_type_name - -%type context_declaration context_declaration_list context_declaring_list context_specifier - -%type declaration declaration_list declaration_list_opt declaration_qualifier_list -%type declaration_specifier declarator declaring_list - -%type elaborated_type_name - -%type enumerator_list enum_name -%type enumerator_value_opt - -%type exception_declaration external_definition external_definition_list external_definition_list_opt - -%type field_declaration field_declaration_list field_declarator field_declaring_list -%type field field_list - -%type external_function_definition function_definition function_array function_declarator function_no_ptr function_ptr - -%type identifier_parameter_array identifier_parameter_declarator identifier_parameter_function -%type identifier_parameter_ptr identifier_list - -%type new_abstract_array new_abstract_declarator_no_tuple new_abstract_declarator_tuple -%type new_abstract_function new_abstract_parameter_declaration new_abstract_parameter_list -%type new_abstract_ptr new_abstract_tuple - -%type new_array_parameter_1st_dimension - -%type new_context_declaring_list new_declaration new_field_declaring_list -%type new_function_declaration new_function_return new_function_specifier - -%type new_identifier_parameter_array new_identifier_parameter_declarator_no_tuple -%type new_identifier_parameter_declarator_tuple new_identifier_parameter_ptr - -%type new_parameter_declaration new_parameter_list new_parameter_type_list new_parameter_type_list_opt - -%type new_typedef_declaration new_variable_declaration new_variable_specifier - -%type old_declaration old_declaration_list old_declaration_list_opt old_function_array -%type old_function_declarator old_function_no_ptr old_function_ptr - -%type parameter_declaration parameter_list parameter_type_list -%type parameter_type_list_opt - -%type paren_identifier paren_typedef - -%type storage_class storage_class_name storage_class_list - -%type sue_declaration_specifier sue_type_specifier - -%type type_class -%type type_declarator type_declarator_name type_declaring_list - -%type typedef typedef_array typedef_declaration typedef_declaration_specifier typedef_expression -%type typedef_function typedef_parameter_array typedef_parameter_function typedef_parameter_ptr -%type typedef_parameter_redeclarator typedef_ptr typedef_redeclarator typedef_type_specifier -%type typegen_declaration_specifier typegen_type_specifier - -%type type_name type_name_no_function -%type type_parameter type_parameter_list - -%type type_name_list - -%type type_qualifier type_qualifier_name type_qualifier_list type_qualifier_list_opt type_specifier - -%type variable_abstract_array variable_abstract_declarator variable_abstract_function -%type variable_abstract_ptr variable_array variable_declarator variable_function variable_ptr - -// initializers -%type initializer initializer_list initializer_opt - -// designators -%type designator designator_list designation - - -// Handle single shift/reduce conflict for dangling else by shifting the ELSE token. For example, this string -// is ambiguous: -// .---------. matches IF '(' comma_expression ')' statement -// if ( C ) S1 else S2 -// `-----------------' matches IF '(' comma_expression ')' statement ELSE statement */ - -%nonassoc THEN // rule precedence for IF '(' comma_expression ')' statement -%nonassoc ELSE // token precedence for start of else clause in IF statement - -%start translation_unit // parse-tree root - -%% -//************************* Namespace Management ******************************** - -// The grammar in the ANSI C standard is not strictly context-free, since it relies upon the distinct terminal -// symbols "identifier" and "TYPEDEFname" that are lexically identical. While it is possible to write a -// purely context-free grammar, such a grammar would obscure the relationship between syntactic and semantic -// constructs. Hence, this grammar uses the ANSI style. -// -// Cforall compounds this problem by introducing type names local to the scope of a declaration (for instance, -// those introduced through "forall" qualifiers), and by introducing "type generators" -- parametrized types. -// This latter type name creates a third class of identifiers that must be distinguished by the scanner. -// -// Since the scanner cannot distinguish among the different classes of identifiers without some context -// information, it accesses a data structure (the TypedefTable) to allow classification of an identifier that -// it has just read. Semantic actions during the parser update this data structure when the class of -// identifiers change. -// -// Because the Cforall language is block-scoped, there is the possibility that an identifier can change its -// class in a local scope; it must revert to its original class at the end of the block. Since type names can -// be local to a particular declaration, each declaration is itself a scope. This requires distinguishing -// between type names that are local to the current declaration scope and those that persist past the end of -// the declaration (i.e., names defined in "typedef" or "type" declarations). -// -// The non-terminals "push" and "pop" derive the empty string; their only use is to denote the opening and -// closing of scopes. Every push must have a matching pop, although it is regrettable the matching pairs do -// not always occur within the same rule. These non-terminals may appear in more contexts than strictly -// necessary from a semantic point of view. Unfortunately, these extra rules are necessary to prevent parsing -// conflicts -- the parser may not have enough context and look-ahead information to decide whether a new -// scope is necessary, so the effect of these extra rules is to open a new scope unconditionally. As the -// grammar evolves, it may be neccesary to add or move around "push" and "pop" nonterminals to resolve -// conflicts of this sort. - -push: - { - typedefTable.enterScope(); - } - ; - -pop: - { - typedefTable.leaveScope(); - } - ; - -//************************* CONSTANTS ******************************** - -constant: - // ENUMERATIONconstant is not included here; it is treated as a variable with type - // "enumeration constant". - INTEGERconstant { $$ = new ConstantNode(ConstantNode::Integer, $1); } - | FLOATINGconstant { $$ = new ConstantNode(ConstantNode::Float, $1); } - | CHARACTERconstant { $$ = new ConstantNode(ConstantNode::Character, $1); } - ; - -identifier: - IDENTIFIER - | ATTR_IDENTIFIER // CFA - | zero_one // CFA - ; - -no_01_identifier: - IDENTIFIER - | ATTR_IDENTIFIER // CFA - ; - -no_attr_identifier: - IDENTIFIER - ; - -zero_one: // CFA - ZERO - | ONE - ; - -string_literal_list: // juxtaposed strings are concatenated - STRINGliteral { $$ = new ConstantNode(ConstantNode::String, $1); } - | string_literal_list STRINGliteral { $$ = $1->append( $2 ); } - ; - -//************************* EXPRESSIONS ******************************** - -primary_expression: - IDENTIFIER // typedef name cannot be used as a variable name - { $$ = new VarRefNode($1); } - | zero_one - { $$ = new VarRefNode($1); } - | constant - { $$ = $1; } - | string_literal_list - { $$ = $1; } - | '(' comma_expression ')' - { $$ = $2; } - | '(' compound_statement ')' // GCC, lambda expression - { $$ = new ValofExprNode($2); } - ; - -postfix_expression: - primary_expression - | postfix_expression '[' push assignment_expression pop ']' - // CFA, comma_expression disallowed in the context because it results in a commom user error: - // subscripting a matrix with x[i,j] instead of x[i][j]. While this change is not backwards - // compatible, there seems to be little advantage to this feature and many disadvantages. It is - // possible to write x[(i,j)] in CFA, which is equivalent to the old x[i,j]. - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Index), $1, $4); } - | postfix_expression '(' argument_expression_list ')' - { $$ = new CompositeExprNode($1, $3); } - | postfix_expression '.' no_attr_identifier - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::FieldSel), $1, new VarRefNode($3)); } - | postfix_expression '.' '[' push field_list pop ']' // CFA, tuple field selector - | postfix_expression ARROW no_attr_identifier - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::PFieldSel), $1, new VarRefNode($3)); } - | postfix_expression ARROW '[' push field_list pop ']' // CFA, tuple field selector - | postfix_expression ICR - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::IncrPost), $1); } - | postfix_expression DECR - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::DecrPost), $1); } - // GCC has priority: cast_expression - | '(' type_name_no_function ')' '{' initializer_list comma_opt '}' // C99 - { $$ = 0; } - ; - -argument_expression_list: - argument_expression - | argument_expression_list ',' argument_expression - { $$ = (ExpressionNode *)($1->set_link($3)); } - ; - -argument_expression: - // empty - { $$ = 0; } // use default argument - | assignment_expression - | no_attr_identifier ':' assignment_expression - { $$ = $3->set_asArgName($1); } - // Only a list of no_attr_identifier_or_typedef_name is allowed in this context. However, there is - // insufficient look ahead to distinguish between this list of parameter names and a tuple, so the - // tuple form must be used with an appropriate semantic check. - | '[' push assignment_expression pop ']' ':' assignment_expression - { $$ = $7->set_asArgName($3); } - | '[' push assignment_expression ',' tuple_expression_list pop ']' ':' assignment_expression - { $$ = $9->set_asArgName( new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)$3->set_link( flattenCommas( $5 )))); } - ; - -field_list: // CFA, tuple field selector - field - | field_list ',' field { $$ = (ExpressionNode *)$1->set_link( $3 ); } - ; - -field: // CFA, tuple field selector - no_attr_identifier - { $$ = new VarRefNode( $1 ); } - | no_attr_identifier '.' field - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::FieldSel), new VarRefNode( $1 ), $3); } - | no_attr_identifier '.' '[' push field_list pop ']' - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::FieldSel), new VarRefNode( $1 ), $5); } - | no_attr_identifier ARROW field - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::PFieldSel), new VarRefNode( $1 ), $3); } - | no_attr_identifier ARROW '[' push field_list pop ']' - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::PFieldSel), new VarRefNode( $1 ), $5); } - ; - -unary_expression: - postfix_expression - | ICR unary_expression - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Incr), $2); } - | DECR unary_expression - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Decr), $2); } - | EXTENSION cast_expression // GCC - { $$ = $2; } - | unary_operator cast_expression - { $$ = new CompositeExprNode($1, $2); } - | '!' cast_expression - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Neg), $2); } - | '*' cast_expression // CFA - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::PointTo), $2); } - // '*' is is separated from unary_operator because of shift/reduce conflict in: - // { * X; } // dereference X - // { * int X; } // CFA declaration of pointer to int - // '&' must be moved here if C++ reference variables are supported. - | SIZEOF unary_expression - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::SizeOf), $2); } - | SIZEOF '(' type_name_no_function ')' - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::SizeOf), new TypeValueNode($3)); } - | ATTR_IDENTIFIER - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Attr), new VarRefNode($1)); } - | ATTR_IDENTIFIER '(' type_name ')' - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Attr), new VarRefNode($1), new TypeValueNode($3)); } - | ATTR_IDENTIFIER '(' argument_expression ')' - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Attr), new VarRefNode($1), $3); } - | ALIGNOF unary_expression // GCC, variable alignment - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::AlignOf), $2); } - | ALIGNOF '(' type_name_no_function ')' // GCC, type alignment - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::AlignOf), new TypeValueNode($3)); } - | ANDAND no_attr_identifier // GCC, address of label - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::LabelAddress), new VarRefNode($2, true)); } - ; - -unary_operator: - '&' { $$ = new OperatorNode(OperatorNode::AddressOf); } - | '+' { $$ = new OperatorNode(OperatorNode::UnPlus); } - | '-' { $$ = new OperatorNode(OperatorNode::UnMinus); } - | '~' { $$ = new OperatorNode(OperatorNode::BitNeg); } - ; - -cast_expression: - unary_expression - | '(' type_name_no_function ')' cast_expression - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Cast), new TypeValueNode($2), $4); } - | '(' type_name_no_function ')' tuple - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Cast), new TypeValueNode($2), $4); } - ; - -multiplicative_expression: - cast_expression - | multiplicative_expression '*' cast_expression - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Mul),$1,$3); } - | multiplicative_expression '/' cast_expression - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Div),$1,$3); } - | multiplicative_expression '%' cast_expression - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Mod),$1,$3); } - ; - -additive_expression: - multiplicative_expression - | additive_expression '+' multiplicative_expression - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Plus),$1,$3); } - | additive_expression '-' multiplicative_expression - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Minus),$1,$3); } - ; - -shift_expression: - additive_expression - | shift_expression LS additive_expression - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::LShift),$1,$3); } - | shift_expression RS additive_expression - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::RShift),$1,$3); } - ; - -relational_expression: - shift_expression - | relational_expression '<' shift_expression - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::LThan),$1,$3); } - | relational_expression '>' shift_expression - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::GThan),$1,$3); } - | relational_expression LE shift_expression - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::LEThan),$1,$3); } - | relational_expression GE shift_expression - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::GEThan),$1,$3); } - ; - -equality_expression: - relational_expression - | equality_expression EQ relational_expression - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Eq), $1, $3); } - | equality_expression NE relational_expression - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Neq), $1, $3); } - ; - -AND_expression: - equality_expression - | AND_expression '&' equality_expression - { $$ =new CompositeExprNode(new OperatorNode(OperatorNode::BitAnd), $1, $3); } - ; - -exclusive_OR_expression: - AND_expression - | exclusive_OR_expression '^' AND_expression - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Xor), $1, $3); } - ; - -inclusive_OR_expression: - exclusive_OR_expression - | inclusive_OR_expression '|' exclusive_OR_expression - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::BitOr), $1, $3); } - ; - -logical_AND_expression: - inclusive_OR_expression - | logical_AND_expression ANDAND inclusive_OR_expression - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::And), $1, $3); } - ; - -logical_OR_expression: - logical_AND_expression - | logical_OR_expression OROR logical_AND_expression - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Or), $1, $3); } - ; - -conditional_expression: - logical_OR_expression - | logical_OR_expression '?' comma_expression ':' conditional_expression - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Cond), (ExpressionNode *)mkList((*$1,*$3,*$5))); } - | logical_OR_expression '?' /* empty */ ':' conditional_expression // GCC, omitted first operand - { $$=new CompositeExprNode(new OperatorNode(OperatorNode::NCond),$1,$4); } - | logical_OR_expression '?' comma_expression ':' tuple // CFA, tuple expression - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Cond), (ExpressionNode *)mkList(( *$1, *$3, *$5 ))); } - ; - -constant_expression: - conditional_expression - ; - -assignment_expression: - // CFA, assignment is separated from assignment_operator to ensure no assignment operations for tuples - conditional_expression - | unary_expression '=' assignment_expression - { $$ =new CompositeExprNode(new OperatorNode(OperatorNode::Assign), $1, $3); } - | unary_expression assignment_operator assignment_expression - { $$ =new CompositeExprNode($2, $1, $3); } - | tuple assignment_opt // CFA, tuple expression - { $$ = ($2 == 0) ? $1 : new CompositeExprNode( new OperatorNode( OperatorNode::Assign ), $1, $2 ); } - ; - -assignment_expression_opt: - // empty - { $$ = new NullExprNode; } - | assignment_expression - ; - -tuple: // CFA, tuple - // CFA, one assignment_expression is factored out of comma_expression to eliminate a shift/reduce - // conflict with comma_expression in new_identifier_parameter_array and new_abstract_array - '[' push pop ']' - { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ) ); } - | '[' push assignment_expression pop ']' - { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), $3 ); } - | '[' push ',' tuple_expression_list pop ']' - { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(new NullExprNode)->set_link( $4 ) ); } - | '[' push assignment_expression ',' tuple_expression_list pop ']' - { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)$3->set_link( flattenCommas( $5 ) ) ); } - ; - -tuple_expression_list: - assignment_expression_opt - | tuple_expression_list ',' assignment_expression_opt - { $$ = (ExpressionNode *)$1->set_link( $3 ); } - ; - -assignment_operator: - MULTassign { $$ = new OperatorNode(OperatorNode::MulAssn); } - | DIVassign { $$ = new OperatorNode(OperatorNode::DivAssn); } - | MODassign { $$ = new OperatorNode(OperatorNode::ModAssn); } - | PLUSassign { $$ = new OperatorNode(OperatorNode::PlusAssn); } - | MINUSassign { $$ = new OperatorNode(OperatorNode::MinusAssn); } - | LSassign { $$ = new OperatorNode(OperatorNode::LSAssn); } - | RSassign { $$ = new OperatorNode(OperatorNode::RSAssn); } - | ANDassign { $$ = new OperatorNode(OperatorNode::AndAssn); } - | ERassign { $$ = new OperatorNode(OperatorNode::ERAssn); } - | ORassign { $$ = new OperatorNode(OperatorNode::OrAssn); } - ; - -comma_expression: - assignment_expression - | comma_expression ',' assignment_expression // { $$ = (ExpressionNode *)$1->add_to_list($3); } - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Comma),$1,$3); } - ; - -comma_expression_opt: - // empty - { $$ = 0; } - | comma_expression - ; - -//*************************** STATEMENTS ******************************* - -statement: - labeled_statement - | compound_statement - | expression_statement { $$ = $1; } - | selection_statement - | iteration_statement - | jump_statement - | exception_statement - | asm_statement - ; - -labeled_statement: - no_attr_identifier ':' attribute_list_opt statement - { $$ = $4->add_label($1);} - ; - -compound_statement: - '{' '}' - { $$ = new CompoundStmtNode( (StatementNode *)0 ); } - | '{' - // Two scopes are necessary because the block itself has a scope, but every declaration within the - // block also requires its own scope - push push - label_declaration_opt // GCC, local labels - block_item_list pop '}' // C99, intermix declarations and statements - { $$ = new CompoundStmtNode( $5 ); } - ; - -block_item_list: // C99 - block_item - | block_item_list push block_item - { if ($1 != 0) { $1->set_link($3); $$ = $1; } } - ; - -block_item: - declaration // CFA, new & old style declarations - { $$ = new StatementNode( $1 ); } - | EXTENSION declaration // GCC - { $$ = new StatementNode( $2 ); } - | function_definition - { $$ = new StatementNode( $1 ); } - | statement pop - ; - -statement_list: - statement - | statement_list statement - { if ($1 != 0) { $1->set_link($2); $$ = $1; } } - ; - -expression_statement: - comma_expression_opt ';' - { $$ = new StatementNode(StatementNode::Exp, $1, 0); } - ; - -selection_statement: - IF '(' comma_expression ')' statement %prec THEN - // explicitly deal with the shift/reduce conflict on if/else - { $$ = new StatementNode(StatementNode::If, $3, $5); } - | IF '(' comma_expression ')' statement ELSE statement - { $$ = new StatementNode(StatementNode::If, $3, (StatementNode *)mkList((*$5, *$7)) ); } - | SWITCH '(' comma_expression ')' case_clause // CFA - { $$ = new StatementNode(StatementNode::Switch, $3, $5); } - | SWITCH '(' comma_expression ')' '{' push declaration_list_opt switch_clause_list_opt '}' // CFA - { $$ = new StatementNode(StatementNode::Switch, $3, $8); /* xxx */ } - // The semantics of the declaration list is changed to include any associated initialization, which is - // performed *before* the transfer to the appropriate case clause. Statements after the initial - // declaration list can never be executed, and therefore, are removed from the grammar even though C - // allows it. - | CHOOSE '(' comma_expression ')' case_clause // CFA - { $$ = new StatementNode(StatementNode::Choose, $3, $5); } - | CHOOSE '(' comma_expression ')' '{' push declaration_list_opt choose_clause_list_opt '}' // CFA - { $$ = new StatementNode(StatementNode::Choose, $3, $8); } - ; - -// CASE and DEFAULT clauses are only allowed in the SWITCH statement, precluding Duff's device. In addition, a -// case clause allows a list of values and subranges. - -case_value: // CFA - constant_expression { $$ = $1; } - | constant_expression ELLIPSIS constant_expression // GCC, subrange - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Range),$1,$3); } - | subrange // CFA, subrange - ; - -case_value_list: // CFA - case_value - | case_value_list ',' case_value - { $$ = new CompositeExprNode(new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(tupleContents($1))->set_link($3) ); } - ; - -case_label: // CFA - CASE case_value_list ':' { $$ = new StatementNode(StatementNode::Case, $2, 0); } - | DEFAULT ':' { $$ = new StatementNode(StatementNode::Default); } - // A semantic check is required to ensure only one default clause per switch/choose statement. - ; - -case_label_list: // CFA - case_label - | case_label_list case_label { $$ = (StatementNode *)($1->set_link($2)); } - ; - -case_clause: // CFA - case_label_list statement { $$ = $1->append_last_case($2); } - ; - -switch_clause_list_opt: // CFA - // empty - { $$ = 0; } - | switch_clause_list - ; - -switch_clause_list: // CFA - case_label_list statement_list - { $$ = $1->append_last_case($2); } - | switch_clause_list case_label_list statement_list - { $$ = (StatementNode *)($1->set_link($2->append_last_case($3))); } - ; - -choose_clause_list_opt: // CFA - // empty - { $$ = 0; } - | choose_clause_list - ; - -choose_clause_list: // CFA - case_label_list fall_through - { $$ = $1->append_last_case($2); } - | case_label_list statement_list fall_through_opt - { $$ = $1->append_last_case((StatementNode *)mkList((*$2,*$3))); } - | choose_clause_list case_label_list fall_through - { $$ = (StatementNode *)($1->set_link($2->append_last_case($3))); } - | choose_clause_list case_label_list statement_list fall_through_opt - { $$ = (StatementNode *)($1->set_link($2->append_last_case((StatementNode *)mkList((*$3,*$4))))); } - ; - -fall_through_opt: // CFA - // empty - { $$ = 0; } - | fall_through - ; - -fall_through: // CFA - FALLTHRU { $$ = new StatementNode(StatementNode::Fallthru, 0, 0); } - | FALLTHRU ';' { $$ = new StatementNode(StatementNode::Fallthru, 0, 0); } - ; - -iteration_statement: - WHILE '(' comma_expression ')' statement - { $$ = new StatementNode(StatementNode::While, $3, $5); } - | DO statement WHILE '(' comma_expression ')' ';' - { $$ = new StatementNode(StatementNode::Do, $5, $2); } - | FOR '(' push for_control_expression ')' statement - { $$ = new StatementNode(StatementNode::For, $4, $6); } - ; - -for_control_expression: - comma_expression_opt pop ';' comma_expression_opt ';' comma_expression_opt - { $$ = new ForCtlExprNode($1, $4, $6); } - | declaration comma_expression_opt ';' comma_expression_opt // C99 - // Like C++, the loop index can be declared local to the loop. - { $$ = new ForCtlExprNode($1, $2, $4); } - ; - -jump_statement: - GOTO no_attr_identifier ';' - { $$ = new StatementNode(StatementNode::Goto, $2); } - | GOTO '*' comma_expression ';' // GCC, computed goto - // The syntax for the GCC computed goto violates normal expression precedence, e.g., goto *i+3; => - // goto *(i+3); whereas normal operator precedence yields goto (*i)+3; - { $$ = new StatementNode(StatementNode::Goto, $3); } - | CONTINUE ';' - // A semantic check is required to ensure this statement appears only in the body of an iteration - // statement. - { $$ = new StatementNode(StatementNode::Continue, 0, 0); } - | CONTINUE no_attr_identifier ';' // CFA, multi-level continue - // A semantic check is required to ensure this statement appears only in the body of an iteration - // statement, and the target of the transfer appears only at the start of an iteration statement. - { $$ = new StatementNode(StatementNode::Continue, $2); } - | BREAK ';' - // A semantic check is required to ensure this statement appears only in the body of an iteration - // statement. - { $$ = new StatementNode(StatementNode::Break, 0, 0); } - | BREAK no_attr_identifier ';' // CFA, multi-level exit - // A semantic check is required to ensure this statement appears only in the body of an iteration - // statement, and the target of the transfer appears only at the start of an iteration statement. - { $$ = new StatementNode(StatementNode::Break, $2 ); } - | RETURN comma_expression_opt ';' - { $$ = new StatementNode(StatementNode::Return, $2, 0); } - | THROW assignment_expression ';' - { $$ = new StatementNode(StatementNode::Throw, $2, 0); } - | THROW ';' - { $$ = new StatementNode(StatementNode::Throw, 0, 0); } - ; - -exception_statement: - TRY compound_statement handler_list - { $$ = new StatementNode(StatementNode::Try, 0,(StatementNode *)(mkList((*$2,*$3)))); } - | TRY compound_statement finally_clause - { $$ = new StatementNode(StatementNode::Try, 0,(StatementNode *)(mkList((*$2,*$3)))); } - | TRY compound_statement handler_list finally_clause - { - $3->set_link($4); - $$ = new StatementNode(StatementNode::Try, 0,(StatementNode *)(mkList((*$2,*$3)))); - } - ; - -handler_list: - // There must be at least one catch clause - handler_clause - // ISO/IEC 9899:1999 Section 15.3(6) If present, a "..." handler shall be the last handler for its try - // block. - | CATCH '(' ELLIPSIS ')' compound_statement - { $$ = StatementNode::newCatchStmt( 0, $5, true ); } - | handler_clause CATCH '(' ELLIPSIS ')' compound_statement - { $$ = $1->set_link( StatementNode::newCatchStmt( 0, $6, true ) ); } - ; - -handler_clause: - CATCH '(' push push exception_declaration pop ')' compound_statement pop - { $$ = StatementNode::newCatchStmt($5, $8); } - | handler_clause CATCH '(' push push exception_declaration pop ')' compound_statement pop - { $$ = $1->set_link( StatementNode::newCatchStmt($6, $9) ); } - ; - -finally_clause: - FINALLY compound_statement - { - $$ = new StatementNode(StatementNode::Finally, 0, $2); - std::cout << "Just created a finally node" << std::endl; - } - ; - -exception_declaration: - // A semantic check is required to ensure type_specifier does not create a new type, e.g.: - // - // catch ( struct { int i; } x ) ... - // - // This new type cannot catch any thrown type because of name equivalence among types. - type_specifier - | type_specifier declarator - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - $$ = $2->addType( $1 ); - } - | type_specifier variable_abstract_declarator - { $$ = $2->addType( $1 ); } - | new_abstract_declarator_tuple no_attr_identifier // CFA - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - $$ = $1->addName( $2 ); - } - | new_abstract_declarator_tuple // CFA - ; - -asm_statement: - ASM type_qualifier_list_opt '(' constant_expression ')' ';' - { $$ = new StatementNode(StatementNode::Asm, 0, 0); } - | ASM type_qualifier_list_opt '(' constant_expression ':' asm_operands_opt ')' ';' // remaining GCC - { $$ = new StatementNode(StatementNode::Asm, 0, 0); } - | ASM type_qualifier_list_opt '(' constant_expression ':' asm_operands_opt ':' asm_operands_opt ')' ';' - { $$ = new StatementNode(StatementNode::Asm, 0, 0); } - | ASM type_qualifier_list_opt '(' constant_expression ':' asm_operands_opt ':' asm_operands_opt ':' asm_clobbers_list ')' ';' - { $$ = new StatementNode(StatementNode::Asm, 0, 0); } - ; - -asm_operands_opt: // GCC - // empty - | asm_operands_list - ; - -asm_operands_list: // GCC - asm_operand - | asm_operands_list ',' asm_operand - ; - -asm_operand: // GCC - STRINGliteral '(' constant_expression ')' {} - ; - -asm_clobbers_list: // GCC - STRINGliteral {} - | asm_clobbers_list ',' STRINGliteral - ; - -//******************************* DECLARATIONS ********************************* - -declaration_list_opt: // used at beginning of switch statement - pop - { $$ = 0; } - | declaration_list - ; - -declaration_list: - declaration - | declaration_list push declaration - { $$ = $1->appendList( $3 ); } - ; - -old_declaration_list_opt: // used to declare parameter types in K&R style functions - pop - { $$ = 0; } - | old_declaration_list - ; - -old_declaration_list: - old_declaration - | old_declaration_list push old_declaration - { $$ = $1->appendList( $3 ); } - ; - -label_declaration_opt: // GCC, local label - // empty - | label_declaration_list - ; - -label_declaration_list: // GCC, local label - LABEL label_list ';' - | label_declaration_list LABEL label_list ';' - ; - -label_list: // GCC, local label - no_attr_identifier_or_typedef_name {} - | label_list ',' no_attr_identifier_or_typedef_name {} - ; - -declaration: // CFA, new & old style declarations - new_declaration - | old_declaration - ; - -// C declaration syntax is notoriously confusing and error prone. Cforall provides its own type, variable and -// function declarations. CFA declarations use the same declaration tokens as in C; however, CFA places -// declaration modifiers to the left of the base type, while C declarations place modifiers to the right of -// the base type. CFA declaration modifiers are interpreted from left to right and the entire type -// specification is distributed across all variables in the declaration list (as in Pascal). ANSI C and the -// new CFA declarations may appear together in the same program block, but cannot be mixed within a specific -// declaration. -// -// CFA C -// [10] int x; int x[10]; // array of 10 integers -// [10] * char y; char *y[10]; // array of 10 pointers to char - -new_declaration: // CFA - new_variable_declaration pop ';' - | new_typedef_declaration pop ';' - | new_function_declaration pop ';' - | type_declaring_list pop ';' - | context_specifier pop ';' - ; - -new_variable_declaration: // CFA - new_variable_specifier initializer_opt - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - $$ = $1; - } - | declaration_qualifier_list new_variable_specifier initializer_opt - // declaration_qualifier_list also includes type_qualifier_list, so a semantic check is necessary to - // preclude them as a type_qualifier cannot appear in that context. - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - $$ = $2->addQualifiers( $1 ); - } - | new_variable_declaration pop ',' push identifier_or_typedef_name initializer_opt - { - typedefTable.addToEnclosingScope( *$5, TypedefTable::ID ); - $$ = $1->appendList( $1->cloneType( $5 ) ); - } - ; - -new_variable_specifier: // CFA - // A semantic check is required to ensure asm_name only appears on declarations with implicit or - // explicit static storage-class - new_abstract_declarator_no_tuple identifier_or_typedef_name asm_name_opt - { - typedefTable.setNextIdentifier( *$2 ); - $$ = $1->addName( $2 ); - } - | new_abstract_tuple identifier_or_typedef_name asm_name_opt - { - typedefTable.setNextIdentifier( *$2 ); - $$ = $1->addName( $2 ); - } - | type_qualifier_list new_abstract_tuple identifier_or_typedef_name asm_name_opt - { - typedefTable.setNextIdentifier( *$3 ); - $$ = $2->addQualifiers( $1 )->addName( $3 ); - } - ; - -new_function_declaration: // CFA - new_function_specifier - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - $$ = $1; - } - | type_qualifier_list new_function_specifier - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - $$ = $2->addQualifiers( $1 ); - } - | declaration_qualifier_list new_function_specifier - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - $$ = $2->addQualifiers( $1 ); - } - | declaration_qualifier_list type_qualifier_list new_function_specifier - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - $$ = $3->addQualifiers( $1 )->addQualifiers( $2 ); - } - | new_function_declaration pop ',' push identifier_or_typedef_name - { - typedefTable.addToEnclosingScope( *$5, TypedefTable::ID ); - $$ = $1->appendList( $1->cloneType( $5 ) ); - } - ; - -new_function_specifier: // CFA - '[' push pop ']' identifier '(' push new_parameter_type_list_opt pop ')' - { - typedefTable.setNextIdentifier( *($5) ); - $$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, 0, true ); - } - | '[' push pop ']' TYPEDEFname '(' push new_parameter_type_list_opt pop ')' - { - typedefTable.setNextIdentifier( *($5) ); - $$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, 0, true ); - } - // identifier_or_typedef_name must be broken apart because of the sequence: - // - // '[' ']' identifier_or_typedef_name '(' new_parameter_type_list_opt ')' - // '[' ']' type_specifier - // - // type_specifier can resolve to just TYPEDEFname (e.g. typedef int T; int f( T );). Therefore this - // must be flattened to allow lookahead to the '(' without having to reduce - // identifier_or_typedef_name. - | new_abstract_tuple identifier_or_typedef_name '(' push new_parameter_type_list_opt pop ')' - // To obtain LR(1), this rule must be factored out from function return type (see - // new_abstract_declarator). - { - $$ = DeclarationNode::newFunction( $2, $1, $5, 0, true ); - } - | new_function_return identifier_or_typedef_name '(' push new_parameter_type_list_opt pop ')' - { - $$ = DeclarationNode::newFunction( $2, $1, $5, 0, true ); - } - ; - -new_function_return: // CFA - '[' push new_parameter_list pop ']' - { $$ = DeclarationNode::newTuple( $3 ); } - | '[' push new_parameter_list pop ',' push new_abstract_parameter_list pop ']' - // To obtain LR(1), the last new_abstract_parameter_list is added into this flattened rule to - // lookahead to the ']'. - { $$ = DeclarationNode::newTuple( $3->appendList( $7 ) ); } - ; - -new_typedef_declaration: // CFA - TYPEDEF new_variable_specifier - { - typedefTable.addToEnclosingScope( TypedefTable::TD); - $$ = $2->addTypedef(); - } - | TYPEDEF new_function_specifier - { - typedefTable.addToEnclosingScope( TypedefTable::TD); - $$ = $2->addTypedef(); - } - | new_typedef_declaration pop ',' push no_attr_identifier - { - typedefTable.addToEnclosingScope( *$5, TypedefTable::TD); - $$ = $1->appendList( $1->cloneType( $5 ) ); - } - ; - -// Traditionally typedef is part of storage-class specifier for syntactic convenience only. Here, it is -// factored out as a separate form of declaration, which syntactically precludes storage-class specifiers and -// initialization. - -typedef_declaration: - TYPEDEF type_specifier declarator - { - typedefTable.addToEnclosingScope( TypedefTable::TD); - $$ = $3->addType( $2 )->addTypedef(); - } - | typedef_declaration pop ',' push declarator - { - typedefTable.addToEnclosingScope( TypedefTable::TD); - $$ = $1->appendList( $1->cloneBaseType( $5 )->addTypedef() ); - } - | type_qualifier_list TYPEDEF type_specifier declarator // remaining OBSOLESCENT (see 2) - { - typedefTable.addToEnclosingScope( TypedefTable::TD); - $$ = $4->addType( $3 )->addQualifiers( $1 )->addTypedef(); - } - | type_specifier TYPEDEF declarator - { - typedefTable.addToEnclosingScope( TypedefTable::TD); - $$ = $3->addType( $1 )->addTypedef(); - } - | type_specifier TYPEDEF type_qualifier_list declarator - { - typedefTable.addToEnclosingScope( TypedefTable::TD); - $$ = $4->addQualifiers($1)->addTypedef()->addType($1); - } - ; - -typedef_expression: // GCC, naming expression type - TYPEDEF no_attr_identifier '=' assignment_expression - { - typedefTable.addToEnclosingScope(*($2), TypedefTable::TD); - $$ = DeclarationNode::newName( 0 ); // XXX - } - | typedef_expression pop ',' push no_attr_identifier '=' assignment_expression - { - typedefTable.addToEnclosingScope(*($5), TypedefTable::TD); - $$ = DeclarationNode::newName( 0 ); // XXX - } - ; - -old_declaration: - declaring_list pop ';' - | typedef_declaration pop ';' - | typedef_expression pop ';' // GCC, naming expression type - | sue_declaration_specifier pop ';' - ; - -declaring_list: - // A semantic check is required to ensure asm_name only appears on declarations with implicit or - // explicit static storage-class - declaration_specifier declarator asm_name_opt initializer_opt - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - $$ = ($2->addType( $1 ))->addInitializer($4); - } - | declaring_list ',' attribute_list_opt declarator asm_name_opt initializer_opt - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - $$ = $1->appendList( $1->cloneBaseType( $4->addInitializer($6) ) ); - } - ; - -declaration_specifier: // type specifier + storage class - basic_declaration_specifier - | sue_declaration_specifier - | typedef_declaration_specifier - | typegen_declaration_specifier - ; - -type_specifier: // declaration specifier - storage class - basic_type_specifier - | sue_type_specifier - | typedef_type_specifier - | typegen_type_specifier - ; - -type_qualifier_list_opt: // GCC, used in asm_statement - // empty - { $$ = 0; } - | type_qualifier_list - ; - -type_qualifier_list: - // A semantic check is necessary to ensure a type qualifier is appropriate for the kind of - // declaration. - // - // ISO/IEC 9899:1999 Section 6.7.3(4) : If the same qualifier appears more than once in the same - // specifier-qualifier-list, either directly or via one or more typedefs, the behavior is the same as - // if it appeared only once. - type_qualifier - | type_qualifier_list type_qualifier - { $$ = $1->addQualifiers( $2 ); } - ; - -type_qualifier: - type_qualifier_name - | attribute - { $$ = DeclarationNode::newQualifier( DeclarationNode::Attribute ); } - ; - -type_qualifier_name: - CONST - { $$ = DeclarationNode::newQualifier( DeclarationNode::Const ); } - | RESTRICT - { $$ = DeclarationNode::newQualifier( DeclarationNode::Restrict ); } - | VOLATILE - { $$ = DeclarationNode::newQualifier( DeclarationNode::Volatile ); } - | LVALUE // CFA - { $$ = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); } - | ATOMIC - { $$ = DeclarationNode::newQualifier( DeclarationNode::Atomic ); } - | FORALL '(' - { - typedefTable.enterScope(); - } - type_parameter_list ')' // CFA - { - typedefTable.leaveScope(); - $$ = DeclarationNode::newForall( $4 ); - } - ; - -declaration_qualifier_list: - storage_class_list - | type_qualifier_list storage_class_list // remaining OBSOLESCENT (see 2) - { $$ = $1->addQualifiers( $2 ); } - | declaration_qualifier_list type_qualifier_list storage_class_list - { $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); } - ; - -storage_class_list: - // A semantic check is necessary to ensure a storage class is appropriate for the kind of declaration - // and that only one of each is specified, except for inline, which can appear with the others. - // - // ISO/IEC 9899:1999 Section 6.7.1(2) : At most, one storage-class specifier may be given in the - // declaration specifiers in a declaration. - storage_class - | storage_class_list storage_class - { $$ = $1->addQualifiers( $2 ); } - ; - -storage_class: - storage_class_name - ; - -storage_class_name: - EXTERN - { $$ = DeclarationNode::newStorageClass( DeclarationNode::Extern ); } - | STATIC - { $$ = DeclarationNode::newStorageClass( DeclarationNode::Static ); } - | AUTO - { $$ = DeclarationNode::newStorageClass( DeclarationNode::Auto ); } - | REGISTER - { $$ = DeclarationNode::newStorageClass( DeclarationNode::Register ); } - | INLINE // C99 - // INLINE is essentially a storage class specifier for functions, and hence, belongs here. - { $$ = DeclarationNode::newStorageClass( DeclarationNode::Inline ); } - | FORTRAN // C99 - { $$ = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); } - ; - -basic_type_name: - CHAR - { $$ = DeclarationNode::newBasicType( DeclarationNode::Char ); } - | DOUBLE - { $$ = DeclarationNode::newBasicType( DeclarationNode::Double ); } - | FLOAT - { $$ = DeclarationNode::newBasicType( DeclarationNode::Float ); } - | INT - { $$ = DeclarationNode::newBasicType( DeclarationNode::Int ); } - | LONG - { $$ = DeclarationNode::newModifier( DeclarationNode::Long ); } - | SHORT - { $$ = DeclarationNode::newModifier( DeclarationNode::Short ); } - | SIGNED - { $$ = DeclarationNode::newModifier( DeclarationNode::Signed ); } - | UNSIGNED - { $$ = DeclarationNode::newModifier( DeclarationNode::Unsigned ); } - | VOID - { $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); } - | BOOL // C99 - { $$ = DeclarationNode::newBasicType( DeclarationNode::Bool ); } - | COMPLEX // C99 - { $$ = DeclarationNode::newBasicType( DeclarationNode::Complex ); } - | IMAGINARY // C99 - { $$ = DeclarationNode::newBasicType( DeclarationNode::Imaginary ); } - ; - -basic_declaration_specifier: - // A semantic check is necessary for conflicting storage classes. - basic_type_specifier - | declaration_qualifier_list basic_type_specifier - { $$ = $2->addQualifiers( $1 ); } - | basic_declaration_specifier storage_class // remaining OBSOLESCENT (see 2) - { $$ = $1->addQualifiers( $2 ); } - | basic_declaration_specifier storage_class type_qualifier_list - { $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); } - | basic_declaration_specifier storage_class basic_type_specifier - { $$ = $3->addQualifiers( $2 )->addType( $1 ); } - ; - -basic_type_specifier: - direct_type_name - | type_qualifier_list_opt indirect_type_name type_qualifier_list_opt - { $$ = $2->addQualifiers( $1 )->addQualifiers( $3 ); } - ; - -direct_type_name: - // A semantic check is necessary for conflicting type qualifiers. - basic_type_name - | type_qualifier_list basic_type_name - { $$ = $2->addQualifiers( $1 ); } - | direct_type_name type_qualifier - { $$ = $1->addQualifiers( $2 ); } - | direct_type_name basic_type_name - { $$ = $1->addType( $2 ); } - ; - -indirect_type_name: - TYPEOF '(' type_name ')' // GCC: typeof(x) y; - { $$ = $3; } - | TYPEOF '(' comma_expression ')' // GCC: typeof(a+b) y; - { $$ = DeclarationNode::newTypeof( $3 ); } - | ATTR_TYPEGENname '(' type_name ')' // CFA: e.g., @type(x) y; - { $$ = DeclarationNode::newAttr( $1, $3 ); } - | ATTR_TYPEGENname '(' comma_expression ')' // CFA: e.g., @type(a+b) y; - { $$ = DeclarationNode::newAttr( $1, $3 ); } - ; - -sue_declaration_specifier: - sue_type_specifier - | declaration_qualifier_list sue_type_specifier - { $$ = $2->addQualifiers( $1 ); } - | sue_declaration_specifier storage_class // remaining OBSOLESCENT (see 2) - { $$ = $1->addQualifiers( $2 ); } - | sue_declaration_specifier storage_class type_qualifier_list - { $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); } - ; - -sue_type_specifier: - elaborated_type_name // struct, union, enum - | type_qualifier_list elaborated_type_name - { $$ = $2->addQualifiers( $1 ); } - | sue_type_specifier type_qualifier - { $$ = $1->addQualifiers( $2 ); } - ; - -typedef_declaration_specifier: - typedef_type_specifier - | declaration_qualifier_list typedef_type_specifier - { $$ = $2->addQualifiers( $1 ); } - | typedef_declaration_specifier storage_class // remaining OBSOLESCENT (see 2) - { $$ = $1->addQualifiers( $2 ); } - | typedef_declaration_specifier storage_class type_qualifier_list - { $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); } - ; - -typedef_type_specifier: // typedef types - TYPEDEFname - { $$ = DeclarationNode::newFromTypedef( $1 ); } - | type_qualifier_list TYPEDEFname - { $$ = DeclarationNode::newFromTypedef( $2 )->addQualifiers( $1 ); } - | typedef_type_specifier type_qualifier - { $$ = $1->addQualifiers( $2 ); } - ; - -elaborated_type_name: - aggregate_name - | enum_name - ; - -aggregate_name: - aggregate_key '{' field_declaration_list '}' - { $$ = DeclarationNode::newAggregate( $1, 0, 0, 0, $3 ); } - | aggregate_key no_attr_identifier_or_typedef_name - { $$ = DeclarationNode::newAggregate( $1, $2, 0, 0, 0 ); } - | aggregate_key no_attr_identifier_or_typedef_name '{' field_declaration_list '}' - { $$ = DeclarationNode::newAggregate( $1, $2, 0, 0, $4 ); } - | aggregate_key '(' push type_parameter_list pop ')' '{' field_declaration_list '}' // CFA - { $$ = DeclarationNode::newAggregate( $1, 0, $4, 0, $8 ); } - | aggregate_key '(' push type_parameter_list pop ')' no_attr_identifier_or_typedef_name // CFA - { $$ = DeclarationNode::newAggregate( $1, $7, $4, 0, 0 ); } - | aggregate_key '(' push type_parameter_list pop ')' no_attr_identifier_or_typedef_name '{' field_declaration_list '}' // CFA - { $$ = DeclarationNode::newAggregate( $1, $7, $4, 0, $9 ); } - | aggregate_key '(' push type_parameter_list pop ')' '(' type_name_list ')' '{' field_declaration_list '}' // CFA - { $$ = DeclarationNode::newAggregate( $1, 0, $4, $8, $11 ); } - | aggregate_key '(' push type_name_list pop ')' no_attr_identifier_or_typedef_name // CFA - // push and pop are only to prevent S/R conflicts - { $$ = DeclarationNode::newAggregate( $1, $7, 0, $4, 0 ); } - | aggregate_key '(' push type_parameter_list pop ')' '(' type_name_list ')' no_attr_identifier_or_typedef_name '{' field_declaration_list '}' // CFA - { $$ = DeclarationNode::newAggregate( $1, $10, $4, $8, $12 ); } - ; - -aggregate_key: - STRUCT attribute_list_opt - { $$ = DeclarationNode::Struct; } - | UNION attribute_list_opt - { $$ = DeclarationNode::Union; } - ; - -field_declaration_list: - field_declaration - { $$ = $1; } - | field_declaration_list field_declaration - { $$ = $1->appendList( $2 ); } - ; - -field_declaration: - new_field_declaring_list ';' // CFA, new style field declaration - | EXTENSION new_field_declaring_list ';' // GCC - { $$ = $2; } - | field_declaring_list ';' - | EXTENSION field_declaring_list ';' // GCC - { $$ = $2; } - ; - -new_field_declaring_list: // CFA, new style field declaration - new_abstract_declarator_tuple // CFA, no field name - | new_abstract_declarator_tuple no_attr_identifier_or_typedef_name - { $$ = $1->addName( $2 ); } - | new_field_declaring_list ',' no_attr_identifier_or_typedef_name - { $$ = $1->appendList( $1->cloneType( $3 ) ); } - | new_field_declaring_list ',' // CFA, no field name - { $$ = $1->appendList( $1->cloneType( 0 ) ); } - ; - -field_declaring_list: - type_specifier field_declarator - { $$ = $2->addType( $1 ); } - | field_declaring_list ',' attribute_list_opt field_declarator - { $$ = $1->appendList( $1->cloneBaseType( $4 ) ); } - ; - -field_declarator: - // empty - { $$ = DeclarationNode::newName( 0 ); /* XXX */ } // CFA, no field name - | bit_subrange_size // no field name - { $$ = DeclarationNode::newBitfield( $1 ); } - | variable_declarator bit_subrange_size_opt - // A semantic check is required to ensure bit_subrange only appears on base type int. - { $$ = $1->addBitfield( $2 ); } - | typedef_redeclarator bit_subrange_size_opt - // A semantic check is required to ensure bit_subrange only appears on base type int. - { $$ = $1->addBitfield( $2 ); } - | variable_abstract_declarator // CFA, no field name - ; - -bit_subrange_size_opt: - // empty - { $$ = 0; } - | bit_subrange_size - { $$ = $1; } - ; - -bit_subrange_size: - ':' constant_expression - { $$ = $2; } - ; - -enum_key: - ENUM attribute_list_opt - ; - -enum_name: - enum_key '{' enumerator_list comma_opt '}' - { $$ = DeclarationNode::newEnum( 0, $3 ); } - | enum_key no_attr_identifier_or_typedef_name '{' enumerator_list comma_opt '}' - { $$ = DeclarationNode::newEnum( $2, $4 ); } - | enum_key no_attr_identifier_or_typedef_name - { $$ = DeclarationNode::newEnum( $2, 0 ); } - ; - -enumerator_list: - no_attr_identifier_or_typedef_name enumerator_value_opt - { $$ = DeclarationNode::newEnumConstant( $1, $2 ); } - | enumerator_list ',' no_attr_identifier_or_typedef_name enumerator_value_opt - { $$ = $1->appendList( DeclarationNode::newEnumConstant( $3, $4 ) ); } - ; - -enumerator_value_opt: - // empty - { $$ = 0; } - | '=' constant_expression - { $$ = $2; } - ; - -// Minimum of one parameter after which ellipsis is allowed only at the end. - -new_parameter_type_list_opt: // CFA - // empty - { $$ = 0; } - | new_parameter_type_list - ; - -new_parameter_type_list: // CFA, abstract + real - new_abstract_parameter_list - | new_parameter_list - | new_parameter_list pop ',' push new_abstract_parameter_list - { $$ = $1->appendList( $5 ); } - | new_abstract_parameter_list pop ',' push ELLIPSIS - { $$ = $1->addVarArgs(); } - | new_parameter_list pop ',' push ELLIPSIS - { $$ = $1->addVarArgs(); } - ; - -new_parameter_list: // CFA - // To obtain LR(1) between new_parameter_list and new_abstract_tuple, the last - // new_abstract_parameter_list is factored out from new_parameter_list, flattening the rules to get - // lookahead to the ']'. - new_parameter_declaration - | new_abstract_parameter_list pop ',' push new_parameter_declaration - { $$ = $1->appendList( $5 ); } - | new_parameter_list pop ',' push new_parameter_declaration - { $$ = $1->appendList( $5 ); } - | new_parameter_list pop ',' push new_abstract_parameter_list pop ',' push new_parameter_declaration - { $$ = $1->appendList( $5 )->appendList( $9 ); } - ; - -new_abstract_parameter_list: // CFA, new & old style abstract - new_abstract_parameter_declaration - | new_abstract_parameter_list pop ',' push new_abstract_parameter_declaration - { $$ = $1->appendList( $5 ); } - ; - -parameter_type_list_opt: - // empty - { $$ = 0; } - | parameter_type_list - ; - -parameter_type_list: - parameter_list - | parameter_list pop ',' push ELLIPSIS - { $$ = $1->addVarArgs(); } - ; - -parameter_list: // abstract + real - abstract_parameter_declaration - | parameter_declaration - | parameter_list pop ',' push abstract_parameter_declaration - { $$ = $1->appendList( $5 ); } - | parameter_list pop ',' push parameter_declaration - { $$ = $1->appendList( $5 ); } - ; - -// Provides optional identifier names (abstract_declarator/variable_declarator), no initialization, different -// semantics for typedef name by using typedef_parameter_redeclarator instead of typedef_redeclarator, and -// function prototypes. - -new_parameter_declaration: // CFA, new & old style parameter declaration - parameter_declaration - | new_identifier_parameter_declarator_no_tuple identifier_or_typedef_name assignment_opt - { $$ = $1->addName( $2 ); } - | new_abstract_tuple identifier_or_typedef_name assignment_opt - // To obtain LR(1), these rules must be duplicated here (see new_abstract_declarator). - { $$ = $1->addName( $2 ); } - | type_qualifier_list new_abstract_tuple identifier_or_typedef_name assignment_opt - { $$ = $2->addName( $3 )->addQualifiers( $1 ); } - | new_function_specifier - ; - -new_abstract_parameter_declaration: // CFA, new & old style parameter declaration - abstract_parameter_declaration - | new_identifier_parameter_declarator_no_tuple - | new_abstract_tuple - // To obtain LR(1), these rules must be duplicated here (see new_abstract_declarator). - | type_qualifier_list new_abstract_tuple - { $$ = $2->addQualifiers( $1 ); } - | new_abstract_function - ; - -parameter_declaration: - declaration_specifier identifier_parameter_declarator assignment_opt - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - $$ = $2->addType( $1 )->addInitializer( new InitializerNode($3) ); - } - | declaration_specifier typedef_parameter_redeclarator assignment_opt - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - $$ = $2->addType( $1 )->addInitializer( new InitializerNode($3) ); - } - ; - -abstract_parameter_declaration: - declaration_specifier - | declaration_specifier abstract_parameter_declarator - { $$ = $2->addType( $1 ); } - ; - -// ISO/IEC 9899:1999 Section 6.9.1(6) : "An identifier declared as a typedef name shall not be redeclared as a -// parameter." Because the scope of the K&R-style parameter-list sees the typedef first, the following is -// based only on identifiers. The ANSI-style parameter-list can redefine a typedef name. - -identifier_list: // K&R-style parameter list => no types - no_attr_identifier - { $$ = DeclarationNode::newName( $1 ); } - | identifier_list ',' no_attr_identifier - { $$ = $1->appendList( DeclarationNode::newName( $3 ) ); } - ; - -identifier_or_typedef_name: - identifier - | TYPEDEFname - | TYPEGENname - ; - -no_01_identifier_or_typedef_name: - no_01_identifier - | TYPEDEFname - | TYPEGENname - ; - -no_attr_identifier_or_typedef_name: - no_attr_identifier - | TYPEDEFname - | TYPEGENname - ; - -type_name_no_function: // sizeof, alignof, cast (constructor) - new_abstract_declarator_tuple // CFA - | type_specifier - | type_specifier variable_abstract_declarator - { $$ = $2->addType( $1 ); } - ; - -type_name: // typeof, assertion - new_abstract_declarator_tuple // CFA - | new_abstract_function // CFA - | type_specifier - | type_specifier abstract_declarator - { $$ = $2->addType( $1 ); } - ; - -initializer_opt: - // empty - { $$ = 0; } - | '=' initializer { $$ = $2; } - ; - -initializer: - assignment_expression { $$ = new InitializerNode($1); } - | '{' initializer_list comma_opt '}' { $$ = new InitializerNode($2, true); } - ; - -initializer_list: - initializer - | designation initializer { $$ = $2->set_designators( $1 ); } - | initializer_list ',' initializer { $$ = (InitializerNode *)( $1->set_link($3) ); } - | initializer_list ',' designation initializer - { $$ = (InitializerNode *)( $1->set_link( $4->set_designators($3) ) ); } - ; - -// There is an unreconcileable parsing problem between C99 and CFA with respect to designators. The problem is -// use of '=' to separator the designator from the initializer value, as in: -// -// int x[10] = { [1] = 3 }; -// -// The string "[1] = 3" can be parsed as a designator assignment or a tuple assignment. To disambiguate this -// case, CFA changes the syntax from "=" to ":" as the separator between the designator and initializer. GCC -// does uses ":" for field selection. The optional use of the "=" in GCC, or in this case ":", cannot be -// supported either due to shift/reduce conflicts - -designation: - designator_list ':' // C99, CFA uses ":" instead of "=" - | no_attr_identifier_or_typedef_name ':' // GCC, field name - { $$ = new VarRefNode( $1 ); } - ; - -designator_list: // C99 - designator - | designator_list designator { $$ = (ExpressionNode *)($1->set_link( $2 )); } - ; - -designator: - '.' no_attr_identifier_or_typedef_name // C99, field name - { $$ = new VarRefNode( $2 ); } - | '[' push assignment_expression pop ']' // C99, single array element - // assignment_expression used instead of constant_expression because of shift/reduce conflicts with - // tuple. - { $$ = $3; } - | '[' push subrange pop ']' // CFA, multiple array elements - { $$ = $3; } - | '[' push constant_expression ELLIPSIS constant_expression pop ']' // GCC, multiple array elements - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Range), $3, $5); } - | '.' '[' push field_list pop ']' // CFA, tuple field selector - { $$ = $4; } - ; - -// The CFA type system is based on parametric polymorphism, the ability to declare functions with type -// parameters, rather than an object-oriented type system. This required four groups of extensions: -// -// Overloading: function, data, and operator identifiers may be overloaded. -// -// Type declarations: "type" is used to generate new types for declaring objects. Similarly, "dtype" is used -// for object and incomplete types, and "ftype" is used for function types. Type declarations with -// initializers provide definitions of new types. Type declarations with storage class "extern" provide -// opaque types. -// -// Polymorphic functions: A forall clause declares a type parameter. The corresponding argument is inferred at -// the call site. A polymorphic function is not a template; it is a function, with an address and a type. -// -// Specifications and Assertions: Specifications are collections of declarations parameterized by one or more -// types. They serve many of the purposes of abstract classes, and specification hierarchies resemble -// subclass hierarchies. Unlike classes, they can define relationships between types. Assertions declare -// that a type or types provide the operations declared by a specification. Assertions are normally used -// to declare requirements on type arguments of polymorphic functions. - -typegen_declaration_specifier: // CFA - typegen_type_specifier - | declaration_qualifier_list typegen_type_specifier - { $$ = $2->addQualifiers( $1 ); } - | typegen_declaration_specifier storage_class // remaining OBSOLESCENT (see 2) - { $$ = $1->addQualifiers( $2 ); } - | typegen_declaration_specifier storage_class type_qualifier_list - { $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); } - ; - -typegen_type_specifier: // CFA - TYPEGENname '(' type_name_list ')' - { $$ = DeclarationNode::newFromTypeGen( $1, $3 ); } - | type_qualifier_list TYPEGENname '(' type_name_list ')' - { $$ = DeclarationNode::newFromTypeGen( $2, $4 )->addQualifiers( $1 ); } - | typegen_type_specifier type_qualifier - { $$ = $1->addQualifiers( $2 ); } - ; - -type_parameter_list: // CFA - type_parameter assignment_opt - | type_parameter_list ',' type_parameter assignment_opt - { $$ = $1->appendList( $3 ); } - ; - -type_parameter: // CFA - type_class no_attr_identifier_or_typedef_name - { typedefTable.addToEnclosingScope(*($2), TypedefTable::TD); } - assertion_list_opt - { $$ = DeclarationNode::newTypeParam( $1, $2 )->addAssertions( $4 ); } - | type_specifier identifier_parameter_declarator - ; - -type_class: // CFA - TYPE - { $$ = DeclarationNode::Type; } - | DTYPE - { $$ = DeclarationNode::Ftype; } - | FTYPE - { $$ = DeclarationNode::Dtype; } - ; - -assertion_list_opt: // CFA - // empty - { $$ = 0; } - | assertion_list_opt assertion - { $$ = $1 == 0 ? $2 : $1->appendList( $2 ); } - ; - -assertion: // CFA - '|' no_attr_identifier_or_typedef_name '(' type_name_list ')' - { - typedefTable.openContext( *($2) ); - $$ = DeclarationNode::newContextUse( $2, $4 ); - } - | '|' '{' push context_declaration_list '}' - { $$ = $4; } - | '|' '(' push type_parameter_list pop ')' '{' push context_declaration_list '}' '(' type_name_list ')' - { $$ = 0; } - ; - -type_name_list: // CFA - type_name - { $$ = new TypeValueNode( $1 ); } - | assignment_expression - | type_name_list ',' type_name - { $$ = (ExpressionNode *)($1->set_link(new TypeValueNode( $3 ))); } - | type_name_list ',' assignment_expression - { $$ = (ExpressionNode *)($1->set_link($3)); } - ; - -type_declaring_list: // CFA - TYPE type_declarator - { $$ = $2; } - | storage_class_list TYPE type_declarator - { $$ = $3->addQualifiers( $1 ); } - | type_declaring_list ',' type_declarator - { $$ = $1->appendList( $3->copyStorageClasses( $1 ) ); } - ; - -type_declarator: // CFA - type_declarator_name assertion_list_opt - { $$ = $1->addAssertions( $2 ); } - | type_declarator_name assertion_list_opt '=' type_name - { $$ = $1->addAssertions( $2 )->addType( $4 ); } - ; - -type_declarator_name: // CFA - no_attr_identifier_or_typedef_name - { - typedefTable.addToEnclosingScope(*($1), TypedefTable::TD); - $$ = DeclarationNode::newTypeDecl( $1, 0 ); - } - | no_01_identifier_or_typedef_name '(' push type_parameter_list pop ')' - { - typedefTable.addToEnclosingScope(*($1), TypedefTable::TG); - $$ = DeclarationNode::newTypeDecl( $1, $4 ); - } - ; - -context_specifier: // CFA - CONTEXT no_attr_identifier_or_typedef_name '(' push type_parameter_list pop ')' '{' '}' - { - typedefTable.addToEnclosingScope(*($2), TypedefTable::ID ); - $$ = DeclarationNode::newContext( $2, $5, 0 ); - } - | CONTEXT no_attr_identifier_or_typedef_name '(' push type_parameter_list pop ')' '{' - { - typedefTable.enterContext( *($2) ); - typedefTable.enterScope(); - } - context_declaration_list '}' - { - typedefTable.leaveContext(); - typedefTable.addToEnclosingScope(*($2), TypedefTable::ID ); - $$ = DeclarationNode::newContext( $2, $5, $10 ); - } - ; - -context_declaration_list: // CFA - context_declaration - | context_declaration_list push context_declaration - { $$ = $1->appendList( $3 ); } - ; - -context_declaration: // CFA - new_context_declaring_list pop ';' - | context_declaring_list pop ';' - ; - -new_context_declaring_list: // CFA - new_variable_specifier - { - typedefTable.addToEnclosingScope2( TypedefTable::ID ); - $$ = $1; - } - | new_function_specifier - { - typedefTable.addToEnclosingScope2( TypedefTable::ID ); - $$ = $1; - } - | new_context_declaring_list pop ',' push identifier_or_typedef_name - { - typedefTable.addToEnclosingScope2( *($5), TypedefTable::ID ); - $$ = $1->appendList( $1->cloneType( $5 ) ); - } - ; - -context_declaring_list: // CFA - type_specifier declarator - { - typedefTable.addToEnclosingScope2( TypedefTable::ID ); - $$ = $2->addType( $1 ); - } - | context_declaring_list pop ',' push declarator - { - typedefTable.addToEnclosingScope2( TypedefTable::ID ); - $$ = $1->appendList( $1->cloneBaseType( $5 ) ); - } - ; - -//***************************** EXTERNAL DEFINITIONS ***************************** - -translation_unit: - // empty - {} // empty input file - | external_definition_list - { - if ( theTree ) { - theTree->appendList( $1 ); - } else { - theTree = $1; - } - } - ; - -external_definition_list: - external_definition - | external_definition_list push external_definition - { $$ = ($1 != NULL ) ? $1->appendList( $3 ) : $3; } - ; - -external_definition_list_opt: - // empty - { $$ = 0; } - | external_definition_list - ; - -external_definition: - declaration - | external_function_definition - | asm_statement // GCC, global assembler statement - {} - | EXTERN STRINGliteral - { - linkageStack.push( linkage ); - linkage = LinkageSpec::fromString( *$2 ); - } - '{' external_definition_list_opt '}' // C++-style linkage specifier - { - linkage = linkageStack.top(); - linkageStack.pop(); - $$ = $5; - } - | EXTENSION external_definition - { $$ = $2; } - ; - -external_function_definition: - function_definition - - // These rules are a concession to the "implicit int" type_specifier because there is a significant - // amount of code with functions missing a type-specifier on the return type. Parsing is possible - // because function_definition does not appear in the context of an expression (nested functions would - // preclude this concession). A function prototype declaration must still have a type_specifier. - // OBSOLESCENT (see 1) - | function_declarator compound_statement - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - typedefTable.leaveScope(); - $$ = $1->addFunctionBody( $2 ); - } - | old_function_declarator push old_declaration_list_opt compound_statement - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - typedefTable.leaveScope(); - $$ = $1->addOldDeclList( $3 )->addFunctionBody( $4 ); - } - ; - -function_definition: - new_function_declaration compound_statement // CFA - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - typedefTable.leaveScope(); - $$ = $1->addFunctionBody( $2 ); - } - | declaration_specifier function_declarator compound_statement - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - typedefTable.leaveScope(); - $$ = $2->addFunctionBody( $3 )->addType( $1 ); - } - | type_qualifier_list function_declarator compound_statement - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - typedefTable.leaveScope(); - $$ = $2->addFunctionBody( $3 )->addQualifiers( $1 ); - } - | declaration_qualifier_list function_declarator compound_statement - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - typedefTable.leaveScope(); - $$ = $2->addFunctionBody( $3 )->addQualifiers( $1 ); - } - | declaration_qualifier_list type_qualifier_list function_declarator compound_statement - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - typedefTable.leaveScope(); - $$ = $3->addFunctionBody( $4 )->addQualifiers( $2 )->addQualifiers( $1 ); - } - - // Old-style K&R function definition, OBSOLESCENT (see 4) - | declaration_specifier old_function_declarator push old_declaration_list_opt compound_statement - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - typedefTable.leaveScope(); - $$ = $2->addOldDeclList( $4 )->addFunctionBody( $5 )->addType( $1 ); - } - | type_qualifier_list old_function_declarator push old_declaration_list_opt compound_statement - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - typedefTable.leaveScope(); - $$ = $2->addOldDeclList( $4 )->addFunctionBody( $5 )->addQualifiers( $1 ); - } - - // Old-style K&R function definition with "implicit int" type_specifier, OBSOLESCENT (see 4) - | declaration_qualifier_list old_function_declarator push old_declaration_list_opt compound_statement - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - typedefTable.leaveScope(); - $$ = $2->addOldDeclList( $4 )->addFunctionBody( $5 )->addQualifiers( $1 ); - } - | declaration_qualifier_list type_qualifier_list old_function_declarator push old_declaration_list_opt compound_statement - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - typedefTable.leaveScope(); - $$ = $3->addOldDeclList( $5 )->addFunctionBody( $6 )->addQualifiers( $2 )->addQualifiers( $1 ); - } - ; - -declarator: - variable_declarator - | function_declarator - | typedef_redeclarator - ; - -subrange: - constant_expression '~' constant_expression // CFA, integer subrange - { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Range), $1, $3); } - ; - -asm_name_opt: // GCC - // empty - | ASM '(' string_literal_list ')' attribute_list_opt - ; - -attribute_list_opt: // GCC - // empty - | attribute_list - ; - -attribute_list: // GCC - attribute - | attribute_list attribute - ; - -attribute: // GCC - ATTRIBUTE '(' '(' attribute_parameter_list ')' ')' - ; - -attribute_parameter_list: // GCC - attrib - | attribute_parameter_list ',' attrib - ; - -attrib: // GCC - // empty - | any_word - | any_word '(' comma_expression_opt ')' - ; - -any_word: // GCC - identifier_or_typedef_name {} - | storage_class_name {} - | basic_type_name {} - | type_qualifier {} - ; - -// ============================================================================ -// The following sections are a series of grammar patterns used to parse declarators. Multiple patterns are -// necessary because the type of an identifier in wrapped around the identifier in the same form as its usage -// in an expression, as in: -// -// int (*f())[10] { ... }; -// ... (*f())[3] += 1; // definition mimics usage -// -// Because these patterns are highly recursive, changes at a lower level in the recursion require copying some -// or all of the pattern. Each of these patterns has some subtle variation to ensure correct syntax in a -// particular context. -// ============================================================================ - -// ---------------------------------------------------------------------------- -// The set of valid declarators before a compound statement for defining a function is less than the set of -// declarators to define a variable or function prototype, e.g.: -// -// valid declaration invalid definition -// ----------------- ------------------ -// int f; int f {} -// int *f; int *f {} -// int f[10]; int f[10] {} -// int (*f)(int); int (*f)(int) {} -// -// To preclude this syntactic anomaly requires separating the grammar rules for variable and function -// declarators, hence variable_declarator and function_declarator. -// ---------------------------------------------------------------------------- - -// This pattern parses a declaration of a variable that is not redefining a typedef name. The pattern -// precludes declaring an array of functions versus a pointer to an array of functions. - -variable_declarator: - paren_identifier attribute_list_opt - | variable_ptr - | variable_array attribute_list_opt - | variable_function attribute_list_opt - ; - -paren_identifier: - identifier - { - typedefTable.setNextIdentifier( *($1) ); - $$ = DeclarationNode::newName( $1 ); - } - | '(' paren_identifier ')' // redundant parenthesis - { $$ = $2; } - ; - -variable_ptr: - '*' variable_declarator - { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); } - | '*' type_qualifier_list variable_declarator - { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); } - | '(' variable_ptr ')' - { $$ = $2; } - ; - -variable_array: - paren_identifier array_dimension - { $$ = $1->addArray( $2 ); } - | '(' variable_ptr ')' array_dimension - { $$ = $2->addArray( $4 ); } - | '(' variable_array ')' multi_array_dimension // redundant parenthesis - { $$ = $2->addArray( $4 ); } - | '(' variable_array ')' // redundant parenthesis - { $$ = $2; } - ; - -variable_function: - '(' variable_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) - { $$ = $2->addParamList( $6 ); } - | '(' variable_function ')' // redundant parenthesis - { $$ = $2; } - ; - -// This pattern parses a function declarator that is not redefining a typedef name. Because functions cannot -// be nested, there is no context where a function definition can redefine a typedef name. To allow nested -// functions requires further separation of variable and function declarators in typedef_redeclarator. The -// pattern precludes returning arrays and functions versus pointers to arrays and functions. - -function_declarator: - function_no_ptr attribute_list_opt - | function_ptr - | function_array attribute_list_opt - ; - -function_no_ptr: - paren_identifier '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) - { $$ = $1->addParamList( $4 ); } - | '(' function_ptr ')' '(' push parameter_type_list_opt pop ')' - { $$ = $2->addParamList( $6 ); } - | '(' function_no_ptr ')' // redundant parenthesis - { $$ = $2; } - ; - -function_ptr: - '*' function_declarator - { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); } - | '*' type_qualifier_list function_declarator - { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); } - | '(' function_ptr ')' - { $$ = $2; } - ; - -function_array: - '(' function_ptr ')' array_dimension - { $$ = $2->addArray( $4 ); } - | '(' function_array ')' multi_array_dimension // redundant parenthesis - { $$ = $2->addArray( $4 ); } - | '(' function_array ')' // redundant parenthesis - { $$ = $2; } - ; - -// This pattern parses an old-style K&R function declarator (OBSOLESCENT, see 4) that is not redefining a -// typedef name (see function_declarator for additional comments). The pattern precludes returning arrays and -// functions versus pointers to arrays and functions. - -old_function_declarator: - old_function_no_ptr - | old_function_ptr - | old_function_array - ; - -old_function_no_ptr: - paren_identifier '(' identifier_list ')' // function_declarator handles empty parameter - { $$ = $1->addIdList( $3 ); } - | '(' old_function_ptr ')' '(' identifier_list ')' - { $$ = $2->addIdList( $5 ); } - | '(' old_function_no_ptr ')' // redundant parenthesis - { $$ = $2; } - ; - -old_function_ptr: - '*' old_function_declarator - { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); } - | '*' type_qualifier_list old_function_declarator - { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); } - | '(' old_function_ptr ')' - { $$ = $2; } - ; - -old_function_array: - '(' old_function_ptr ')' array_dimension - { $$ = $2->addArray( $4 ); } - | '(' old_function_array ')' multi_array_dimension // redundant parenthesis - { $$ = $2->addArray( $4 ); } - | '(' old_function_array ')' // redundant parenthesis - { $$ = $2; } - ; - -// This pattern parses a declaration for a variable or function prototype that redefines a typedef name, e.g.: -// -// typedef int foo; -// { -// int foo; // redefine typedef name in new scope -// } -// -// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and -// returning arrays and functions versus pointers to arrays and functions. - -typedef_redeclarator: - paren_typedef attribute_list_opt - | typedef_ptr - | typedef_array attribute_list_opt - | typedef_function attribute_list_opt - ; - -paren_typedef: - TYPEDEFname - { - typedefTable.setNextIdentifier( *($1) ); - $$ = DeclarationNode::newName( $1 ); - } - | '(' paren_typedef ')' - { $$ = $2; } - ; - -typedef_ptr: - '*' typedef_redeclarator - { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); } - | '*' type_qualifier_list typedef_redeclarator - { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); } - | '(' typedef_ptr ')' - { $$ = $2; } - ; - -typedef_array: - paren_typedef array_dimension - { $$ = $1->addArray( $2 ); } - | '(' typedef_ptr ')' array_dimension - { $$ = $2->addArray( $4 ); } - | '(' typedef_array ')' multi_array_dimension // redundant parenthesis - { $$ = $2->addArray( $4 ); } - | '(' typedef_array ')' // redundant parenthesis - { $$ = $2; } - ; - -typedef_function: - paren_typedef '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) - { $$ = $1->addParamList( $4 ); } - | '(' typedef_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) - { $$ = $2->addParamList( $6 ); } - | '(' typedef_function ')' // redundant parenthesis - { $$ = $2; } - ; - -// This pattern parses a declaration for a parameter variable or function prototype that is not redefining a -// typedef name and allows the C99 array options, which can only appear in a parameter list. The pattern -// precludes declaring an array of functions versus a pointer to an array of functions, and returning arrays -// and functions versus pointers to arrays and functions. - -identifier_parameter_declarator: - paren_identifier attribute_list_opt - | identifier_parameter_ptr - | identifier_parameter_array attribute_list_opt - | identifier_parameter_function attribute_list_opt - ; - -identifier_parameter_ptr: - '*' identifier_parameter_declarator - { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); } - | '*' type_qualifier_list identifier_parameter_declarator - { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); } - | '(' identifier_parameter_ptr ')' - { $$ = $2; } - ; - -identifier_parameter_array: - paren_identifier array_parameter_dimension - { $$ = $1->addArray( $2 ); } - | '(' identifier_parameter_ptr ')' array_dimension - { $$ = $2->addArray( $4 ); } - | '(' identifier_parameter_array ')' multi_array_dimension // redundant parenthesis - { $$ = $2->addArray( $4 ); } - | '(' identifier_parameter_array ')' // redundant parenthesis - { $$ = $2; } - ; - -identifier_parameter_function: - paren_identifier '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) - { $$ = $1->addParamList( $4 ); } - | '(' identifier_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) - { $$ = $2->addParamList( $6 ); } - | '(' identifier_parameter_function ')' // redundant parenthesis - { $$ = $2; } - ; - -// This pattern parses a declaration for a parameter variable or function prototype that is redefining a -// typedef name, e.g.: -// -// typedef int foo; -// int f( int foo ); // redefine typedef name in new scope -// -// and allows the C99 array options, which can only appear in a parameter list. In addition, the pattern -// handles the special meaning of parenthesis around a typedef name: -// -// ISO/IEC 9899:1999 Section 6.7.5.3(11) : "In a parameter declaration, a single typedef name in -// parentheses is taken to be an abstract declarator that specifies a function with a single parameter, -// not as redundant parentheses around the identifier." -// -// which precludes the following cases: -// -// typedef float T; -// int f( int ( T [5] ) ); // see abstract_parameter_declarator -// int g( int ( T ( int ) ) ); // see abstract_parameter_declarator -// int f( int f1( T a[5] ) ); // see identifier_parameter_declarator -// int g( int g1( T g2( int p ) ) ); // see identifier_parameter_declarator -// -// In essence, a '(' immediately to the left of typedef name, T, is interpreted as starting a parameter type -// list, and not as redundant parentheses around a redeclaration of T. Finally, the pattern also precludes -// declaring an array of functions versus a pointer to an array of functions, and returning arrays and -// functions versus pointers to arrays and functions. - -typedef_parameter_redeclarator: - typedef attribute_list_opt - | typedef_parameter_ptr - | typedef_parameter_array attribute_list_opt - | typedef_parameter_function attribute_list_opt - ; - -typedef: - TYPEDEFname - { - typedefTable.setNextIdentifier( *($1) ); - $$ = DeclarationNode::newName( $1 ); - } - ; - -typedef_parameter_ptr: - '*' typedef_parameter_redeclarator - { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); } - | '*' type_qualifier_list typedef_parameter_redeclarator - { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); } - | '(' typedef_parameter_ptr ')' - { $$ = $2; } - ; - -typedef_parameter_array: - typedef array_parameter_dimension - { $$ = $1->addArray( $2 ); } - | '(' typedef_parameter_ptr ')' array_parameter_dimension - { $$ = $2->addArray( $4 ); } - ; - -typedef_parameter_function: - typedef '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) - { $$ = $1->addParamList( $4 ); } - | '(' typedef_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) - { $$ = $2->addParamList( $6 ); } - ; - -// This pattern parses a declaration of an abstract variable or function prototype, i.e., there is no -// identifier to which the type applies, e.g.: -// -// sizeof( int ); -// sizeof( int [10] ); -// -// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and -// returning arrays and functions versus pointers to arrays and functions. - -abstract_declarator: - abstract_ptr - | abstract_array attribute_list_opt - | abstract_function attribute_list_opt - ; - -abstract_ptr: - '*' - { $$ = DeclarationNode::newPointer( 0 ); } - | '*' type_qualifier_list - { $$ = DeclarationNode::newPointer( $2 ); } - | '*' abstract_declarator - { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); } - | '*' type_qualifier_list abstract_declarator - { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); } - | '(' abstract_ptr ')' - { $$ = $2; } - ; - -abstract_array: - array_dimension - | '(' abstract_ptr ')' array_dimension - { $$ = $2->addArray( $4 ); } - | '(' abstract_array ')' multi_array_dimension // redundant parenthesis - { $$ = $2->addArray( $4 ); } - | '(' abstract_array ')' // redundant parenthesis - { $$ = $2; } - ; - -abstract_function: - '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) - { $$ = DeclarationNode::newFunction( 0, 0, $3, 0 ); } - | '(' abstract_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) - { $$ = $2->addParamList( $6 ); } - | '(' abstract_function ')' // redundant parenthesis - { $$ = $2; } - ; - -array_dimension: - // Only the first dimension can be empty. - '[' push pop ']' - { $$ = DeclarationNode::newArray( 0, 0, false ); } - | '[' push pop ']' multi_array_dimension - { $$ = DeclarationNode::newArray( 0, 0, false )->addArray( $5 ); } - | multi_array_dimension - ; - -multi_array_dimension: - '[' push assignment_expression pop ']' - { $$ = DeclarationNode::newArray( $3, 0, false ); } - | '[' push '*' pop ']' // C99 - { $$ = DeclarationNode::newVarArray( 0 ); } - | multi_array_dimension '[' push assignment_expression pop ']' - { $$ = $1->addArray( DeclarationNode::newArray( $4, 0, false ) ); } - | multi_array_dimension '[' push '*' pop ']' // C99 - { $$ = $1->addArray( DeclarationNode::newVarArray( 0 ) ); } - ; - -// This pattern parses a declaration of a parameter abstract variable or function prototype, i.e., there is no -// identifier to which the type applies, e.g.: -// -// int f( int ); // abstract variable parameter; no parameter name specified -// int f( int (int) ); // abstract function-prototype parameter; no parameter name specified -// -// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and -// returning arrays and functions versus pointers to arrays and functions. - -abstract_parameter_declarator: - abstract_parameter_ptr - | abstract_parameter_array attribute_list_opt - | abstract_parameter_function attribute_list_opt - ; - -abstract_parameter_ptr: - '*' - { $$ = DeclarationNode::newPointer( 0 ); } - | '*' type_qualifier_list - { $$ = DeclarationNode::newPointer( $2 ); } - | '*' abstract_parameter_declarator - { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); } - | '*' type_qualifier_list abstract_parameter_declarator - { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); } - | '(' abstract_parameter_ptr ')' - { $$ = $2; } - ; - -abstract_parameter_array: - array_parameter_dimension - | '(' abstract_parameter_ptr ')' array_parameter_dimension - { $$ = $2->addArray( $4 ); } - | '(' abstract_parameter_array ')' multi_array_dimension // redundant parenthesis - { $$ = $2->addArray( $4 ); } - | '(' abstract_parameter_array ')' // redundant parenthesis - { $$ = $2; } - ; - -abstract_parameter_function: - '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) - { $$ = DeclarationNode::newFunction( 0, 0, $3, 0 ); } - | '(' abstract_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) - { $$ = $2->addParamList( $6 ); } - | '(' abstract_parameter_function ')' // redundant parenthesis - { $$ = $2; } - ; - -array_parameter_dimension: - // Only the first dimension can be empty or have qualifiers. - array_parameter_1st_dimension - | array_parameter_1st_dimension multi_array_dimension - { $$ = $1->addArray( $2 ); } - | multi_array_dimension - ; - -// The declaration of an array parameter has additional syntax over arrays in normal variable declarations: -// -// ISO/IEC 9899:1999 Section 6.7.5.2(1) : "The optional type qualifiers and the keyword static shall -// appear only in a declaration of a function parameter with an array type, and then only in the -// outermost array type derivation." - -array_parameter_1st_dimension: - '[' push pop ']' - { $$ = DeclarationNode::newArray( 0, 0, false ); } - // multi_array_dimension handles the '[' '*' ']' case - | '[' push type_qualifier_list '*' pop ']' // remaining C99 - { $$ = DeclarationNode::newVarArray( $3 ); } - | '[' push type_qualifier_list pop ']' - { $$ = DeclarationNode::newArray( 0, $3, false ); } - // multi_array_dimension handles the '[' assignment_expression ']' case - | '[' push type_qualifier_list assignment_expression pop ']' - { $$ = DeclarationNode::newArray( $4, $3, false ); } - | '[' push STATIC type_qualifier_list_opt assignment_expression pop ']' - { $$ = DeclarationNode::newArray( $5, $4, true ); } - | '[' push type_qualifier_list STATIC assignment_expression pop ']' - { $$ = DeclarationNode::newArray( $5, $3, true ); } - ; - -// This pattern parses a declaration of an abstract variable, i.e., there is no identifier to which the type -// applies, e.g.: -// -// sizeof( int ); // abstract variable; no identifier name specified -// -// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and -// returning arrays and functions versus pointers to arrays and functions. - -variable_abstract_declarator: - variable_abstract_ptr - | variable_abstract_array attribute_list_opt - | variable_abstract_function attribute_list_opt - ; - -variable_abstract_ptr: - '*' - { $$ = DeclarationNode::newPointer( 0 ); } - | '*' type_qualifier_list - { $$ = DeclarationNode::newPointer( $2 ); } - | '*' variable_abstract_declarator - { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); } - | '*' type_qualifier_list variable_abstract_declarator - { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); } - | '(' variable_abstract_ptr ')' - { $$ = $2; } - ; - -variable_abstract_array: - array_dimension - | '(' variable_abstract_ptr ')' array_dimension - { $$ = $2->addArray( $4 ); } - | '(' variable_abstract_array ')' multi_array_dimension // redundant parenthesis - { $$ = $2->addArray( $4 ); } - | '(' variable_abstract_array ')' // redundant parenthesis - { $$ = $2; } - ; - -variable_abstract_function: - '(' variable_abstract_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) - { $$ = $2->addParamList( $6 ); } - | '(' variable_abstract_function ')' // redundant parenthesis - { $$ = $2; } - ; - -// This pattern parses a new-style declaration for a parameter variable or function prototype that is either -// an identifier or typedef name and allows the C99 array options, which can only appear in a parameter list. - -new_identifier_parameter_declarator_tuple: // CFA - new_identifier_parameter_declarator_no_tuple - | new_abstract_tuple - | type_qualifier_list new_abstract_tuple - { $$ = $2->addQualifiers( $1 ); } - ; - -new_identifier_parameter_declarator_no_tuple: // CFA - new_identifier_parameter_ptr - | new_identifier_parameter_array - ; - -new_identifier_parameter_ptr: // CFA - '*' type_specifier - { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); } - | type_qualifier_list '*' type_specifier - { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); } - | '*' new_abstract_function - { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); } - | type_qualifier_list '*' new_abstract_function - { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); } - | '*' new_identifier_parameter_declarator_tuple - { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); } - | type_qualifier_list '*' new_identifier_parameter_declarator_tuple - { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); } - ; - -new_identifier_parameter_array: // CFA - // Only the first dimension can be empty or have qualifiers. Empty dimension must be factored out due - // to shift/reduce conflict with new-style empty (void) function return type. - '[' push pop ']' type_specifier - { $$ = $5->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } - | new_array_parameter_1st_dimension type_specifier - { $$ = $2->addNewArray( $1 ); } - | '[' push pop ']' multi_array_dimension type_specifier - { $$ = $6->addNewArray( $5 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } - | new_array_parameter_1st_dimension multi_array_dimension type_specifier - { $$ = $3->addNewArray( $2 )->addNewArray( $1 ); } - | multi_array_dimension type_specifier - { $$ = $2->addNewArray( $1 ); } - | '[' push pop ']' new_identifier_parameter_ptr - { $$ = $5->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } - | new_array_parameter_1st_dimension new_identifier_parameter_ptr - { $$ = $2->addNewArray( $1 ); } - | '[' push pop ']' multi_array_dimension new_identifier_parameter_ptr - { $$ = $6->addNewArray( $5 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } - | new_array_parameter_1st_dimension multi_array_dimension new_identifier_parameter_ptr - { $$ = $3->addNewArray( $2 )->addNewArray( $1 ); } - | multi_array_dimension new_identifier_parameter_ptr - { $$ = $2->addNewArray( $1 ); } - ; - -new_array_parameter_1st_dimension: - '[' push type_qualifier_list '*' pop ']' // remaining C99 - { $$ = DeclarationNode::newVarArray( $3 ); } - | '[' push type_qualifier_list assignment_expression pop ']' - { $$ = DeclarationNode::newArray( $4, $3, false ); } - | '[' push declaration_qualifier_list assignment_expression pop ']' - // declaration_qualifier_list must be used because of shift/reduce conflict with - // assignment_expression, so a semantic check is necessary to preclude them as a type_qualifier cannot - // appear in this context. - { $$ = DeclarationNode::newArray( $4, $3, true ); } - | '[' push declaration_qualifier_list type_qualifier_list assignment_expression pop ']' - { $$ = DeclarationNode::newArray( $5, $4->addQualifiers( $3 ), true ); } - ; - -// This pattern parses a new-style declaration of an abstract variable or function prototype, i.e., there is -// no identifier to which the type applies, e.g.: -// -// [int] f( int ); // abstract variable parameter; no parameter name specified -// [int] f( [int] (int) ); // abstract function-prototype parameter; no parameter name specified -// -// These rules need LR(3): -// -// new_abstract_tuple identifier_or_typedef_name -// '[' new_parameter_list ']' identifier_or_typedef_name '(' new_parameter_type_list_opt ')' -// -// since a function return type can be syntactically identical to a tuple type: -// -// [int, int] t; -// [int, int] f( int ); -// -// Therefore, it is necessary to look at the token after identifier_or_typedef_name to know when to reduce -// new_abstract_tuple. To make this LR(1), several rules have to be flattened (lengthened) to allow the -// necessary lookahead. To accomplish this, new_abstract_declarator has an entry point without tuple, and -// tuple declarations are duplicated when appearing with new_function_specifier. - -new_abstract_declarator_tuple: // CFA - new_abstract_tuple - | type_qualifier_list new_abstract_tuple - { $$ = $2->addQualifiers( $1 ); } - | new_abstract_declarator_no_tuple - ; - -new_abstract_declarator_no_tuple: // CFA - new_abstract_ptr - | new_abstract_array - ; - -new_abstract_ptr: // CFA - '*' type_specifier - { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); } - | type_qualifier_list '*' type_specifier - { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); } - | '*' new_abstract_function - { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); } - | type_qualifier_list '*' new_abstract_function - { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); } - | '*' new_abstract_declarator_tuple - { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); } - | type_qualifier_list '*' new_abstract_declarator_tuple - { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); } - ; - -new_abstract_array: // CFA - // Only the first dimension can be empty. Empty dimension must be factored out due to shift/reduce - // conflict with empty (void) function return type. - '[' push pop ']' type_specifier - { $$ = $5->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } - | '[' push pop ']' multi_array_dimension type_specifier - { $$ = $6->addNewArray( $5 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } - | multi_array_dimension type_specifier - { $$ = $2->addNewArray( $1 ); } - | '[' push pop ']' new_abstract_ptr - { $$ = $5->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } - | '[' push pop ']' multi_array_dimension new_abstract_ptr - { $$ = $6->addNewArray( $5 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } - | multi_array_dimension new_abstract_ptr - { $$ = $2->addNewArray( $1 ); } - ; - -new_abstract_tuple: // CFA - '[' push new_abstract_parameter_list pop ']' - { $$ = DeclarationNode::newTuple( $3 ); } - ; - -new_abstract_function: // CFA - '[' push pop ']' '(' new_parameter_type_list_opt ')' - { $$ = DeclarationNode::newFunction( 0, DeclarationNode::newTuple( 0 ), $6, 0 ); } - | new_abstract_tuple '(' push new_parameter_type_list_opt pop ')' - { $$ = DeclarationNode::newFunction( 0, $1, $4, 0 ); } - | new_function_return '(' push new_parameter_type_list_opt pop ')' - { $$ = DeclarationNode::newFunction( 0, $1, $4, 0 ); } - ; - -// 1) ISO/IEC 9899:1999 Section 6.7.2(2) : "At least one type specifier shall be given in the declaration -// specifiers in each declaration, and in the specifier-qualifier list in each structure declaration and -// type name." -// -// 2) ISO/IEC 9899:1999 Section 6.11.5(1) : "The placement of a storage-class specifier other than at the -// beginning of the declaration specifiers in a declaration is an obsolescent feature." -// -// 3) ISO/IEC 9899:1999 Section 6.11.6(1) : "The use of function declarators with empty parentheses (not -// prototype-format parameter type declarators) is an obsolescent feature." -// -// 4) ISO/IEC 9899:1999 Section 6.11.7(1) : "The use of function definitions with separate parameter -// identifier and declaration lists (not prototype-format parameter type and identifier declarators) is an -// obsolescent feature. - -//************************* MISCELLANEOUS ******************************** - -comma_opt: // redundant comma - // empty - | ',' - ; - -assignment_opt: - // empty - { $$ = 0; } - | '=' assignment_expression - { $$ = $2; } - ; - -%% -// ----end of grammar---- - -void yyerror( char *string ) { - using std::cout; - using std::endl; - cout << "Error "; - if ( yyfilename ) { - cout << "in file " << yyfilename << " "; - } - cout << "at line " << yylineno << " reading token \"" << *(yylval.tok.str) << "\"" << endl; -} - -// Local Variables: // -// fill-column: 110 // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: src/Parser/lex.cc =================================================================== --- src/Parser/lex.cc (revision 56c393547addff0a409b2886d25499bdf0079ca7) +++ src/Parser/lex.cc (revision 56c393547addff0a409b2886d25499bdf0079ca7) @@ -0,0 +1,3911 @@ + +#line 3 "Parser/lex.cc" + +#define YY_INT_ALIGNED short int + +/* A lexical scanner generated by flex */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 5 +#define YY_FLEX_SUBMINOR_VERSION 35 +#if YY_FLEX_SUBMINOR_VERSION > 0 +#define FLEX_BETA +#endif + +/* First, we deal with platform-specific or compiler-specific issues. */ + +/* begin standard C headers. */ +#include +#include +#include +#include + +/* end standard C headers. */ + +/* flex integer type definitions */ + +#ifndef FLEXINT_H +#define FLEXINT_H + +/* C99 systems have . Non-C99 systems may or may not. */ + +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + +/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, + * if you want the limit (max/min) macros for int types. + */ +#ifndef __STDC_LIMIT_MACROS +#define __STDC_LIMIT_MACROS 1 +#endif + +#include +typedef int8_t flex_int8_t; +typedef uint8_t flex_uint8_t; +typedef int16_t flex_int16_t; +typedef uint16_t flex_uint16_t; +typedef int32_t flex_int32_t; +typedef uint32_t flex_uint32_t; +#else +typedef signed char flex_int8_t; +typedef short int flex_int16_t; +typedef int flex_int32_t; +typedef unsigned char flex_uint8_t; +typedef unsigned short int flex_uint16_t; +typedef unsigned int flex_uint32_t; + +/* Limits of integral types. */ +#ifndef INT8_MIN +#define INT8_MIN (-128) +#endif +#ifndef INT16_MIN +#define INT16_MIN (-32767-1) +#endif +#ifndef INT32_MIN +#define INT32_MIN (-2147483647-1) +#endif +#ifndef INT8_MAX +#define INT8_MAX (127) +#endif +#ifndef INT16_MAX +#define INT16_MAX (32767) +#endif +#ifndef INT32_MAX +#define INT32_MAX (2147483647) +#endif +#ifndef UINT8_MAX +#define UINT8_MAX (255U) +#endif +#ifndef UINT16_MAX +#define UINT16_MAX (65535U) +#endif +#ifndef UINT32_MAX +#define UINT32_MAX (4294967295U) +#endif + +#endif /* ! C99 */ + +#endif /* ! FLEXINT_H */ + +#ifdef __cplusplus + +/* The "const" storage-class-modifier is valid. */ +#define YY_USE_CONST + +#else /* ! __cplusplus */ + +/* C99 requires __STDC__ to be defined as 1. */ +#if defined (__STDC__) + +#define YY_USE_CONST + +#endif /* defined (__STDC__) */ +#endif /* ! __cplusplus */ + +#ifdef YY_USE_CONST +#define yyconst const +#else +#define yyconst +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an unsigned + * integer for use as an array index. If the signed char is negative, + * we want to instead treat it as an 8-bit unsigned char, hence the + * double cast. + */ +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN (yy_start) = 1 + 2 * + +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START (((yy_start) - 1) / 2) +#define YYSTATE YY_START + +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) + +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart(yyin ) + +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#ifndef YY_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k. + * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. + * Ditto for the __ia64__ case accordingly. + */ +#define YY_BUF_SIZE 32768 +#else +#define YY_BUF_SIZE 16384 +#endif /* __ia64__ */ +#endif + +/* The state buf must be large enough to hold one state per character in the main buffer. + */ +#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) + +#ifndef YY_TYPEDEF_YY_BUFFER_STATE +#define YY_TYPEDEF_YY_BUFFER_STATE +typedef struct yy_buffer_state *YY_BUFFER_STATE; +#endif + +extern int yyleng; + +extern FILE *yyin, *yyout; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + + /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires + * access to the local variable yy_act. Since yyless() is a macro, it would break + * existing scanners that call yyless() from OUTSIDE yylex. + * One obvious solution it to make yy_act a global. I tried that, and saw + * a 5% performance hit in a non-yylineno scanner, because yy_act is + * normally declared as a register variable-- so it is not worth it. + */ + #define YY_LESS_LINENO(n) \ + do { \ + int yyl;\ + for ( yyl = n; yyl < yyleng; ++yyl )\ + if ( yytext[yyl] == '\n' )\ + --yylineno;\ + }while(0) + +/* Return all but the first "n" matched characters back to the input stream. */ +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + int yyless_macro_arg = (n); \ + YY_LESS_LINENO(yyless_macro_arg);\ + *yy_cp = (yy_hold_char); \ + YY_RESTORE_YY_MORE_OFFSET \ + (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) + +#define unput(c) yyunput( c, (yytext_ptr) ) + +#ifndef YY_TYPEDEF_YY_SIZE_T +#define YY_TYPEDEF_YY_SIZE_T +typedef size_t yy_size_t; +#endif + +#ifndef YY_STRUCT_YY_BUFFER_STATE +#define YY_STRUCT_YY_BUFFER_STATE +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + yy_size_t yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + int yy_bs_lineno; /**< The line count. */ + int yy_bs_column; /**< The column count. */ + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; + +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + + }; +#endif /* !YY_STRUCT_YY_BUFFER_STATE */ + +/* Stack of input buffers. */ +static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ +static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ +static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */ + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + * + * Returns the top of the stack, or NULL. + */ +#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ + ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ + : NULL) + +/* Same as previous macro, but useful when we know that the buffer stack is not + * NULL or when we need an lvalue. For internal use only. + */ +#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] + +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; +static int yy_n_chars; /* number of characters read into yy_ch_buf */ +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = (char *) 0; +static int yy_init = 0; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +void yyrestart (FILE *input_file ); +void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ); +YY_BUFFER_STATE yy_create_buffer (FILE *file,int size ); +void yy_delete_buffer (YY_BUFFER_STATE b ); +void yy_flush_buffer (YY_BUFFER_STATE b ); +void yypush_buffer_state (YY_BUFFER_STATE new_buffer ); +void yypop_buffer_state (void ); + +static void yyensure_buffer_stack (void ); +static void yy_load_buffer_state (void ); +static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file ); + +#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER ) + +YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size ); +YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str ); +YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len ); + +void *yyalloc (yy_size_t ); +void *yyrealloc (void *,yy_size_t ); +void yyfree (void * ); + +#define yy_new_buffer yy_create_buffer + +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! YY_CURRENT_BUFFER ){ \ + yyensure_buffer_stack (); \ + YY_CURRENT_BUFFER_LVALUE = \ + yy_create_buffer(yyin,YY_BUF_SIZE ); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ + } + +#define yy_set_bol(at_bol) \ + { \ + if ( ! YY_CURRENT_BUFFER ){\ + yyensure_buffer_stack (); \ + YY_CURRENT_BUFFER_LVALUE = \ + yy_create_buffer(yyin,YY_BUF_SIZE ); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ + } + +#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) + +/* Begin user sect3 */ + +typedef unsigned char YY_CHAR; + +FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; + +typedef int yy_state_type; + +extern int yylineno; + +int yylineno = 1; + +extern char *yytext; +#define yytext_ptr yytext + +static yy_state_type yy_get_previous_state (void ); +static yy_state_type yy_try_NUL_trans (yy_state_type current_state ); +static int yy_get_next_buffer (void ); +static void yy_fatal_error (yyconst char msg[] ); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + (yytext_ptr) = yy_bp; \ + yyleng = (size_t) (yy_cp - yy_bp); \ + (yy_hold_char) = *yy_cp; \ + *yy_cp = '\0'; \ + (yy_c_buf_p) = yy_cp; + +#define YY_NUM_RULES 170 +#define YY_END_OF_BUFFER 171 +/* This struct is not used in this scanner, + but its presence is necessary. */ +struct yy_trans_info + { + flex_int32_t yy_verify; + flex_int32_t yy_nxt; + }; +static yyconst flex_int16_t yy_accept[821] = + { 0, + 0, 0, 0, 0, 0, 0, 108, 108, 111, 111, + 171, 169, 7, 9, 8, 130, 110, 95, 135, 138, + 107, 117, 118, 133, 131, 121, 132, 124, 134, 100, + 101, 102, 122, 123, 140, 142, 141, 143, 169, 95, + 115, 169, 116, 136, 95, 97, 95, 95, 95, 95, + 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, + 95, 119, 139, 120, 137, 7, 169, 4, 4, 170, + 98, 170, 99, 108, 109, 114, 111, 112, 7, 9, + 0, 8, 147, 165, 95, 0, 159, 129, 152, 160, + 157, 144, 155, 145, 156, 154, 0, 105, 3, 0, + + 158, 105, 103, 0, 0, 103, 103, 0, 0, 103, + 102, 102, 102, 0, 102, 127, 128, 126, 148, 150, + 146, 151, 149, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 96, 0, 110, + 107, 95, 0, 0, 162, 95, 95, 95, 95, 95, + 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, + 95, 36, 95, 95, 95, 95, 95, 95, 95, 95, + 95, 95, 53, 95, 95, 95, 95, 95, 95, 95, + 95, 95, 95, 95, 95, 95, 95, 161, 153, 7, + 0, 0, 0, 2, 0, 5, 98, 0, 0, 0, + + 108, 113, 113, 0, 0, 0, 111, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 125, 105, 0, 105, 0, 0, 6, 0, + 103, 0, 0, 0, 105, 0, 103, 103, 103, 103, + 0, 104, 0, 0, 102, 102, 102, 102, 0, 163, + 164, 0, 167, 166, 0, 0, 0, 96, 0, 0, + 0, 0, 0, 0, 0, 95, 95, 95, 95, 95, + 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, + 95, 95, 95, 95, 14, 95, 95, 95, 95, 95, + 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, + + 95, 47, 95, 95, 95, 60, 95, 95, 95, 95, + 95, 95, 95, 95, 95, 95, 95, 95, 82, 95, + 95, 95, 95, 95, 95, 0, 0, 0, 0, 0, + 0, 0, 0, 113, 0, 0, 0, 0, 0, 113, + 0, 0, 168, 0, 0, 0, 0, 0, 0, 0, + 0, 105, 0, 0, 0, 105, 0, 103, 103, 0, + 0, 104, 104, 0, 104, 0, 104, 102, 102, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, + 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, + 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, + + 95, 20, 95, 23, 95, 25, 95, 95, 95, 95, + 95, 95, 39, 40, 95, 95, 95, 95, 95, 95, + 95, 52, 95, 63, 95, 95, 95, 95, 95, 95, + 95, 95, 95, 95, 95, 83, 95, 95, 90, 95, + 95, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 113, 0, 0, 0, 0, + 0, 105, 0, 0, 0, 0, 0, 0, 104, 104, + 0, 106, 0, 104, 104, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 95, 95, + 21, 95, 95, 95, 95, 95, 95, 95, 15, 95, + + 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, + 95, 95, 22, 24, 95, 30, 95, 95, 95, 95, + 38, 95, 95, 95, 45, 95, 95, 50, 95, 95, + 95, 95, 95, 71, 95, 95, 95, 95, 95, 81, + 95, 95, 88, 95, 95, 94, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 106, 0, 0, 104, 106, + 106, 0, 104, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 95, 0, 95, 95, 95, 95, 95, + 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, + + 55, 95, 95, 95, 95, 95, 95, 95, 26, 95, + 95, 95, 37, 42, 95, 95, 48, 95, 57, 64, + 95, 95, 70, 72, 75, 76, 78, 79, 95, 85, + 95, 95, 0, 1, 0, 0, 0, 0, 0, 0, + 98, 0, 0, 0, 113, 0, 0, 0, 0, 106, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 95, 95, 17, 95, 95, 95, 95, 95, 95, 95, + 16, 95, 95, 31, 95, 95, 95, 95, 95, 95, + 95, 95, 95, 95, 33, 95, 35, 95, 44, 49, + 95, 95, 84, 95, 95, 0, 0, 0, 0, 0, + + 0, 0, 0, 0, 0, 0, 0, 0, 10, 11, + 27, 51, 95, 95, 95, 95, 95, 95, 95, 95, + 95, 95, 56, 58, 61, 95, 95, 73, 86, 95, + 34, 43, 66, 67, 89, 91, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 95, 65, + 95, 95, 12, 95, 28, 32, 95, 95, 95, 62, + 95, 95, 95, 95, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 54, 95, 95, + 95, 95, 95, 95, 46, 59, 68, 74, 87, 92, + 0, 0, 0, 0, 0, 0, 0, 0, 95, 95, + + 13, 18, 29, 95, 95, 95, 0, 0, 95, 95, + 95, 95, 69, 93, 95, 80, 19, 41, 77, 0 + } ; + +static yyconst flex_int32_t yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 4, 5, 6, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 26, 26, 26, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 11, 43, 11, 11, 44, 11, 45, 11, 46, + 11, 11, 47, 48, 49, 11, 11, 50, 11, 11, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + + 61, 62, 63, 64, 65, 11, 66, 67, 68, 69, + 70, 71, 11, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static yyconst flex_int32_t yy_meta[85] = + { 0, + 1, 1, 2, 1, 1, 1, 1, 1, 3, 1, + 4, 1, 1, 5, 1, 1, 1, 1, 1, 1, + 6, 1, 7, 7, 7, 7, 8, 8, 1, 1, + 1, 1, 1, 9, 1, 10, 10, 10, 10, 10, + 10, 4, 4, 11, 4, 12, 4, 4, 13, 4, + 1, 14, 1, 1, 15, 1, 16, 16, 10, 10, + 16, 16, 4, 4, 4, 4, 11, 4, 17, 4, + 12, 17, 4, 17, 13, 17, 4, 17, 4, 4, + 1, 1, 1, 1 + } ; + +static yyconst flex_int16_t yy_base[995] = + { 0, + 0, 83, 2183, 2181, 93, 0, 175, 176, 177, 178, + 2193, 3518, 189, 3518, 195, 54, 3518, 2140, 59, 171, + 3518, 3518, 3518, 55, 186, 3518, 189, 187, 202, 214, + 272, 0, 2158, 3518, 214, 2158, 150, 340, 2136, 222, + 3518, 157, 3518, 2152, 277, 3518, 192, 133, 196, 198, + 204, 271, 155, 218, 181, 200, 266, 238, 210, 224, + 282, 3518, 223, 3518, 2149, 372, 361, 3518, 2160, 3518, + 2129, 229, 3518, 0, 3518, 372, 0, 3518, 397, 3518, + 403, 409, 3518, 443, 2128, 234, 3518, 3518, 3518, 3518, + 3518, 2144, 3518, 2139, 3518, 3518, 2151, 503, 3518, 2168, + + 3518, 548, 394, 403, 414, 262, 240, 280, 402, 387, + 0, 305, 241, 335, 404, 3518, 3518, 3518, 2138, 3518, + 3518, 3518, 2136, 2132, 215, 310, 2147, 327, 333, 349, + 401, 414, 434, 449, 2128, 452, 453, 2109, 317, 3518, + 3518, 464, 2105, 2103, 3518, 425, 418, 437, 439, 438, + 441, 443, 444, 555, 446, 449, 451, 461, 452, 450, + 453, 251, 458, 466, 318, 468, 469, 472, 480, 481, + 488, 486, 2101, 494, 493, 497, 517, 496, 531, 525, + 533, 507, 499, 529, 553, 534, 541, 3518, 3518, 630, + 636, 2149, 642, 3518, 648, 3518, 2099, 538, 2095, 2093, + + 0, 3518, 654, 2089, 2088, 2087, 0, 2109, 523, 570, + 587, 624, 661, 591, 651, 614, 620, 2106, 652, 655, + 2083, 2078, 3518, 687, 674, 3518, 2077, 2128, 3518, 663, + 0, 404, 695, 713, 734, 745, 641, 3518, 2086, 2061, + 0, 753, 2103, 756, 642, 3518, 2079, 2055, 767, 3518, + 3518, 2087, 3518, 3518, 674, 700, 2067, 2066, 677, 2058, + 2057, 2056, 0, 2055, 0, 543, 681, 694, 735, 572, + 748, 695, 752, 714, 758, 736, 755, 746, 766, 760, + 644, 762, 763, 767, 2056, 769, 784, 692, 504, 771, + 774, 703, 788, 794, 777, 786, 797, 798, 799, 801, + + 803, 804, 802, 805, 811, 2051, 816, 810, 815, 812, + 817, 818, 578, 820, 819, 822, 830, 831, 2050, 833, + 832, 835, 836, 846, 839, 905, 886, 2046, 2045, 2043, + 0, 2038, 0, 892, 896, 2037, 0, 2036, 0, 2035, + 0, 2054, 3518, 711, 877, 1990, 1985, 0, 1984, 0, + 900, 907, 918, 929, 940, 952, 962, 3518, 3518, 926, + 927, 979, 955, 1013, 893, 1011, 934, 3518, 3518, 1981, + 1980, 1979, 0, 1978, 0, 1977, 0, 1975, 0, 847, + 861, 953, 887, 888, 898, 950, 918, 960, 961, 942, + 970, 983, 975, 991, 990, 996, 1001, 1004, 1006, 993, + + 1013, 1973, 764, 1972, 532, 1971, 1010, 1015, 1020, 1019, + 1021, 1023, 1970, 1968, 919, 1022, 1024, 1027, 1035, 1038, + 1043, 1964, 1040, 1963, 1041, 1045, 1047, 1048, 1051, 1046, + 1053, 1056, 956, 1054, 1059, 1062, 1060, 1063, 1962, 1065, + 1072, 1125, 1958, 0, 1957, 0, 1955, 0, 1950, 0, + 1117, 1949, 0, 1948, 0, 1947, 1945, 1940, 0, 1939, + 0, 1121, 1127, 1172, 1114, 1183, 1115, 1085, 1088, 3518, + 1189, 1195, 1206, 1949, 1925, 1935, 1930, 0, 1929, 0, + 1928, 0, 1927, 0, 1925, 0, 1921, 0, 1105, 1107, + 1923, 1106, 1112, 1114, 1128, 1125, 1078, 1075, 1123, 1115, + + 1173, 1176, 1185, 1183, 1129, 1139, 164, 1190, 1189, 1191, + 1193, 1195, 1922, 1921, 1203, 1920, 1196, 1201, 1204, 1206, + 1918, 1207, 1141, 1213, 1912, 1214, 1216, 1907, 1217, 1223, + 1209, 1220, 1225, 1902, 1227, 1230, 1234, 1236, 1237, 1901, + 1238, 1243, 1900, 1239, 1244, 1899, 1947, 1893, 0, 1871, + 0, 1870, 0, 1869, 0, 1868, 0, 1866, 0, 1861, + 0, 1860, 0, 1288, 1294, 1300, 1311, 1859, 3518, 1322, + 3518, 1346, 3518, 1858, 0, 1856, 0, 1851, 0, 1850, + 0, 0, 0, 1852, 0, 1308, 1245, 1246, 1288, 1290, + 1281, 1299, 1316, 1312, 1248, 1323, 1327, 1278, 1328, 1280, + + 1330, 1331, 1366, 1340, 1334, 1341, 1344, 1343, 1851, 1346, + 1347, 1351, 1849, 1844, 1352, 1353, 1843, 1357, 1842, 1841, + 1358, 1364, 1839, 1834, 1833, 1832, 1831, 1829, 1359, 1824, + 1375, 1363, 1872, 3518, 1819, 0, 1818, 0, 0, 0, + 1819, 0, 0, 0, 3518, 0, 0, 0, 0, 1414, + 1420, 1465, 1811, 0, 1810, 0, 0, 0, 0, 1809, + 1360, 1397, 1811, 1376, 1398, 1377, 1379, 1401, 1408, 1400, + 1809, 1410, 1413, 1425, 1421, 1443, 1431, 1444, 1445, 1446, + 1414, 1447, 1448, 1419, 1804, 1450, 1803, 1433, 1802, 1801, + 1451, 1452, 1799, 1454, 1457, 0, 0, 1791, 1790, 1789, + + 1788, 1504, 0, 1786, 1775, 1772, 1771, 1767, 1769, 1768, + 1767, 1765, 1461, 1465, 1464, 1470, 1463, 1460, 1467, 1484, + 1486, 1515, 1741, 1489, 1730, 1491, 1490, 1495, 1500, 1496, + 1729, 1725, 1722, 1721, 1720, 1718, 1713, 1711, 1706, 1697, + 1694, 1684, 1681, 1680, 1653, 1652, 1651, 1650, 1501, 1652, + 1502, 1504, 1505, 1509, 1510, 1642, 1506, 1537, 1514, 1639, + 1516, 1518, 1526, 1525, 1635, 1581, 1580, 1579, 1578, 1577, + 1576, 1575, 1573, 1571, 1570, 1569, 1568, 1570, 1519, 1520, + 1530, 1532, 1536, 1535, 1569, 1568, 1542, 1567, 1566, 1543, + 1469, 1423, 1380, 1306, 1302, 1251, 1247, 963, 1544, 1549, + + 964, 1547, 907, 1548, 1555, 1556, 850, 730, 1557, 1560, + 1561, 1562, 636, 500, 1563, 415, 298, 236, 165, 3518, + 1637, 1654, 1671, 1685, 1699, 1716, 1730, 1747, 1762, 1779, + 1796, 1808, 1821, 1832, 1842, 1852, 1862, 1872, 1882, 1892, + 1902, 1912, 1928, 1939, 1950, 1961, 1971, 1981, 1991, 2001, + 2011, 2021, 2034, 2051, 2068, 2079, 2089, 2099, 2109, 2119, + 2129, 2139, 2149, 2159, 2169, 2179, 2189, 2199, 2209, 2219, + 2229, 2239, 2249, 2260, 2270, 2280, 2290, 2300, 2310, 2320, + 2330, 2340, 2350, 2360, 2373, 2390, 2401, 2411, 2421, 2431, + 2441, 2451, 2461, 2471, 2481, 2491, 2501, 2511, 2521, 2531, + + 2541, 2551, 2561, 2571, 2581, 2591, 2601, 2611, 2621, 2631, + 2641, 2651, 2661, 2671, 2681, 2691, 2701, 2714, 2731, 2742, + 2752, 2762, 2772, 2782, 2792, 2802, 2812, 2822, 2832, 2842, + 2852, 2862, 2872, 2882, 2892, 2902, 2912, 2922, 2932, 2942, + 2952, 2962, 2972, 2982, 2992, 3002, 3015, 3026, 3042, 3053, + 3063, 3073, 3083, 3093, 3103, 3116, 3127, 3137, 3147, 3157, + 3167, 3177, 3187, 3197, 3207, 3217, 3227, 3237, 3247, 3257, + 3267, 3280, 3291, 3301, 3311, 3321, 3331, 3341, 3351, 3361, + 3371, 3381, 3391, 3401, 3411, 3421, 3431, 3441, 3451, 3461, + 3471, 3481, 3491, 3501 + + } ; + +static yyconst flex_int16_t yy_def[995] = + { 0, + 820, 1, 821, 821, 820, 5, 822, 822, 823, 823, + 820, 820, 820, 820, 820, 820, 820, 824, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 31, 820, 820, 820, 820, 820, 820, 825, 824, + 820, 820, 820, 820, 824, 820, 824, 824, 824, 824, + 824, 824, 824, 824, 824, 824, 824, 824, 824, 824, + 824, 820, 820, 820, 820, 820, 826, 820, 820, 820, + 827, 820, 820, 828, 820, 829, 830, 820, 820, 820, + 820, 820, 820, 820, 824, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 831, + + 820, 820, 30, 820, 820, 820, 820, 832, 30, 820, + 31, 820, 820, 31, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 833, 820, 820, + 820, 824, 834, 835, 820, 824, 824, 824, 824, 824, + 824, 824, 824, 824, 824, 824, 824, 824, 824, 824, + 824, 824, 824, 824, 824, 824, 824, 824, 824, 824, + 824, 824, 824, 824, 824, 824, 824, 824, 824, 824, + 824, 824, 824, 824, 824, 824, 824, 820, 820, 820, + 826, 826, 826, 820, 826, 820, 827, 820, 836, 837, + + 828, 820, 820, 838, 839, 840, 830, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 841, 842, 820, 820, 820, 820, 224, 843, 820, 820, + 103, 103, 820, 820, 820, 820, 820, 820, 820, 820, + 844, 845, 846, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 833, 820, 847, + 848, 849, 850, 851, 852, 853, 853, 853, 853, 853, + 853, 853, 853, 853, 853, 853, 853, 853, 853, 853, + 853, 853, 853, 853, 853, 853, 853, 853, 853, 853, + 853, 853, 853, 853, 853, 853, 853, 853, 853, 853, + + 853, 853, 853, 853, 853, 853, 853, 853, 853, 853, + 853, 853, 853, 853, 853, 853, 853, 853, 853, 853, + 853, 853, 853, 853, 853, 854, 855, 856, 857, 858, + 859, 860, 861, 820, 820, 862, 863, 864, 865, 866, + 867, 820, 820, 820, 820, 820, 868, 869, 870, 871, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 872, + 873, 874, 820, 820, 820, 874, 820, 820, 820, 875, + 876, 877, 878, 879, 880, 881, 882, 883, 884, 885, + 885, 885, 885, 885, 885, 885, 885, 885, 885, 885, + 885, 885, 885, 885, 885, 885, 885, 885, 885, 885, + + 885, 885, 885, 885, 885, 885, 885, 885, 885, 885, + 885, 885, 885, 885, 885, 885, 885, 885, 885, 885, + 885, 885, 885, 885, 885, 885, 885, 885, 885, 885, + 885, 885, 885, 885, 885, 885, 885, 885, 885, 885, + 885, 886, 887, 888, 889, 890, 891, 892, 893, 894, + 820, 895, 896, 897, 898, 899, 899, 900, 901, 902, + 903, 820, 820, 820, 904, 820, 904, 820, 820, 820, + 820, 820, 820, 820, 820, 905, 906, 907, 908, 909, + 910, 911, 912, 913, 914, 915, 916, 917, 918, 918, + 918, 918, 918, 918, 918, 918, 918, 918, 918, 918, + + 918, 918, 918, 918, 918, 918, 918, 918, 918, 918, + 918, 918, 918, 918, 918, 918, 918, 918, 918, 918, + 918, 918, 918, 918, 918, 918, 918, 918, 918, 918, + 918, 918, 918, 918, 918, 918, 918, 918, 918, 918, + 918, 918, 918, 918, 918, 918, 919, 920, 921, 922, + 923, 924, 925, 926, 927, 928, 929, 930, 931, 932, + 933, 934, 935, 820, 820, 820, 820, 936, 820, 820, + 820, 820, 820, 937, 938, 939, 940, 941, 942, 943, + 944, 945, 946, 947, 948, 947, 947, 947, 947, 947, + 947, 947, 947, 947, 947, 947, 947, 947, 947, 947, + + 947, 947, 947, 947, 947, 947, 947, 947, 947, 947, + 947, 947, 947, 947, 947, 947, 947, 947, 947, 947, + 947, 947, 947, 947, 947, 947, 947, 947, 947, 947, + 947, 947, 949, 820, 950, 951, 952, 953, 954, 955, + 956, 957, 958, 959, 820, 960, 961, 962, 963, 820, + 820, 820, 964, 965, 966, 967, 968, 969, 970, 971, + 972, 972, 972, 972, 972, 972, 972, 972, 972, 972, + 972, 972, 972, 972, 972, 972, 972, 972, 972, 972, + 972, 972, 972, 972, 972, 972, 972, 972, 972, 972, + 972, 972, 972, 972, 972, 973, 974, 952, 975, 976, + + 977, 820, 978, 964, 966, 979, 980, 971, 972, 972, + 972, 972, 972, 972, 972, 972, 972, 972, 972, 972, + 972, 972, 972, 972, 972, 972, 972, 972, 972, 972, + 972, 972, 972, 972, 972, 972, 981, 982, 975, 983, + 976, 984, 977, 985, 986, 979, 987, 980, 972, 972, + 972, 972, 972, 972, 972, 972, 972, 972, 972, 972, + 972, 972, 972, 972, 988, 981, 989, 982, 990, 983, + 991, 984, 992, 985, 993, 986, 987, 972, 972, 972, + 972, 972, 972, 972, 972, 972, 972, 972, 972, 972, + 994, 988, 989, 990, 991, 966, 992, 993, 972, 972, + + 972, 972, 972, 972, 972, 972, 994, 966, 972, 972, + 972, 972, 972, 972, 972, 972, 972, 972, 972, 0, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820 + + } ; + +static yyconst flex_int16_t yy_nxt[3603] = + { 0, + 12, 13, 14, 15, 15, 15, 13, 16, 17, 12, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 32, 32, 32, 33, 34, + 35, 36, 37, 38, 39, 18, 18, 18, 18, 18, + 18, 18, 18, 40, 18, 18, 18, 18, 18, 18, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 18, 54, 18, 55, 18, 18, 18, + 18, 56, 57, 58, 59, 60, 61, 18, 18, 18, + 62, 63, 64, 65, 66, 83, 91, 84, 84, 66, + 87, 88, 67, 70, 70, 70, 70, 70, 70, 70, + + 70, 70, 70, 71, 70, 70, 70, 70, 70, 70, + 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, + 70, 70, 70, 70, 70, 70, 70, 70, 71, 71, + 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, + 71, 71, 71, 70, 72, 70, 70, 71, 73, 71, + 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, + 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, + 71, 71, 71, 70, 70, 70, 70, 75, 75, 78, + 78, 122, 123, 89, 86, 78, 78, 603, 75, 75, + 79, 80, 81, 81, 81, 79, 81, 80, 82, 82, + + 82, 81, 90, 92, 157, 143, 86, 97, 94, 98, + 98, 98, 98, 98, 98, 86, 86, 93, 99, 84, + 95, 96, 84, 100, 172, 117, 76, 76, 76, 76, + 140, 144, 86, 101, 102, 141, 103, 103, 103, 103, + 104, 104, 118, 86, 119, 120, 252, 86, 253, 86, + 175, 86, 158, 105, 188, 86, 176, 106, 161, 159, + 177, 86, 107, 108, 155, 160, 156, 162, 109, 86, + 164, 163, 165, 86, 105, 86, 142, 199, 185, 173, + 110, 166, 221, 239, 247, 140, 174, 86, 107, 86, + 141, 108, 102, 186, 111, 111, 111, 111, 111, 111, + + 241, 182, 86, 200, 189, 237, 240, 248, 222, 183, + 238, 105, 146, 147, 148, 112, 184, 86, 149, 150, + 113, 151, 86, 152, 153, 294, 114, 167, 86, 178, + 179, 154, 105, 86, 243, 168, 238, 169, 115, 180, + 170, 252, 181, 253, 171, 187, 113, 124, 245, 86, + 254, 125, 126, 246, 127, 820, 128, 129, 252, 130, + 253, 131, 193, 194, 252, 260, 253, 193, 254, 86, + 132, 133, 134, 190, 80, 81, 81, 81, 190, 246, + 252, 191, 253, 195, 195, 195, 195, 195, 195, 249, + 135, 261, 297, 136, 203, 203, 203, 203, 79, 80, + + 81, 81, 81, 79, 81, 80, 81, 81, 81, 81, + 81, 80, 82, 82, 82, 81, 231, 231, 231, 231, + 204, 137, 820, 102, 820, 104, 104, 104, 104, 104, + 104, 234, 252, 234, 253, 238, 235, 235, 235, 235, + 235, 235, 105, 820, 255, 252, 205, 253, 232, 206, + 208, 820, 246, 237, 209, 210, 244, 233, 355, 211, + 212, 238, 213, 105, 214, 252, 86, 253, 236, 86, + 245, 820, 140, 215, 216, 217, 86, 141, 246, 820, + 252, 256, 253, 252, 252, 253, 253, 268, 86, 86, + 86, 266, 86, 218, 86, 86, 219, 86, 267, 270, + + 86, 86, 86, 86, 86, 271, 269, 274, 290, 86, + 272, 287, 86, 285, 293, 86, 273, 86, 292, 86, + 86, 291, 286, 86, 220, 224, 224, 224, 224, 224, + 224, 86, 86, 288, 289, 299, 295, 86, 296, 86, + 300, 298, 225, 226, 86, 86, 226, 86, 86, 301, + 86, 86, 302, 308, 342, 86, 343, 227, 86, 304, + 305, 307, 405, 225, 226, 312, 303, 306, 86, 226, + 98, 98, 98, 98, 98, 98, 86, 319, 318, 309, + 86, 315, 86, 86, 86, 86, 328, 225, 226, 310, + 311, 226, 86, 313, 86, 514, 316, 317, 323, 320, + + 324, 342, 230, 343, 86, 325, 86, 380, 225, 226, + 314, 275, 329, 276, 226, 277, 278, 321, 342, 279, + 343, 280, 342, 86, 343, 322, 281, 282, 283, 86, + 284, 190, 80, 81, 81, 81, 190, 193, 194, 191, + 384, 343, 193, 193, 194, 342, 430, 343, 193, 326, + 194, 342, 345, 343, 326, 342, 327, 343, 195, 195, + 195, 195, 195, 195, 195, 195, 195, 195, 195, 195, + 195, 195, 195, 195, 195, 195, 334, 334, 334, 334, + 343, 344, 342, 342, 343, 343, 342, 86, 343, 358, + 368, 351, 342, 351, 343, 86, 352, 352, 352, 352, + + 352, 352, 225, 226, 398, 252, 226, 253, 335, 224, + 224, 224, 224, 224, 224, 358, 368, 104, 104, 104, + 104, 104, 104, 225, 226, 370, 225, 226, 353, 226, + 226, 252, 86, 253, 105, 235, 235, 235, 235, 235, + 235, 227, 342, 86, 343, 86, 86, 225, 226, 244, + 381, 371, 404, 226, 86, 105, 356, 356, 356, 356, + 356, 356, 234, 382, 234, 86, 386, 235, 235, 235, + 235, 235, 235, 361, 226, 408, 409, 226, 104, 104, + 104, 104, 104, 104, 820, 388, 86, 86, 357, 111, + 111, 111, 111, 111, 111, 226, 363, 86, 364, 86, + + 226, 365, 383, 86, 385, 392, 86, 366, 387, 86, + 244, 86, 394, 86, 86, 86, 397, 86, 86, 367, + 86, 249, 86, 364, 389, 86, 399, 365, 86, 513, + 390, 391, 393, 395, 396, 86, 401, 86, 402, 86, + 403, 400, 406, 407, 410, 86, 413, 412, 86, 86, + 86, 411, 86, 86, 86, 86, 86, 417, 415, 418, + 419, 86, 86, 86, 414, 416, 86, 86, 86, 86, + 86, 86, 421, 86, 422, 423, 425, 420, 424, 426, + 431, 86, 86, 86, 86, 427, 86, 86, 194, 429, + 86, 428, 432, 436, 192, 439, 433, 86, 86, 438, + + 435, 437, 440, 434, 820, 441, 326, 194, 342, 489, + 343, 326, 86, 327, 202, 202, 202, 202, 334, 334, + 334, 334, 352, 352, 352, 352, 352, 352, 490, 462, + 462, 462, 462, 462, 462, 351, 474, 351, 86, 86, + 352, 352, 352, 352, 352, 352, 451, 226, 493, 86, + 226, 224, 224, 224, 224, 224, 224, 492, 86, 475, + 494, 463, 231, 231, 231, 231, 104, 104, 226, 86, + 86, 466, 466, 226, 356, 356, 356, 356, 356, 356, + 467, 468, 470, 354, 356, 356, 356, 356, 356, 356, + 522, 496, 226, 86, 355, 226, 466, 466, 469, 361, + + 469, 86, 226, 470, 86, 226, 357, 86, 470, 499, + 495, 86, 86, 226, 538, 86, 464, 820, 226, 491, + 497, 86, 363, 226, 364, 498, 86, 365, 226, 470, + 471, 820, 471, 366, 86, 472, 472, 472, 472, 472, + 472, 86, 86, 500, 86, 367, 505, 86, 503, 364, + 501, 502, 86, 365, 363, 86, 364, 86, 508, 365, + 504, 86, 506, 511, 86, 476, 86, 473, 510, 507, + 86, 86, 86, 86, 86, 86, 509, 367, 86, 512, + 517, 364, 515, 521, 518, 365, 86, 520, 516, 86, + 524, 86, 86, 519, 86, 523, 86, 86, 86, 86, + + 525, 526, 86, 528, 86, 86, 535, 86, 529, 527, + 86, 86, 539, 86, 86, 530, 86, 531, 532, 533, + 537, 541, 536, 86, 534, 544, 86, 194, 543, 86, + 466, 542, 546, 547, 593, 540, 569, 594, 545, 202, + 202, 202, 202, 462, 462, 462, 462, 462, 462, 462, + 462, 462, 462, 462, 462, 466, 86, 86, 86, 466, + 466, 226, 569, 86, 226, 86, 86, 226, 467, 568, + 226, 587, 588, 586, 86, 463, 86, 595, 590, 86, + 86, 564, 226, 589, 466, 466, 596, 226, 226, 592, + 86, 601, 86, 226, 356, 356, 356, 356, 356, 356, + + 565, 591, 565, 602, 615, 566, 566, 566, 566, 566, + 566, 472, 472, 472, 472, 472, 472, 570, 570, 570, + 570, 570, 570, 471, 86, 471, 464, 86, 472, 472, + 472, 472, 472, 472, 86, 571, 86, 567, 571, 600, + 86, 86, 86, 597, 86, 599, 86, 86, 598, 572, + 604, 608, 86, 607, 86, 86, 571, 86, 86, 606, + 86, 571, 605, 609, 86, 86, 613, 86, 86, 611, + 612, 86, 618, 610, 86, 614, 86, 619, 86, 616, + 617, 86, 621, 620, 622, 86, 624, 86, 86, 86, + 86, 625, 626, 623, 86, 86, 86, 86, 629, 86, + + 628, 820, 671, 663, 630, 808, 664, 631, 632, 627, + 462, 462, 462, 462, 462, 462, 566, 566, 566, 566, + 566, 566, 650, 650, 650, 650, 650, 650, 565, 86, + 565, 86, 86, 566, 566, 566, 566, 566, 566, 86, + 571, 86, 564, 571, 570, 570, 570, 570, 570, 570, + 86, 674, 665, 676, 651, 667, 820, 668, 666, 86, + 820, 571, 571, 86, 661, 571, 571, 86, 570, 570, + 570, 570, 570, 570, 86, 669, 572, 662, 86, 86, + 670, 86, 86, 571, 677, 86, 571, 672, 571, 571, + 679, 86, 86, 673, 86, 86, 675, 86, 86, 678, + + 652, 682, 86, 86, 86, 681, 680, 571, 86, 86, + 86, 86, 571, 683, 86, 86, 684, 86, 691, 685, + 693, 686, 692, 688, 687, 690, 86, 86, 86, 695, + 86, 689, 709, 713, 820, 694, 650, 650, 650, 650, + 650, 650, 650, 650, 650, 650, 650, 650, 86, 86, + 714, 86, 86, 711, 571, 715, 712, 571, 710, 86, + 571, 86, 716, 571, 86, 86, 722, 718, 651, 717, + 86, 725, 86, 719, 702, 571, 86, 820, 727, 720, + 571, 571, 86, 730, 86, 723, 571, 570, 570, 570, + 570, 570, 570, 721, 86, 86, 86, 86, 86, 86, + + 726, 86, 86, 86, 724, 86, 728, 732, 86, 729, + 731, 86, 86, 735, 86, 86, 86, 736, 86, 652, + 751, 86, 733, 807, 753, 734, 650, 650, 650, 650, + 650, 650, 749, 750, 754, 86, 752, 86, 756, 758, + 86, 86, 86, 759, 755, 760, 86, 86, 761, 762, + 757, 86, 86, 86, 763, 86, 86, 86, 702, 781, + 86, 86, 764, 785, 783, 86, 86, 86, 786, 86, + 86, 86, 788, 780, 779, 784, 86, 86, 800, 778, + 789, 86, 782, 86, 801, 790, 86, 86, 86, 787, + 803, 799, 802, 86, 86, 86, 805, 806, 86, 86, + + 86, 811, 812, 804, 809, 810, 86, 86, 86, 813, + 814, 86, 86, 86, 86, 817, 818, 86, 86, 86, + 86, 86, 820, 820, 798, 820, 816, 797, 815, 820, + 795, 820, 794, 820, 793, 820, 819, 68, 68, 68, + 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, + 68, 68, 68, 68, 74, 74, 74, 74, 74, 74, + 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, + 74, 77, 77, 77, 77, 77, 77, 77, 77, 77, + 77, 77, 77, 77, 77, 77, 77, 77, 85, 792, + 86, 85, 85, 86, 85, 85, 85, 85, 85, 85, + + 85, 85, 138, 86, 820, 777, 820, 776, 138, 138, + 138, 138, 138, 138, 138, 138, 192, 192, 192, 192, + 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, + 192, 192, 192, 197, 774, 820, 197, 197, 772, 197, + 197, 197, 197, 197, 197, 197, 197, 201, 820, 201, + 201, 770, 201, 201, 201, 201, 201, 201, 201, 201, + 820, 201, 201, 201, 202, 768, 202, 766, 202, 86, + 202, 86, 86, 86, 202, 202, 86, 202, 202, 207, + 86, 86, 207, 207, 207, 207, 207, 207, 207, 207, + 207, 207, 86, 207, 207, 207, 228, 228, 228, 228, + + 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, + 228, 228, 228, 242, 242, 242, 86, 242, 86, 86, + 86, 820, 242, 242, 258, 748, 746, 258, 258, 820, + 258, 258, 258, 258, 258, 258, 258, 258, 262, 262, + 820, 262, 743, 741, 739, 820, 262, 262, 264, 264, + 86, 264, 86, 86, 86, 86, 264, 264, 330, 330, + 86, 330, 86, 708, 705, 704, 330, 330, 332, 332, + 198, 332, 698, 697, 634, 86, 332, 332, 336, 336, + 86, 336, 86, 86, 86, 86, 336, 336, 338, 338, + 86, 338, 86, 86, 86, 86, 338, 338, 340, 340, + + 86, 340, 86, 86, 659, 658, 340, 340, 347, 347, + 656, 347, 654, 568, 649, 648, 347, 347, 349, 349, + 646, 349, 644, 642, 640, 638, 349, 349, 228, 228, + 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, + 228, 228, 228, 228, 228, 360, 360, 636, 360, 634, + 86, 86, 86, 86, 360, 362, 362, 362, 86, 362, + 362, 362, 362, 86, 362, 362, 242, 242, 242, 86, + 242, 86, 86, 86, 86, 585, 242, 372, 372, 583, + 372, 581, 579, 577, 575, 372, 372, 374, 374, 476, + 374, 573, 573, 563, 561, 374, 374, 376, 376, 457, + + 376, 457, 559, 557, 555, 376, 376, 262, 262, 553, + 262, 551, 549, 86, 86, 86, 262, 378, 378, 86, + 378, 86, 86, 86, 86, 378, 378, 264, 264, 488, + 264, 486, 484, 482, 480, 478, 264, 85, 461, 459, + 85, 85, 343, 85, 85, 85, 85, 85, 85, 85, + 85, 192, 192, 192, 192, 192, 192, 192, 192, 192, + 192, 192, 192, 192, 192, 192, 192, 192, 442, 442, + 442, 442, 442, 442, 442, 442, 442, 442, 442, 442, + 442, 442, 442, 442, 442, 443, 443, 343, 443, 457, + 455, 453, 450, 443, 443, 445, 445, 448, 445, 446, + + 444, 86, 86, 445, 445, 447, 447, 86, 447, 379, + 377, 375, 373, 447, 447, 330, 330, 259, 330, 254, + 253, 369, 369, 241, 330, 449, 449, 359, 449, 359, + 229, 354, 350, 449, 449, 332, 332, 348, 332, 346, + 342, 341, 339, 337, 332, 452, 452, 333, 452, 331, + 198, 194, 86, 452, 452, 336, 336, 265, 336, 263, + 259, 257, 254, 252, 336, 454, 454, 251, 454, 250, + 229, 223, 84, 454, 454, 338, 338, 84, 338, 86, + 198, 196, 84, 145, 338, 456, 456, 139, 456, 121, + 116, 86, 820, 456, 456, 340, 340, 69, 340, 69, + + 820, 820, 820, 820, 340, 458, 458, 820, 458, 820, + 820, 820, 820, 458, 458, 347, 347, 820, 347, 820, + 820, 820, 820, 820, 347, 460, 460, 820, 460, 820, + 820, 820, 820, 460, 460, 349, 349, 820, 349, 820, + 820, 820, 820, 820, 349, 465, 465, 820, 465, 820, + 465, 820, 820, 465, 465, 360, 360, 820, 360, 820, + 360, 820, 820, 360, 360, 362, 362, 362, 820, 362, + 362, 362, 362, 820, 362, 362, 477, 477, 820, 477, + 820, 820, 820, 820, 477, 477, 479, 479, 820, 479, + 820, 820, 820, 820, 479, 479, 481, 481, 820, 481, + + 820, 820, 820, 820, 481, 481, 372, 372, 820, 372, + 820, 820, 820, 820, 820, 372, 483, 483, 820, 483, + 820, 820, 820, 820, 483, 483, 374, 374, 820, 374, + 820, 820, 820, 820, 820, 374, 485, 485, 820, 485, + 820, 820, 820, 820, 485, 485, 376, 376, 820, 376, + 820, 820, 820, 820, 820, 376, 487, 487, 820, 487, + 820, 820, 820, 820, 487, 487, 378, 378, 820, 378, + 820, 820, 820, 820, 820, 378, 85, 820, 820, 85, + 85, 820, 85, 85, 85, 85, 85, 85, 85, 85, + 442, 442, 442, 442, 442, 442, 442, 442, 442, 442, + + 442, 442, 442, 442, 442, 442, 442, 548, 548, 820, + 548, 820, 820, 820, 820, 548, 548, 443, 443, 820, + 443, 820, 820, 820, 820, 820, 443, 550, 550, 820, + 550, 820, 820, 820, 820, 550, 550, 445, 445, 820, + 445, 820, 820, 820, 820, 820, 445, 552, 552, 820, + 552, 820, 820, 820, 820, 552, 552, 447, 447, 820, + 447, 820, 820, 820, 820, 820, 447, 554, 554, 820, + 554, 820, 820, 820, 820, 554, 554, 449, 449, 820, + 449, 820, 820, 820, 820, 820, 449, 556, 556, 820, + 556, 820, 820, 820, 820, 556, 556, 452, 452, 820, + + 452, 820, 820, 820, 820, 820, 452, 558, 558, 820, + 558, 820, 820, 820, 820, 558, 558, 454, 454, 820, + 454, 820, 820, 820, 820, 820, 454, 456, 456, 820, + 456, 820, 820, 820, 820, 456, 456, 560, 560, 820, + 560, 820, 820, 820, 820, 560, 560, 458, 458, 820, + 458, 820, 820, 820, 820, 820, 458, 562, 562, 820, + 562, 820, 820, 820, 820, 562, 562, 460, 460, 820, + 460, 820, 820, 820, 820, 820, 460, 465, 465, 820, + 465, 820, 465, 820, 820, 465, 465, 362, 362, 820, + 362, 820, 820, 820, 820, 362, 362, 574, 574, 820, + + 574, 820, 820, 820, 820, 574, 574, 477, 477, 820, + 477, 820, 820, 820, 820, 820, 477, 576, 576, 820, + 576, 820, 820, 820, 820, 576, 576, 479, 479, 820, + 479, 820, 820, 820, 820, 820, 479, 578, 578, 820, + 578, 820, 820, 820, 820, 578, 578, 481, 481, 820, + 481, 820, 820, 820, 820, 820, 481, 580, 580, 820, + 580, 820, 820, 820, 820, 580, 580, 483, 483, 820, + 483, 820, 820, 820, 820, 820, 483, 582, 582, 820, + 582, 820, 820, 820, 820, 582, 582, 485, 485, 820, + 485, 820, 820, 820, 820, 820, 485, 584, 584, 820, + + 584, 820, 820, 820, 820, 584, 584, 487, 487, 820, + 487, 820, 820, 820, 820, 820, 487, 85, 820, 820, + 85, 85, 820, 85, 85, 85, 85, 85, 85, 85, + 85, 633, 633, 633, 633, 633, 633, 633, 633, 633, + 633, 633, 633, 633, 633, 633, 633, 633, 635, 635, + 820, 635, 820, 820, 820, 820, 635, 635, 548, 548, + 820, 548, 820, 820, 820, 820, 820, 548, 637, 637, + 820, 637, 820, 820, 820, 820, 637, 637, 550, 550, + 820, 550, 820, 820, 820, 820, 820, 550, 639, 639, + 820, 639, 820, 820, 820, 820, 639, 639, 552, 552, + + 820, 552, 820, 820, 820, 820, 820, 552, 641, 641, + 820, 641, 820, 820, 820, 820, 641, 641, 554, 554, + 820, 554, 820, 820, 820, 820, 820, 554, 643, 643, + 820, 643, 820, 820, 820, 820, 643, 643, 556, 556, + 820, 556, 820, 820, 820, 820, 820, 556, 645, 645, + 820, 645, 820, 820, 820, 820, 645, 645, 558, 558, + 820, 558, 820, 820, 820, 820, 820, 558, 647, 647, + 820, 647, 820, 820, 820, 820, 647, 647, 560, 560, + 820, 560, 820, 820, 820, 820, 820, 560, 85, 85, + 820, 85, 820, 820, 820, 820, 85, 85, 562, 562, + + 820, 562, 820, 820, 820, 820, 820, 562, 465, 465, + 820, 465, 820, 820, 820, 820, 465, 465, 653, 653, + 820, 653, 820, 820, 820, 820, 653, 653, 574, 574, + 820, 574, 820, 820, 820, 820, 820, 574, 655, 655, + 820, 655, 820, 820, 820, 820, 655, 655, 576, 576, + 820, 576, 820, 820, 820, 820, 820, 576, 657, 657, + 820, 657, 820, 820, 820, 820, 657, 657, 578, 578, + 820, 578, 820, 820, 820, 820, 820, 578, 138, 138, + 820, 138, 820, 820, 820, 820, 138, 138, 580, 580, + 820, 580, 820, 820, 820, 820, 820, 580, 660, 660, + + 820, 660, 820, 820, 820, 820, 820, 660, 582, 582, + 820, 582, 820, 820, 820, 820, 820, 582, 85, 820, + 820, 85, 85, 820, 85, 85, 85, 85, 85, 85, + 85, 85, 584, 584, 820, 584, 820, 820, 820, 820, + 820, 584, 633, 633, 633, 633, 633, 633, 633, 633, + 633, 633, 633, 633, 633, 633, 633, 633, 633, 696, + 696, 820, 696, 820, 820, 820, 820, 696, 696, 635, + 635, 820, 635, 820, 820, 820, 820, 820, 635, 197, + 197, 820, 197, 820, 820, 820, 820, 197, 197, 637, + 637, 820, 637, 820, 820, 820, 820, 820, 637, 699, + + 699, 820, 699, 820, 820, 820, 820, 820, 699, 639, + 639, 820, 639, 820, 820, 820, 820, 820, 639, 197, + 820, 820, 197, 197, 820, 197, 197, 197, 197, 197, + 197, 197, 197, 641, 641, 820, 641, 820, 820, 820, + 820, 820, 641, 700, 700, 820, 700, 820, 820, 820, + 820, 820, 700, 643, 643, 820, 643, 820, 820, 820, + 820, 820, 643, 645, 645, 820, 645, 820, 820, 820, + 820, 820, 645, 701, 701, 820, 701, 820, 820, 820, + 820, 820, 701, 647, 647, 820, 647, 820, 820, 820, + 820, 820, 647, 85, 85, 820, 85, 820, 820, 820, + + 820, 820, 85, 703, 703, 820, 703, 820, 820, 820, + 820, 703, 703, 653, 653, 820, 653, 820, 820, 820, + 820, 820, 653, 258, 258, 820, 258, 820, 820, 820, + 820, 258, 258, 655, 655, 820, 655, 820, 820, 820, + 820, 820, 655, 706, 706, 820, 706, 820, 820, 820, + 820, 820, 706, 657, 657, 820, 657, 820, 820, 820, + 820, 820, 657, 138, 138, 820, 138, 820, 820, 820, + 820, 820, 138, 707, 707, 820, 707, 820, 820, 820, + 820, 707, 707, 85, 820, 820, 85, 85, 820, 85, + 85, 85, 85, 85, 85, 85, 85, 737, 737, 820, + + 737, 820, 820, 820, 820, 820, 737, 696, 696, 820, + 696, 820, 820, 820, 820, 820, 696, 738, 738, 820, + 738, 820, 820, 820, 820, 738, 738, 740, 740, 820, + 740, 820, 820, 820, 820, 740, 740, 742, 742, 820, + 742, 820, 820, 820, 820, 742, 742, 744, 744, 820, + 744, 820, 820, 820, 820, 820, 744, 745, 745, 820, + 745, 820, 820, 820, 820, 745, 745, 747, 747, 820, + 747, 820, 820, 820, 820, 747, 747, 765, 765, 820, + 765, 820, 820, 820, 820, 765, 765, 767, 767, 820, + 767, 820, 820, 820, 820, 767, 767, 769, 769, 820, + + 769, 820, 820, 820, 820, 769, 769, 771, 771, 820, + 771, 820, 820, 820, 820, 771, 771, 773, 773, 820, + 773, 820, 820, 820, 820, 773, 773, 775, 775, 820, + 775, 820, 820, 820, 820, 775, 775, 584, 584, 820, + 584, 820, 820, 820, 820, 584, 584, 791, 791, 820, + 791, 820, 820, 820, 820, 791, 791, 641, 641, 820, + 641, 820, 820, 820, 820, 641, 641, 645, 645, 820, + 645, 820, 820, 820, 820, 645, 645, 85, 85, 820, + 85, 820, 820, 820, 820, 85, 85, 796, 796, 820, + 796, 820, 820, 820, 820, 796, 796, 138, 138, 820, + + 138, 820, 820, 820, 820, 138, 138, 197, 197, 820, + 197, 820, 820, 820, 820, 197, 197, 11, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + + 820, 820 + } ; + +static yyconst flex_int16_t yy_chk[3603] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 2, 16, 24, 16, 24, 2, + 19, 19, 2, 5, 5, 5, 5, 5, 5, 5, + + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 7, 8, 9, + 10, 37, 37, 20, 48, 9, 10, 507, 7, 8, + 13, 13, 13, 13, 13, 13, 15, 15, 15, 15, + + 15, 15, 20, 25, 48, 42, 53, 28, 27, 28, + 28, 28, 28, 28, 28, 507, 819, 25, 29, 25, + 27, 27, 27, 29, 53, 35, 7, 8, 9, 10, + 40, 42, 55, 29, 30, 40, 30, 30, 30, 30, + 30, 30, 35, 47, 35, 35, 125, 49, 125, 50, + 55, 56, 49, 30, 63, 51, 55, 30, 50, 49, + 56, 59, 30, 30, 47, 49, 47, 50, 30, 54, + 51, 50, 51, 40, 30, 60, 40, 72, 59, 54, + 30, 51, 86, 107, 113, 45, 54, 818, 30, 58, + 45, 30, 31, 60, 31, 31, 31, 31, 31, 31, + + 108, 58, 162, 72, 63, 106, 107, 113, 86, 58, + 106, 31, 45, 45, 45, 31, 58, 57, 45, 45, + 31, 45, 52, 45, 45, 162, 31, 52, 45, 57, + 57, 45, 31, 61, 108, 52, 106, 52, 31, 57, + 52, 126, 57, 126, 52, 61, 31, 38, 112, 817, + 129, 38, 38, 112, 38, 114, 38, 38, 128, 38, + 128, 38, 67, 67, 129, 139, 129, 67, 130, 165, + 38, 38, 38, 66, 66, 66, 66, 66, 66, 112, + 130, 66, 130, 67, 67, 67, 67, 67, 67, 114, + 38, 139, 165, 38, 76, 76, 76, 76, 79, 79, + + 79, 79, 79, 79, 81, 81, 81, 81, 81, 81, + 82, 82, 82, 82, 82, 82, 103, 103, 103, 103, + 76, 38, 109, 104, 232, 104, 104, 104, 104, 104, + 104, 105, 131, 105, 131, 110, 105, 105, 105, 105, + 105, 105, 104, 103, 132, 132, 76, 132, 103, 76, + 84, 109, 115, 110, 84, 84, 109, 104, 232, 84, + 84, 110, 84, 104, 84, 133, 816, 133, 105, 147, + 115, 103, 142, 84, 84, 84, 146, 142, 115, 109, + 134, 134, 134, 136, 137, 136, 137, 147, 148, 150, + 149, 146, 151, 84, 152, 153, 84, 155, 146, 149, + + 156, 160, 157, 159, 161, 150, 148, 153, 159, 163, + 151, 157, 158, 155, 161, 142, 152, 164, 160, 166, + 167, 159, 156, 168, 84, 98, 98, 98, 98, 98, + 98, 169, 170, 158, 158, 167, 163, 172, 164, 171, + 168, 166, 98, 98, 175, 174, 98, 178, 176, 169, + 183, 814, 170, 176, 209, 289, 209, 98, 182, 172, + 174, 175, 289, 98, 98, 178, 171, 174, 177, 98, + 102, 102, 102, 102, 102, 102, 180, 183, 182, 177, + 184, 180, 179, 405, 181, 186, 198, 102, 102, 177, + 177, 102, 187, 179, 266, 405, 180, 181, 186, 184, + + 186, 210, 102, 210, 185, 187, 154, 266, 102, 102, + 179, 154, 198, 154, 102, 154, 154, 185, 211, 154, + 211, 154, 214, 270, 214, 185, 154, 154, 154, 313, + 154, 190, 190, 190, 190, 190, 190, 191, 191, 190, + 270, 212, 191, 193, 193, 216, 313, 216, 193, 195, + 195, 217, 217, 217, 195, 212, 195, 212, 191, 191, + 191, 191, 191, 191, 193, 193, 193, 193, 193, 193, + 195, 195, 195, 195, 195, 195, 203, 203, 203, 203, + 213, 215, 215, 219, 215, 219, 220, 813, 220, 237, + 245, 225, 213, 225, 213, 281, 225, 225, 225, 225, + + 225, 225, 230, 230, 281, 255, 230, 255, 203, 224, + 224, 224, 224, 224, 224, 237, 245, 233, 233, 233, + 233, 233, 233, 230, 230, 259, 224, 224, 225, 230, + 224, 256, 267, 256, 233, 234, 234, 234, 234, 234, + 234, 224, 344, 288, 344, 268, 272, 224, 224, 233, + 267, 259, 288, 224, 292, 233, 235, 235, 235, 235, + 235, 235, 236, 268, 236, 274, 272, 236, 236, 236, + 236, 236, 236, 242, 235, 292, 292, 235, 244, 244, + 244, 244, 244, 244, 808, 274, 269, 276, 235, 249, + 249, 249, 249, 249, 249, 235, 242, 278, 242, 271, + + 235, 242, 269, 273, 271, 276, 277, 242, 273, 275, + 244, 280, 278, 282, 283, 403, 280, 279, 284, 242, + 286, 249, 290, 242, 275, 291, 282, 242, 295, 403, + 275, 275, 277, 279, 279, 287, 284, 296, 286, 293, + 287, 283, 290, 291, 293, 294, 296, 295, 297, 298, + 299, 294, 300, 303, 301, 302, 304, 300, 298, 301, + 302, 308, 305, 310, 297, 299, 309, 307, 311, 312, + 315, 314, 303, 316, 304, 305, 308, 302, 307, 309, + 314, 317, 318, 321, 320, 310, 322, 323, 327, 312, + 325, 311, 315, 320, 327, 323, 316, 324, 380, 322, + + 318, 321, 324, 317, 807, 325, 326, 326, 345, 380, + 345, 326, 381, 326, 334, 334, 334, 334, 335, 335, + 335, 335, 351, 351, 351, 351, 351, 351, 381, 352, + 352, 352, 352, 352, 352, 353, 365, 353, 383, 384, + 353, 353, 353, 353, 353, 353, 334, 352, 384, 385, + 352, 354, 354, 354, 354, 354, 354, 383, 803, 365, + 385, 352, 355, 355, 355, 355, 355, 355, 352, 387, + 415, 360, 361, 352, 356, 356, 356, 356, 356, 356, + 360, 361, 367, 354, 357, 357, 357, 357, 357, 357, + 415, 387, 356, 390, 355, 356, 360, 361, 363, 362, + + 367, 386, 357, 363, 382, 357, 356, 433, 367, 390, + 386, 388, 389, 356, 433, 801, 357, 798, 356, 382, + 388, 391, 362, 357, 362, 389, 393, 362, 357, 363, + 364, 366, 364, 362, 392, 364, 364, 364, 364, 364, + 364, 395, 394, 391, 400, 362, 395, 396, 393, 362, + 392, 392, 397, 362, 366, 398, 366, 399, 397, 366, + 394, 407, 396, 400, 401, 366, 408, 364, 399, 396, + 410, 409, 411, 416, 412, 417, 398, 366, 418, 401, + 409, 366, 407, 412, 409, 366, 419, 411, 408, 420, + 417, 423, 425, 410, 421, 416, 426, 430, 427, 428, + + 418, 419, 429, 421, 431, 434, 430, 432, 423, 420, + 435, 437, 434, 436, 438, 425, 440, 426, 427, 428, + 432, 436, 431, 441, 429, 438, 498, 442, 437, 497, + 468, 436, 441, 442, 497, 435, 469, 498, 440, 451, + 451, 451, 451, 462, 462, 462, 462, 462, 462, 463, + 463, 463, 463, 463, 463, 468, 489, 492, 490, 465, + 467, 462, 469, 493, 462, 494, 500, 463, 465, 467, + 463, 490, 492, 489, 499, 462, 496, 499, 494, 495, + 505, 463, 462, 493, 465, 467, 500, 462, 463, 496, + 506, 505, 523, 463, 464, 464, 464, 464, 464, 464, + + 466, 495, 466, 506, 523, 466, 466, 466, 466, 466, + 466, 471, 471, 471, 471, 471, 471, 472, 472, 472, + 472, 472, 472, 473, 501, 473, 464, 502, 473, 473, + 473, 473, 473, 473, 504, 472, 503, 466, 472, 504, + 509, 508, 510, 501, 511, 503, 512, 517, 502, 472, + 508, 512, 518, 511, 515, 519, 472, 520, 522, 510, + 531, 472, 509, 515, 524, 526, 520, 527, 529, 518, + 519, 532, 527, 517, 530, 522, 533, 529, 535, 524, + 526, 536, 531, 530, 532, 537, 535, 538, 539, 541, + 544, 536, 537, 533, 542, 545, 587, 588, 541, 595, + + 539, 797, 595, 587, 542, 796, 588, 544, 545, 538, + 564, 564, 564, 564, 564, 564, 565, 565, 565, 565, + 565, 565, 566, 566, 566, 566, 566, 566, 567, 598, + 567, 600, 591, 567, 567, 567, 567, 567, 567, 589, + 566, 590, 564, 566, 570, 570, 570, 570, 570, 570, + 592, 598, 589, 600, 566, 591, 795, 592, 590, 586, + 794, 566, 570, 594, 586, 570, 566, 593, 572, 572, + 572, 572, 572, 572, 596, 593, 570, 586, 597, 599, + 594, 601, 602, 570, 601, 605, 572, 596, 570, 572, + 603, 604, 606, 597, 608, 607, 599, 610, 611, 602, + + 572, 606, 612, 615, 616, 605, 604, 572, 618, 621, + 629, 661, 572, 607, 632, 622, 608, 603, 621, 610, + 629, 611, 622, 615, 612, 618, 631, 664, 666, 632, + 667, 616, 661, 666, 793, 631, 650, 650, 650, 650, + 650, 650, 651, 651, 651, 651, 651, 651, 662, 665, + 667, 670, 668, 664, 650, 668, 665, 650, 662, 669, + 651, 672, 669, 651, 673, 681, 676, 672, 650, 670, + 684, 679, 675, 673, 651, 650, 674, 792, 681, 674, + 650, 651, 677, 684, 688, 677, 651, 652, 652, 652, + 652, 652, 652, 675, 676, 678, 679, 680, 682, 683, + + 680, 686, 691, 692, 678, 694, 682, 688, 695, 683, + 686, 718, 713, 694, 717, 715, 714, 695, 719, 652, + 715, 716, 691, 791, 717, 692, 702, 702, 702, 702, + 702, 702, 713, 714, 718, 720, 716, 721, 720, 722, + 724, 727, 726, 724, 719, 726, 728, 730, 727, 728, + 721, 729, 749, 751, 729, 752, 753, 757, 702, 753, + 754, 755, 730, 758, 755, 759, 722, 761, 759, 762, + 779, 780, 762, 752, 751, 757, 764, 763, 780, 749, + 763, 781, 754, 782, 781, 764, 784, 783, 758, 761, + 783, 779, 782, 787, 790, 799, 787, 790, 802, 804, + + 800, 802, 804, 784, 799, 800, 805, 806, 809, 805, + 806, 810, 811, 812, 815, 811, 812, 789, 788, 786, + 785, 778, 777, 776, 775, 774, 810, 773, 809, 772, + 771, 770, 769, 768, 767, 766, 815, 821, 821, 821, + 821, 821, 821, 821, 821, 821, 821, 821, 821, 821, + 821, 821, 821, 821, 822, 822, 822, 822, 822, 822, + 822, 822, 822, 822, 822, 822, 822, 822, 822, 822, + 822, 823, 823, 823, 823, 823, 823, 823, 823, 823, + 823, 823, 823, 823, 823, 823, 823, 823, 824, 765, + 760, 824, 824, 756, 824, 824, 824, 824, 824, 824, + + 824, 824, 825, 750, 748, 747, 746, 745, 825, 825, + 825, 825, 825, 825, 825, 825, 826, 826, 826, 826, + 826, 826, 826, 826, 826, 826, 826, 826, 826, 826, + 826, 826, 826, 827, 744, 743, 827, 827, 742, 827, + 827, 827, 827, 827, 827, 827, 827, 828, 741, 828, + 828, 740, 828, 828, 828, 828, 828, 828, 828, 828, + 739, 828, 828, 828, 829, 738, 829, 737, 829, 736, + 829, 735, 734, 733, 829, 829, 732, 829, 829, 830, + 731, 725, 830, 830, 830, 830, 830, 830, 830, 830, + 830, 830, 723, 830, 830, 830, 831, 831, 831, 831, + + 831, 831, 831, 831, 831, 831, 831, 831, 831, 831, + 831, 831, 831, 832, 832, 832, 712, 832, 711, 710, + 709, 708, 832, 832, 833, 707, 706, 833, 833, 705, + 833, 833, 833, 833, 833, 833, 833, 833, 834, 834, + 704, 834, 701, 700, 699, 698, 834, 834, 835, 835, + 693, 835, 690, 689, 687, 685, 835, 835, 836, 836, + 671, 836, 663, 660, 655, 653, 836, 836, 837, 837, + 641, 837, 637, 635, 633, 630, 837, 837, 838, 838, + 628, 838, 627, 626, 625, 624, 838, 838, 839, 839, + 623, 839, 620, 619, 617, 614, 839, 839, 840, 840, + + 613, 840, 609, 584, 580, 578, 840, 840, 841, 841, + 576, 841, 574, 568, 562, 560, 841, 841, 842, 842, + 558, 842, 556, 554, 552, 550, 842, 842, 843, 843, + 843, 843, 843, 843, 843, 843, 843, 843, 843, 843, + 843, 843, 843, 843, 843, 844, 844, 548, 844, 547, + 546, 543, 540, 534, 844, 845, 845, 845, 528, 845, + 845, 845, 845, 525, 845, 845, 846, 846, 846, 521, + 846, 516, 514, 513, 491, 487, 846, 847, 847, 485, + 847, 483, 481, 479, 477, 847, 847, 848, 848, 476, + 848, 475, 474, 460, 458, 848, 848, 849, 849, 457, + + 849, 456, 454, 452, 449, 849, 849, 850, 850, 447, + 850, 445, 443, 439, 424, 422, 850, 851, 851, 414, + 851, 413, 406, 404, 402, 851, 851, 852, 852, 378, + 852, 376, 374, 372, 371, 370, 852, 853, 349, 347, + 853, 853, 346, 853, 853, 853, 853, 853, 853, 853, + 853, 854, 854, 854, 854, 854, 854, 854, 854, 854, + 854, 854, 854, 854, 854, 854, 854, 854, 855, 855, + 855, 855, 855, 855, 855, 855, 855, 855, 855, 855, + 855, 855, 855, 855, 855, 856, 856, 342, 856, 340, + 338, 336, 332, 856, 856, 857, 857, 330, 857, 329, + + 328, 319, 306, 857, 857, 858, 858, 285, 858, 264, + 262, 261, 260, 858, 858, 859, 859, 258, 859, 257, + 252, 248, 247, 243, 859, 860, 860, 240, 860, 239, + 228, 227, 222, 860, 860, 861, 861, 221, 861, 218, + 208, 206, 205, 204, 861, 862, 862, 200, 862, 199, + 197, 192, 173, 862, 862, 863, 863, 144, 863, 143, + 138, 135, 127, 124, 863, 864, 864, 123, 864, 119, + 100, 97, 94, 864, 864, 865, 865, 92, 865, 85, + 71, 69, 65, 44, 865, 866, 866, 39, 866, 36, + 33, 18, 11, 866, 866, 867, 867, 4, 867, 3, + + 0, 0, 0, 0, 867, 868, 868, 0, 868, 0, + 0, 0, 0, 868, 868, 869, 869, 0, 869, 0, + 0, 0, 0, 0, 869, 870, 870, 0, 870, 0, + 0, 0, 0, 870, 870, 871, 871, 0, 871, 0, + 0, 0, 0, 0, 871, 872, 872, 0, 872, 0, + 872, 0, 0, 872, 872, 873, 873, 0, 873, 0, + 873, 0, 0, 873, 873, 874, 874, 874, 0, 874, + 874, 874, 874, 0, 874, 874, 875, 875, 0, 875, + 0, 0, 0, 0, 875, 875, 876, 876, 0, 876, + 0, 0, 0, 0, 876, 876, 877, 877, 0, 877, + + 0, 0, 0, 0, 877, 877, 878, 878, 0, 878, + 0, 0, 0, 0, 0, 878, 879, 879, 0, 879, + 0, 0, 0, 0, 879, 879, 880, 880, 0, 880, + 0, 0, 0, 0, 0, 880, 881, 881, 0, 881, + 0, 0, 0, 0, 881, 881, 882, 882, 0, 882, + 0, 0, 0, 0, 0, 882, 883, 883, 0, 883, + 0, 0, 0, 0, 883, 883, 884, 884, 0, 884, + 0, 0, 0, 0, 0, 884, 885, 0, 0, 885, + 885, 0, 885, 885, 885, 885, 885, 885, 885, 885, + 886, 886, 886, 886, 886, 886, 886, 886, 886, 886, + + 886, 886, 886, 886, 886, 886, 886, 887, 887, 0, + 887, 0, 0, 0, 0, 887, 887, 888, 888, 0, + 888, 0, 0, 0, 0, 0, 888, 889, 889, 0, + 889, 0, 0, 0, 0, 889, 889, 890, 890, 0, + 890, 0, 0, 0, 0, 0, 890, 891, 891, 0, + 891, 0, 0, 0, 0, 891, 891, 892, 892, 0, + 892, 0, 0, 0, 0, 0, 892, 893, 893, 0, + 893, 0, 0, 0, 0, 893, 893, 894, 894, 0, + 894, 0, 0, 0, 0, 0, 894, 895, 895, 0, + 895, 0, 0, 0, 0, 895, 895, 896, 896, 0, + + 896, 0, 0, 0, 0, 0, 896, 897, 897, 0, + 897, 0, 0, 0, 0, 897, 897, 898, 898, 0, + 898, 0, 0, 0, 0, 0, 898, 899, 899, 0, + 899, 0, 0, 0, 0, 899, 899, 900, 900, 0, + 900, 0, 0, 0, 0, 900, 900, 901, 901, 0, + 901, 0, 0, 0, 0, 0, 901, 902, 902, 0, + 902, 0, 0, 0, 0, 902, 902, 903, 903, 0, + 903, 0, 0, 0, 0, 0, 903, 904, 904, 0, + 904, 0, 904, 0, 0, 904, 904, 905, 905, 0, + 905, 0, 0, 0, 0, 905, 905, 906, 906, 0, + + 906, 0, 0, 0, 0, 906, 906, 907, 907, 0, + 907, 0, 0, 0, 0, 0, 907, 908, 908, 0, + 908, 0, 0, 0, 0, 908, 908, 909, 909, 0, + 909, 0, 0, 0, 0, 0, 909, 910, 910, 0, + 910, 0, 0, 0, 0, 910, 910, 911, 911, 0, + 911, 0, 0, 0, 0, 0, 911, 912, 912, 0, + 912, 0, 0, 0, 0, 912, 912, 913, 913, 0, + 913, 0, 0, 0, 0, 0, 913, 914, 914, 0, + 914, 0, 0, 0, 0, 914, 914, 915, 915, 0, + 915, 0, 0, 0, 0, 0, 915, 916, 916, 0, + + 916, 0, 0, 0, 0, 916, 916, 917, 917, 0, + 917, 0, 0, 0, 0, 0, 917, 918, 0, 0, + 918, 918, 0, 918, 918, 918, 918, 918, 918, 918, + 918, 919, 919, 919, 919, 919, 919, 919, 919, 919, + 919, 919, 919, 919, 919, 919, 919, 919, 920, 920, + 0, 920, 0, 0, 0, 0, 920, 920, 921, 921, + 0, 921, 0, 0, 0, 0, 0, 921, 922, 922, + 0, 922, 0, 0, 0, 0, 922, 922, 923, 923, + 0, 923, 0, 0, 0, 0, 0, 923, 924, 924, + 0, 924, 0, 0, 0, 0, 924, 924, 925, 925, + + 0, 925, 0, 0, 0, 0, 0, 925, 926, 926, + 0, 926, 0, 0, 0, 0, 926, 926, 927, 927, + 0, 927, 0, 0, 0, 0, 0, 927, 928, 928, + 0, 928, 0, 0, 0, 0, 928, 928, 929, 929, + 0, 929, 0, 0, 0, 0, 0, 929, 930, 930, + 0, 930, 0, 0, 0, 0, 930, 930, 931, 931, + 0, 931, 0, 0, 0, 0, 0, 931, 932, 932, + 0, 932, 0, 0, 0, 0, 932, 932, 933, 933, + 0, 933, 0, 0, 0, 0, 0, 933, 934, 934, + 0, 934, 0, 0, 0, 0, 934, 934, 935, 935, + + 0, 935, 0, 0, 0, 0, 0, 935, 936, 936, + 0, 936, 0, 0, 0, 0, 936, 936, 937, 937, + 0, 937, 0, 0, 0, 0, 937, 937, 938, 938, + 0, 938, 0, 0, 0, 0, 0, 938, 939, 939, + 0, 939, 0, 0, 0, 0, 939, 939, 940, 940, + 0, 940, 0, 0, 0, 0, 0, 940, 941, 941, + 0, 941, 0, 0, 0, 0, 941, 941, 942, 942, + 0, 942, 0, 0, 0, 0, 0, 942, 943, 943, + 0, 943, 0, 0, 0, 0, 943, 943, 944, 944, + 0, 944, 0, 0, 0, 0, 0, 944, 945, 945, + + 0, 945, 0, 0, 0, 0, 0, 945, 946, 946, + 0, 946, 0, 0, 0, 0, 0, 946, 947, 0, + 0, 947, 947, 0, 947, 947, 947, 947, 947, 947, + 947, 947, 948, 948, 0, 948, 0, 0, 0, 0, + 0, 948, 949, 949, 949, 949, 949, 949, 949, 949, + 949, 949, 949, 949, 949, 949, 949, 949, 949, 950, + 950, 0, 950, 0, 0, 0, 0, 950, 950, 951, + 951, 0, 951, 0, 0, 0, 0, 0, 951, 952, + 952, 0, 952, 0, 0, 0, 0, 952, 952, 953, + 953, 0, 953, 0, 0, 0, 0, 0, 953, 954, + + 954, 0, 954, 0, 0, 0, 0, 0, 954, 955, + 955, 0, 955, 0, 0, 0, 0, 0, 955, 956, + 0, 0, 956, 956, 0, 956, 956, 956, 956, 956, + 956, 956, 956, 957, 957, 0, 957, 0, 0, 0, + 0, 0, 957, 958, 958, 0, 958, 0, 0, 0, + 0, 0, 958, 959, 959, 0, 959, 0, 0, 0, + 0, 0, 959, 960, 960, 0, 960, 0, 0, 0, + 0, 0, 960, 961, 961, 0, 961, 0, 0, 0, + 0, 0, 961, 962, 962, 0, 962, 0, 0, 0, + 0, 0, 962, 963, 963, 0, 963, 0, 0, 0, + + 0, 0, 963, 964, 964, 0, 964, 0, 0, 0, + 0, 964, 964, 965, 965, 0, 965, 0, 0, 0, + 0, 0, 965, 966, 966, 0, 966, 0, 0, 0, + 0, 966, 966, 967, 967, 0, 967, 0, 0, 0, + 0, 0, 967, 968, 968, 0, 968, 0, 0, 0, + 0, 0, 968, 969, 969, 0, 969, 0, 0, 0, + 0, 0, 969, 970, 970, 0, 970, 0, 0, 0, + 0, 0, 970, 971, 971, 0, 971, 0, 0, 0, + 0, 971, 971, 972, 0, 0, 972, 972, 0, 972, + 972, 972, 972, 972, 972, 972, 972, 973, 973, 0, + + 973, 0, 0, 0, 0, 0, 973, 974, 974, 0, + 974, 0, 0, 0, 0, 0, 974, 975, 975, 0, + 975, 0, 0, 0, 0, 975, 975, 976, 976, 0, + 976, 0, 0, 0, 0, 976, 976, 977, 977, 0, + 977, 0, 0, 0, 0, 977, 977, 978, 978, 0, + 978, 0, 0, 0, 0, 0, 978, 979, 979, 0, + 979, 0, 0, 0, 0, 979, 979, 980, 980, 0, + 980, 0, 0, 0, 0, 980, 980, 981, 981, 0, + 981, 0, 0, 0, 0, 981, 981, 982, 982, 0, + 982, 0, 0, 0, 0, 982, 982, 983, 983, 0, + + 983, 0, 0, 0, 0, 983, 983, 984, 984, 0, + 984, 0, 0, 0, 0, 984, 984, 985, 985, 0, + 985, 0, 0, 0, 0, 985, 985, 986, 986, 0, + 986, 0, 0, 0, 0, 986, 986, 987, 987, 0, + 987, 0, 0, 0, 0, 987, 987, 988, 988, 0, + 988, 0, 0, 0, 0, 988, 988, 989, 989, 0, + 989, 0, 0, 0, 0, 989, 989, 990, 990, 0, + 990, 0, 0, 0, 0, 990, 990, 991, 991, 0, + 991, 0, 0, 0, 0, 991, 991, 992, 992, 0, + 992, 0, 0, 0, 0, 992, 992, 993, 993, 0, + + 993, 0, 0, 0, 0, 993, 993, 994, 994, 0, + 994, 0, 0, 0, 0, 994, 994, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + 820, 820, 820, 820, 820, 820, 820, 820, 820, 820, + + 820, 820 + } ; + +/* Table of booleans, true if rule could match eol. */ +static yyconst flex_int32_t yy_rule_can_match_eol[171] = + { 0, +1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +extern int yy_flex_debug; +int yy_flex_debug = 0; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +#define yymore() yymore_used_but_not_detected +#define YY_MORE_ADJ 0 +#define YY_RESTORE_YY_MORE_OFFSET +char *yytext; +#line 1 "lex.ll" +/* + * Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo + * + * The contents of this file are covered under the licence agreement in the + * file "LICENCE" distributed with Cforall. + * + * lex.l -- + * + * Author : Peter A. Buhr + * Created On : Sat Sep 22 08:58:10 2001 + * Last Modified By : Peter A. Buhr + * Last Modified On : Sun May 31 23:41:32 2015 + * Update Count : 334 + */ +#line 19 "lex.ll" +// This lexer assumes the program has been preprocessed by cpp. Hence, all user level preprocessor directive +// have been performed and removed from the source. The only exceptions are preprocessor directives passed to +// the compiler (e.g., line-number directives) and C/C++ style comments, which are ignored. + +//**************************** Includes and Defines **************************** + +#include + +#include "lex.h" +#include "ParseNode.h" +#include "parser.h" // YACC generated definitions based on C++ grammar + +char *yyfilename; +std::string *strtext; // accumulate parts of character and string constant value + +#define WHITE_RETURN(x) // do nothing +#define NEWLINE_RETURN() WHITE_RETURN('\n') +#define RETURN_VAL(x) yylval.tok.str = new std::string(yytext); \ + yylval.tok.loc.file = yyfilename; \ + yylval.tok.loc.line = yylineno; \ + return(x) +#define RETURN_STR(x) yylval.tok.str = strtext; \ + yylval.tok.loc.file = yyfilename; \ + yylval.tok.loc.line = yylineno; \ + return(x) + +#define KEYWORD_RETURN(x) RETURN_VAL(x) // keyword +#define IDENTIFIER_RETURN() RETURN_VAL((typedefTable.isIdentifier(yytext) ? IDENTIFIER : typedefTable.isTypedef(yytext) ? TYPEDEFname : TYPEGENname)) +//#define ATTRIBUTE_RETURN() RETURN_VAL((typedefTable.isIdentifier(yytext) ? ATTR_IDENTIFIER : typedefTable.isTypedef(yytext) ? ATTR_TYPEDEFname : ATTR_TYPEGENname)) +#define ATTRIBUTE_RETURN() RETURN_VAL(ATTR_IDENTIFIER) + +#define ASCIIOP_RETURN() RETURN_VAL((int)yytext[0]) // single character operator +#define NAMEDOP_RETURN(x) RETURN_VAL(x) // multichar operator, with a name + +#define NUMERIC_RETURN(x) rm_underscore(); RETURN_VAL(x) // numeric constant + +void rm_underscore() { + // remove underscores in numeric constant + int j = 0; + for ( int i = 0; yytext[i] != '\0'; i += 1 ) { + if ( yytext[i] != '_' ) { + yytext[j] = yytext[i]; + j += 1; + } // if + } // for + yyleng = j; + yytext[yyleng] = '\0'; +} + +// identifier, GCC: $ in identifier +// quoted identifier +// attribute identifier, GCC: $ in identifier +// numeric constants, CFA: '_' in constant +// character escape sequence, GCC: \e => esc character +// ' stop highlighting +// display/white-space characters +// operators + + + + +#line 1667 "Parser/lex.cc" + +#define INITIAL 0 +#define COMMENT 1 +#define BKQUOTE 2 +#define QUOTE 3 +#define STRING 4 + +#ifndef YY_NO_UNISTD_H +/* Special case for "unistd.h", since it is non-ANSI. We include it way + * down here because we want the user's section 1 to have been scanned first. + * The user has a chance to override it with an option. + */ +#include +#endif + +#ifndef YY_EXTRA_TYPE +#define YY_EXTRA_TYPE void * +#endif + +static int yy_init_globals (void ); + +/* Accessor methods to globals. + These are made visible to non-reentrant scanners for convenience. */ + +int yylex_destroy (void ); + +int yyget_debug (void ); + +void yyset_debug (int debug_flag ); + +YY_EXTRA_TYPE yyget_extra (void ); + +void yyset_extra (YY_EXTRA_TYPE user_defined ); + +FILE *yyget_in (void ); + +void yyset_in (FILE * in_str ); + +FILE *yyget_out (void ); + +void yyset_out (FILE * out_str ); + +int yyget_leng (void ); + +char *yyget_text (void ); + +int yyget_lineno (void ); + +void yyset_lineno (int line_number ); + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap (void ); +#else +extern int yywrap (void ); +#endif +#endif + + static void yyunput (int c,char *buf_ptr ); + +#ifndef yytext_ptr +static void yy_flex_strncpy (char *,yyconst char *,int ); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen (yyconst char * ); +#endif + +#ifndef YY_NO_INPUT + +#ifdef __cplusplus +static int yyinput (void ); +#else +static int input (void ); +#endif + +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k */ +#define YY_READ_BUF_SIZE 16384 +#else +#define YY_READ_BUF_SIZE 8192 +#endif /* __ia64__ */ +#endif + +/* Copy whatever the last rule matched to the standard output. */ +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ + { \ + int c = '*'; \ + size_t n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else \ + { \ + errno=0; \ + while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ + { \ + if( errno != EINTR) \ + { \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + break; \ + } \ + errno=0; \ + clearerr(yyin); \ + } \ + }\ +\ + +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* end tables serialization structures and prototypes */ + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL_IS_OURS 1 + +extern int yylex (void); + +#define YY_DECL int yylex (void) +#endif /* !YY_DECL */ + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK break; +#endif + +#define YY_RULE_SETUP \ + if ( yyleng > 0 ) \ + YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ + (yytext[yyleng - 1] == '\n'); \ + YY_USER_ACTION + +/** The main scanner function which does all the work. + */ +YY_DECL +{ + register yy_state_type yy_current_state; + register char *yy_cp, *yy_bp; + register int yy_act; + +#line 140 "lex.ll" + + /* line directives */ +#line 1864 "Parser/lex.cc" + + if ( !(yy_init) ) + { + (yy_init) = 1; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! (yy_start) ) + (yy_start) = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! YY_CURRENT_BUFFER ) { + yyensure_buffer_stack (); + YY_CURRENT_BUFFER_LVALUE = + yy_create_buffer(yyin,YY_BUF_SIZE ); + } + + yy_load_buffer_state( ); + } + + while ( 1 ) /* loops until end-of-file is reached */ + { + yy_cp = (yy_c_buf_p); + + /* Support of yytext. */ + *yy_cp = (yy_hold_char); + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = (yy_start); + yy_current_state += YY_AT_BOL(); +yy_match: + do + { + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 821 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 3518 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + + if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] ) + { + int yyl; + for ( yyl = 0; yyl < yyleng; ++yyl ) + if ( yytext[yyl] == '\n' ) + + yylineno++; +; + } + +do_action: /* This label is used only to access EOF actions. */ + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = (yy_hold_char); + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); + goto yy_find_action; + +case 1: +/* rule 1 can match eol */ +YY_RULE_SETUP +#line 142 "lex.ll" +{ + /* " stop highlighting */ + char *end_num; + char *begin_string, *end_string; + char *filename; + long lineno, length; + lineno = strtol( yytext + 1, &end_num, 0 ); + begin_string = strchr( end_num, '"' ); + if ( begin_string ) { + end_string = strchr( begin_string + 1, '"' ); + if ( end_string ) { + length = end_string - begin_string - 1; + filename = new char[ length + 1 ]; + memcpy( filename, begin_string + 1, length ); + filename[ length ] = '\0'; + //std::cout << "file " << filename << " line " << lineno << std::endl; + yylineno = lineno; + yyfilename = filename; + } // if + } // if +} + YY_BREAK +/* ignore preprocessor directives (for now) */ +case 2: +/* rule 2 can match eol */ +YY_RULE_SETUP +#line 165 "lex.ll" +; + YY_BREAK +/* ignore C style comments */ +case 3: +YY_RULE_SETUP +#line 168 "lex.ll" +{ BEGIN COMMENT; } + YY_BREAK +case 4: +/* rule 4 can match eol */ +YY_RULE_SETUP +#line 169 "lex.ll" +; + YY_BREAK +case 5: +YY_RULE_SETUP +#line 170 "lex.ll" +{ BEGIN 0; } + YY_BREAK +/* ignore C++ style comments */ +case 6: +/* rule 6 can match eol */ +YY_RULE_SETUP +#line 173 "lex.ll" +; + YY_BREAK +/* ignore whitespace */ +case 7: +YY_RULE_SETUP +#line 176 "lex.ll" +{ WHITE_RETURN(' '); } + YY_BREAK +case 8: +YY_RULE_SETUP +#line 177 "lex.ll" +{ WHITE_RETURN(' '); } + YY_BREAK +case 9: +/* rule 9 can match eol */ +YY_RULE_SETUP +#line 178 "lex.ll" +{ NEWLINE_RETURN(); } + YY_BREAK +/* keywords */ +case 10: +YY_RULE_SETUP +#line 181 "lex.ll" +{ KEYWORD_RETURN(ALIGNAS); } // C11 + YY_BREAK +case 11: +YY_RULE_SETUP +#line 182 "lex.ll" +{ KEYWORD_RETURN(ALIGNOF); } // C11 + YY_BREAK +case 12: +YY_RULE_SETUP +#line 183 "lex.ll" +{ KEYWORD_RETURN(ALIGNOF); } // GCC + YY_BREAK +case 13: +YY_RULE_SETUP +#line 184 "lex.ll" +{ KEYWORD_RETURN(ALIGNOF); } // GCC + YY_BREAK +case 14: +YY_RULE_SETUP +#line 185 "lex.ll" +{ KEYWORD_RETURN(ASM); } + YY_BREAK +case 15: +YY_RULE_SETUP +#line 186 "lex.ll" +{ KEYWORD_RETURN(ASM); } // GCC + YY_BREAK +case 16: +YY_RULE_SETUP +#line 187 "lex.ll" +{ KEYWORD_RETURN(ASM); } // GCC + YY_BREAK +case 17: +YY_RULE_SETUP +#line 188 "lex.ll" +{ KEYWORD_RETURN(ATOMIC); } // C11 + YY_BREAK +case 18: +YY_RULE_SETUP +#line 189 "lex.ll" +{ KEYWORD_RETURN(ATTRIBUTE); } // GCC + YY_BREAK +case 19: +YY_RULE_SETUP +#line 190 "lex.ll" +{ KEYWORD_RETURN(ATTRIBUTE); } // GCC + YY_BREAK +case 20: +YY_RULE_SETUP +#line 191 "lex.ll" +{ KEYWORD_RETURN(AUTO); } + YY_BREAK +case 21: +YY_RULE_SETUP +#line 192 "lex.ll" +{ KEYWORD_RETURN(BOOL); } // C99 + YY_BREAK +case 22: +YY_RULE_SETUP +#line 193 "lex.ll" +{ KEYWORD_RETURN(BREAK); } + YY_BREAK +case 23: +YY_RULE_SETUP +#line 194 "lex.ll" +{ KEYWORD_RETURN(CASE); } + YY_BREAK +case 24: +YY_RULE_SETUP +#line 195 "lex.ll" +{ KEYWORD_RETURN(CATCH); } // CFA + YY_BREAK +case 25: +YY_RULE_SETUP +#line 196 "lex.ll" +{ KEYWORD_RETURN(CHAR); } + YY_BREAK +case 26: +YY_RULE_SETUP +#line 197 "lex.ll" +{ KEYWORD_RETURN(CHOOSE); } // CFA + YY_BREAK +case 27: +YY_RULE_SETUP +#line 198 "lex.ll" +{ KEYWORD_RETURN(COMPLEX); } // C99 + YY_BREAK +case 28: +YY_RULE_SETUP +#line 199 "lex.ll" +{ KEYWORD_RETURN(COMPLEX); } // GCC + YY_BREAK +case 29: +YY_RULE_SETUP +#line 200 "lex.ll" +{ KEYWORD_RETURN(COMPLEX); } // GCC + YY_BREAK +case 30: +YY_RULE_SETUP +#line 201 "lex.ll" +{ KEYWORD_RETURN(CONST); } + YY_BREAK +case 31: +YY_RULE_SETUP +#line 202 "lex.ll" +{ KEYWORD_RETURN(CONST); } // GCC + YY_BREAK +case 32: +YY_RULE_SETUP +#line 203 "lex.ll" +{ KEYWORD_RETURN(CONST); } // GCC + YY_BREAK +case 33: +YY_RULE_SETUP +#line 204 "lex.ll" +{ KEYWORD_RETURN(CONTEXT); } // CFA + YY_BREAK +case 34: +YY_RULE_SETUP +#line 205 "lex.ll" +{ KEYWORD_RETURN(CONTINUE); } + YY_BREAK +case 35: +YY_RULE_SETUP +#line 206 "lex.ll" +{ KEYWORD_RETURN(DEFAULT); } + YY_BREAK +case 36: +YY_RULE_SETUP +#line 207 "lex.ll" +{ KEYWORD_RETURN(DO); } + YY_BREAK +case 37: +YY_RULE_SETUP +#line 208 "lex.ll" +{ KEYWORD_RETURN(DOUBLE); } + YY_BREAK +case 38: +YY_RULE_SETUP +#line 209 "lex.ll" +{ KEYWORD_RETURN(DTYPE); } // CFA + YY_BREAK +case 39: +YY_RULE_SETUP +#line 210 "lex.ll" +{ KEYWORD_RETURN(ELSE); } + YY_BREAK +case 40: +YY_RULE_SETUP +#line 211 "lex.ll" +{ KEYWORD_RETURN(ENUM); } + YY_BREAK +case 41: +YY_RULE_SETUP +#line 212 "lex.ll" +{ KEYWORD_RETURN(EXTENSION); } // GCC + YY_BREAK +case 42: +YY_RULE_SETUP +#line 213 "lex.ll" +{ KEYWORD_RETURN(EXTERN); } + YY_BREAK +case 43: +YY_RULE_SETUP +#line 214 "lex.ll" +{ KEYWORD_RETURN(FALLTHRU); } // CFA + YY_BREAK +case 44: +YY_RULE_SETUP +#line 215 "lex.ll" +{ KEYWORD_RETURN(FINALLY); } // CFA + YY_BREAK +case 45: +YY_RULE_SETUP +#line 216 "lex.ll" +{ KEYWORD_RETURN(FLOAT); } + YY_BREAK +case 46: +YY_RULE_SETUP +#line 217 "lex.ll" +{ KEYWORD_RETURN(FLOAT); } // GCC + YY_BREAK +case 47: +YY_RULE_SETUP +#line 218 "lex.ll" +{ KEYWORD_RETURN(FOR); } + YY_BREAK +case 48: +YY_RULE_SETUP +#line 219 "lex.ll" +{ KEYWORD_RETURN(FORALL); } // CFA + YY_BREAK +case 49: +YY_RULE_SETUP +#line 220 "lex.ll" +{ KEYWORD_RETURN(FORTRAN); } + YY_BREAK +case 50: +YY_RULE_SETUP +#line 221 "lex.ll" +{ KEYWORD_RETURN(FTYPE); } // CFA + YY_BREAK +case 51: +YY_RULE_SETUP +#line 222 "lex.ll" +{ KEYWORD_RETURN(GENERIC); } // C11 + YY_BREAK +case 52: +YY_RULE_SETUP +#line 223 "lex.ll" +{ KEYWORD_RETURN(GOTO); } + YY_BREAK +case 53: +YY_RULE_SETUP +#line 224 "lex.ll" +{ KEYWORD_RETURN(IF); } + YY_BREAK +case 54: +YY_RULE_SETUP +#line 225 "lex.ll" +{ KEYWORD_RETURN(IMAGINARY); } // C99 + YY_BREAK +case 55: +YY_RULE_SETUP +#line 226 "lex.ll" +{ KEYWORD_RETURN(IMAGINARY); } // GCC + YY_BREAK +case 56: +YY_RULE_SETUP +#line 227 "lex.ll" +{ KEYWORD_RETURN(IMAGINARY); } // GCC + YY_BREAK +case 57: +YY_RULE_SETUP +#line 228 "lex.ll" +{ KEYWORD_RETURN(INLINE); } // C99 + YY_BREAK +case 58: +YY_RULE_SETUP +#line 229 "lex.ll" +{ KEYWORD_RETURN(INLINE); } // GCC + YY_BREAK +case 59: +YY_RULE_SETUP +#line 230 "lex.ll" +{ KEYWORD_RETURN(INLINE); } // GCC + YY_BREAK +case 60: +YY_RULE_SETUP +#line 231 "lex.ll" +{ KEYWORD_RETURN(INT); } + YY_BREAK +case 61: +YY_RULE_SETUP +#line 232 "lex.ll" +{ KEYWORD_RETURN(INT); } // GCC + YY_BREAK +case 62: +YY_RULE_SETUP +#line 233 "lex.ll" +{ KEYWORD_RETURN(LABEL); } // GCC + YY_BREAK +case 63: +YY_RULE_SETUP +#line 234 "lex.ll" +{ KEYWORD_RETURN(LONG); } + YY_BREAK +case 64: +YY_RULE_SETUP +#line 235 "lex.ll" +{ KEYWORD_RETURN(LVALUE); } // CFA + YY_BREAK +case 65: +YY_RULE_SETUP +#line 236 "lex.ll" +{ KEYWORD_RETURN(NORETURN); } // C11 + YY_BREAK +case 66: +YY_RULE_SETUP +#line 237 "lex.ll" +{ KEYWORD_RETURN(REGISTER); } + YY_BREAK +case 67: +YY_RULE_SETUP +#line 238 "lex.ll" +{ KEYWORD_RETURN(RESTRICT); } // C99 + YY_BREAK +case 68: +YY_RULE_SETUP +#line 239 "lex.ll" +{ KEYWORD_RETURN(RESTRICT); } // GCC + YY_BREAK +case 69: +YY_RULE_SETUP +#line 240 "lex.ll" +{ KEYWORD_RETURN(RESTRICT); } // GCC + YY_BREAK +case 70: +YY_RULE_SETUP +#line 241 "lex.ll" +{ KEYWORD_RETURN(RETURN); } + YY_BREAK +case 71: +YY_RULE_SETUP +#line 242 "lex.ll" +{ KEYWORD_RETURN(SHORT); } + YY_BREAK +case 72: +YY_RULE_SETUP +#line 243 "lex.ll" +{ KEYWORD_RETURN(SIGNED); } + YY_BREAK +case 73: +YY_RULE_SETUP +#line 244 "lex.ll" +{ KEYWORD_RETURN(SIGNED); } // GCC + YY_BREAK +case 74: +YY_RULE_SETUP +#line 245 "lex.ll" +{ KEYWORD_RETURN(SIGNED); } // GCC + YY_BREAK +case 75: +YY_RULE_SETUP +#line 246 "lex.ll" +{ KEYWORD_RETURN(SIZEOF); } + YY_BREAK +case 76: +YY_RULE_SETUP +#line 247 "lex.ll" +{ KEYWORD_RETURN(STATIC); } + YY_BREAK +case 77: +YY_RULE_SETUP +#line 248 "lex.ll" +{ KEYWORD_RETURN(STATICASSERT); } // C11 + YY_BREAK +case 78: +YY_RULE_SETUP +#line 249 "lex.ll" +{ KEYWORD_RETURN(STRUCT); } + YY_BREAK +case 79: +YY_RULE_SETUP +#line 250 "lex.ll" +{ KEYWORD_RETURN(SWITCH); } + YY_BREAK +case 80: +YY_RULE_SETUP +#line 251 "lex.ll" +{ KEYWORD_RETURN(THREADLOCAL); } // C11 + YY_BREAK +case 81: +YY_RULE_SETUP +#line 252 "lex.ll" +{ KEYWORD_RETURN(THROW); } // CFA + YY_BREAK +case 82: +YY_RULE_SETUP +#line 253 "lex.ll" +{ KEYWORD_RETURN(TRY); } // CFA + YY_BREAK +case 83: +YY_RULE_SETUP +#line 254 "lex.ll" +{ KEYWORD_RETURN(TYPE); } // CFA + YY_BREAK +case 84: +YY_RULE_SETUP +#line 255 "lex.ll" +{ KEYWORD_RETURN(TYPEDEF); } + YY_BREAK +case 85: +YY_RULE_SETUP +#line 256 "lex.ll" +{ KEYWORD_RETURN(TYPEOF); } // GCC + YY_BREAK +case 86: +YY_RULE_SETUP +#line 257 "lex.ll" +{ KEYWORD_RETURN(TYPEOF); } // GCC + YY_BREAK +case 87: +YY_RULE_SETUP +#line 258 "lex.ll" +{ KEYWORD_RETURN(TYPEOF); } // GCC + YY_BREAK +case 88: +YY_RULE_SETUP +#line 259 "lex.ll" +{ KEYWORD_RETURN(UNION); } + YY_BREAK +case 89: +YY_RULE_SETUP +#line 260 "lex.ll" +{ KEYWORD_RETURN(UNSIGNED); } + YY_BREAK +case 90: +YY_RULE_SETUP +#line 261 "lex.ll" +{ KEYWORD_RETURN(VOID); } + YY_BREAK +case 91: +YY_RULE_SETUP +#line 262 "lex.ll" +{ KEYWORD_RETURN(VOLATILE); } + YY_BREAK +case 92: +YY_RULE_SETUP +#line 263 "lex.ll" +{ KEYWORD_RETURN(VOLATILE); } // GCC + YY_BREAK +case 93: +YY_RULE_SETUP +#line 264 "lex.ll" +{ KEYWORD_RETURN(VOLATILE); } // GCC + YY_BREAK +case 94: +YY_RULE_SETUP +#line 265 "lex.ll" +{ KEYWORD_RETURN(WHILE); } + YY_BREAK +/* identifier */ +case 95: +YY_RULE_SETUP +#line 268 "lex.ll" +{ IDENTIFIER_RETURN(); } + YY_BREAK +case 96: +YY_RULE_SETUP +#line 269 "lex.ll" +{ ATTRIBUTE_RETURN(); } + YY_BREAK +case 97: +YY_RULE_SETUP +#line 270 "lex.ll" +{ BEGIN BKQUOTE; } + YY_BREAK +case 98: +YY_RULE_SETUP +#line 271 "lex.ll" +{ IDENTIFIER_RETURN(); } + YY_BREAK +case 99: +YY_RULE_SETUP +#line 272 "lex.ll" +{ BEGIN 0; } + YY_BREAK +/* numeric constants */ +case 100: +YY_RULE_SETUP +#line 275 "lex.ll" +{ NUMERIC_RETURN(ZERO); } // CFA + YY_BREAK +case 101: +YY_RULE_SETUP +#line 276 "lex.ll" +{ NUMERIC_RETURN(ONE); } // CFA + YY_BREAK +case 102: +YY_RULE_SETUP +#line 277 "lex.ll" +{ NUMERIC_RETURN(INTEGERconstant); } + YY_BREAK +case 103: +YY_RULE_SETUP +#line 278 "lex.ll" +{ NUMERIC_RETURN(INTEGERconstant); } + YY_BREAK +case 104: +YY_RULE_SETUP +#line 279 "lex.ll" +{ NUMERIC_RETURN(INTEGERconstant); } + YY_BREAK +case 105: +YY_RULE_SETUP +#line 280 "lex.ll" +{ NUMERIC_RETURN(FLOATINGconstant); } + YY_BREAK +case 106: +YY_RULE_SETUP +#line 281 "lex.ll" +{ NUMERIC_RETURN(FLOATINGconstant); } + YY_BREAK +/* character constant, allows empty value */ +case 107: +YY_RULE_SETUP +#line 284 "lex.ll" +{ BEGIN QUOTE; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); } + YY_BREAK +case 108: +YY_RULE_SETUP +#line 285 "lex.ll" +{ *strtext += std::string( yytext ); } + YY_BREAK +case 109: +/* rule 109 can match eol */ +YY_RULE_SETUP +#line 286 "lex.ll" +{ BEGIN 0; *strtext += std::string( yytext); RETURN_STR(CHARACTERconstant); } + YY_BREAK +/* ' stop highlighting */ +/* string constant */ +case 110: +YY_RULE_SETUP +#line 290 "lex.ll" +{ BEGIN STRING; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); } + YY_BREAK +case 111: +YY_RULE_SETUP +#line 291 "lex.ll" +{ *strtext += std::string( yytext ); } + YY_BREAK +case 112: +/* rule 112 can match eol */ +YY_RULE_SETUP +#line 292 "lex.ll" +{ BEGIN 0; *strtext += std::string( yytext); RETURN_STR(STRINGliteral); } + YY_BREAK +/* " stop highlighting */ +case 113: +YY_RULE_SETUP +#line 295 "lex.ll" +{ rm_underscore(); *strtext += std::string( yytext ); } + YY_BREAK +case 114: +YY_RULE_SETUP +#line 296 "lex.ll" +{ *strtext += std::string( yytext ); } // unknown escape character + YY_BREAK +/* punctuation */ +case 115: +YY_RULE_SETUP +#line 299 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK +case 116: +YY_RULE_SETUP +#line 300 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK +case 117: +YY_RULE_SETUP +#line 301 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK +case 118: +YY_RULE_SETUP +#line 302 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK +case 119: +YY_RULE_SETUP +#line 303 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK +case 120: +YY_RULE_SETUP +#line 304 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK +case 121: +YY_RULE_SETUP +#line 305 "lex.ll" +{ ASCIIOP_RETURN(); } // also operator + YY_BREAK +case 122: +YY_RULE_SETUP +#line 306 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK +case 123: +YY_RULE_SETUP +#line 307 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK +case 124: +YY_RULE_SETUP +#line 308 "lex.ll" +{ ASCIIOP_RETURN(); } // also operator + YY_BREAK +case 125: +YY_RULE_SETUP +#line 309 "lex.ll" +{ NAMEDOP_RETURN(ELLIPSIS); } + YY_BREAK +/* alternative C99 brackets, "<:" & "<:<:" handled by preprocessor */ +case 126: +YY_RULE_SETUP +#line 312 "lex.ll" +{ RETURN_VAL('['); } + YY_BREAK +case 127: +YY_RULE_SETUP +#line 313 "lex.ll" +{ RETURN_VAL(']'); } + YY_BREAK +case 128: +YY_RULE_SETUP +#line 314 "lex.ll" +{ RETURN_VAL('{'); } + YY_BREAK +case 129: +YY_RULE_SETUP +#line 315 "lex.ll" +{ RETURN_VAL('}'); } + YY_BREAK +/* operators */ +case 130: +YY_RULE_SETUP +#line 318 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK +case 131: +YY_RULE_SETUP +#line 319 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK +case 132: +YY_RULE_SETUP +#line 320 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK +case 133: +YY_RULE_SETUP +#line 321 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK +case 134: +YY_RULE_SETUP +#line 322 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK +case 135: +YY_RULE_SETUP +#line 323 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK +case 136: +YY_RULE_SETUP +#line 324 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK +case 137: +YY_RULE_SETUP +#line 325 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK +case 138: +YY_RULE_SETUP +#line 326 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK +case 139: +YY_RULE_SETUP +#line 327 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK +case 140: +YY_RULE_SETUP +#line 328 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK +case 141: +YY_RULE_SETUP +#line 329 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK +case 142: +YY_RULE_SETUP +#line 330 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK +case 143: +YY_RULE_SETUP +#line 331 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK +case 144: +YY_RULE_SETUP +#line 333 "lex.ll" +{ NAMEDOP_RETURN(ICR); } + YY_BREAK +case 145: +YY_RULE_SETUP +#line 334 "lex.ll" +{ NAMEDOP_RETURN(DECR); } + YY_BREAK +case 146: +YY_RULE_SETUP +#line 335 "lex.ll" +{ NAMEDOP_RETURN(EQ); } + YY_BREAK +case 147: +YY_RULE_SETUP +#line 336 "lex.ll" +{ NAMEDOP_RETURN(NE); } + YY_BREAK +case 148: +YY_RULE_SETUP +#line 337 "lex.ll" +{ NAMEDOP_RETURN(LS); } + YY_BREAK +case 149: +YY_RULE_SETUP +#line 338 "lex.ll" +{ NAMEDOP_RETURN(RS); } + YY_BREAK +case 150: +YY_RULE_SETUP +#line 339 "lex.ll" +{ NAMEDOP_RETURN(LE); } + YY_BREAK +case 151: +YY_RULE_SETUP +#line 340 "lex.ll" +{ NAMEDOP_RETURN(GE); } + YY_BREAK +case 152: +YY_RULE_SETUP +#line 341 "lex.ll" +{ NAMEDOP_RETURN(ANDAND); } + YY_BREAK +case 153: +YY_RULE_SETUP +#line 342 "lex.ll" +{ NAMEDOP_RETURN(OROR); } + YY_BREAK +case 154: +YY_RULE_SETUP +#line 343 "lex.ll" +{ NAMEDOP_RETURN(ARROW); } + YY_BREAK +case 155: +YY_RULE_SETUP +#line 344 "lex.ll" +{ NAMEDOP_RETURN(PLUSassign); } + YY_BREAK +case 156: +YY_RULE_SETUP +#line 345 "lex.ll" +{ NAMEDOP_RETURN(MINUSassign); } + YY_BREAK +case 157: +YY_RULE_SETUP +#line 346 "lex.ll" +{ NAMEDOP_RETURN(MULTassign); } + YY_BREAK +case 158: +YY_RULE_SETUP +#line 347 "lex.ll" +{ NAMEDOP_RETURN(DIVassign); } + YY_BREAK +case 159: +YY_RULE_SETUP +#line 348 "lex.ll" +{ NAMEDOP_RETURN(MODassign); } + YY_BREAK +case 160: +YY_RULE_SETUP +#line 349 "lex.ll" +{ NAMEDOP_RETURN(ANDassign); } + YY_BREAK +case 161: +YY_RULE_SETUP +#line 350 "lex.ll" +{ NAMEDOP_RETURN(ORassign); } + YY_BREAK +case 162: +YY_RULE_SETUP +#line 351 "lex.ll" +{ NAMEDOP_RETURN(ERassign); } + YY_BREAK +case 163: +YY_RULE_SETUP +#line 352 "lex.ll" +{ NAMEDOP_RETURN(LSassign); } + YY_BREAK +case 164: +YY_RULE_SETUP +#line 353 "lex.ll" +{ NAMEDOP_RETURN(RSassign); } + YY_BREAK +/* CFA, operator identifier */ +case 165: +YY_RULE_SETUP +#line 356 "lex.ll" +{ IDENTIFIER_RETURN(); } // unary + YY_BREAK +case 166: +YY_RULE_SETUP +#line 357 "lex.ll" +{ IDENTIFIER_RETURN(); } + YY_BREAK +case 167: +YY_RULE_SETUP +#line 358 "lex.ll" +{ IDENTIFIER_RETURN(); } // binary + YY_BREAK +/* + This rule handles ambiguous cases with operator identifiers, e.g., "int *?*?()", where the string "*?*?" + can be lexed as "*"/"?*?" or "*?"/"*?". Since it is common practise to put a unary operator juxtaposed + to an identifier, e.g., "*i", users will be annoyed if they cannot do this with respect to operator + identifiers. Even with this special hack, there are 5 general cases that cannot be handled. The first + case is for the function-call identifier "?()": + + int * ?()(); // declaration: space required after '*' + * ?()(); // expression: space required after '*' + + Without the space, the string "*?()" is ambiguous without N character look ahead; it requires scanning + ahead to determine if there is a '(', which is the start of an argument/parameter list. + + The 4 remaining cases occur in expressions: + + i++?i:0; // space required before '?' + i--?i:0; // space required before '?' + i?++i:0; // space required after '?' + i?--i:0; // space required after '?' + + In the first two cases, the string "i++?" is ambiguous, where this string can be lexed as "i"/"++?" or + "i++"/"?"; it requires scanning ahead to determine if there is a '(', which is the start of an argument + list. In the second two cases, the string "?++x" is ambiguous, where this string can be lexed as + "?++"/"x" or "?"/"++x"; it requires scanning ahead to determine if there is a '(', which is the start of + an argument list. + */ +case 168: +YY_RULE_SETUP +#line 385 "lex.ll" +{ + // 1 or 2 character unary operator ? + int i = yytext[1] == '?' ? 1 : 2; + yyless( i ); // put back characters up to first '?' + if ( i > 1 ) { + NAMEDOP_RETURN( yytext[0] == '+' ? ICR : DECR ); + } else { + ASCIIOP_RETURN(); + } // if +} + YY_BREAK +/* unknown characters */ +case 169: +YY_RULE_SETUP +#line 397 "lex.ll" +{ printf("unknown character(s):\"%s\" on line %d\n", yytext, yylineno); } + YY_BREAK +case 170: +YY_RULE_SETUP +#line 399 "lex.ll" +ECHO; + YY_BREAK +#line 2886 "Parser/lex.cc" +case YY_STATE_EOF(INITIAL): +case YY_STATE_EOF(COMMENT): +case YY_STATE_EOF(BKQUOTE): +case YY_STATE_EOF(QUOTE): +case YY_STATE_EOF(STRING): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = (yy_hold_char); + YY_RESTORE_YY_MORE_OFFSET + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between YY_CURRENT_BUFFER and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( ); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++(yy_c_buf_p); + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = (yy_c_buf_p); + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer( ) ) + { + case EOB_ACT_END_OF_FILE: + { + (yy_did_buffer_switch_on_eof) = 0; + + if ( yywrap( ) ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! (yy_did_buffer_switch_on_eof) ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + (yy_c_buf_p) = + (yytext_ptr) + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( ); + + yy_cp = (yy_c_buf_p); + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + (yy_c_buf_p) = + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; + + yy_current_state = yy_get_previous_state( ); + + yy_cp = (yy_c_buf_p); + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ +} /* end of yylex */ + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ +static int yy_get_next_buffer (void) +{ + register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; + register char *source = (yytext_ptr); + register int number_to_move, i; + int ret_val; + + if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1; + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; + + else + { + int num_to_read = + YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = YY_CURRENT_BUFFER; + + int yy_c_buf_p_offset = + (int) ((yy_c_buf_p) - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = 0; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - + number_to_move - 1; + + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), + (yy_n_chars), (size_t) num_to_read ); + + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + if ( (yy_n_chars) == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart(yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { + /* Extend the array by 50%, plus the number we really need. */ + yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ); + if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); + } + + (yy_n_chars) += number_to_move; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; + + (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; + + return ret_val; +} + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + + static yy_state_type yy_get_previous_state (void) +{ + register yy_state_type yy_current_state; + register char *yy_cp; + + yy_current_state = (yy_start); + yy_current_state += YY_AT_BOL(); + + for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) + { + register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 821 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + } + + return yy_current_state; +} + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) +{ + register int yy_is_jam; + register char *yy_cp = (yy_c_buf_p); + + register YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 821 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_is_jam = (yy_current_state == 820); + + return yy_is_jam ? 0 : yy_current_state; +} + + static void yyunput (int c, register char * yy_bp ) +{ + register char *yy_cp; + + yy_cp = (yy_c_buf_p); + + /* undo effects of setting up yytext */ + *yy_cp = (yy_hold_char); + + if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + register int number_to_move = (yy_n_chars) + 2; + register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ + YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; + register char *source = + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; + + while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size; + + if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + + if ( c == '\n' ){ + --yylineno; + } + + (yytext_ptr) = yy_bp; + (yy_hold_char) = *yy_cp; + (yy_c_buf_p) = yy_cp; +} + +#ifndef YY_NO_INPUT +#ifdef __cplusplus + static int yyinput (void) +#else + static int input (void) +#endif + +{ + int c; + + *(yy_c_buf_p) = (yy_hold_char); + + if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) + /* This was really a NUL. */ + *(yy_c_buf_p) = '\0'; + + else + { /* need more input */ + int offset = (yy_c_buf_p) - (yytext_ptr); + ++(yy_c_buf_p); + + switch ( yy_get_next_buffer( ) ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart(yyin ); + + /*FALLTHROUGH*/ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap( ) ) + return EOF; + + if ( ! (yy_did_buffer_switch_on_eof) ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + (yy_c_buf_p) = (yytext_ptr) + offset; + break; + } + } + } + + c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ + *(yy_c_buf_p) = '\0'; /* preserve yytext */ + (yy_hold_char) = *++(yy_c_buf_p); + + YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n'); + if ( YY_CURRENT_BUFFER_LVALUE->yy_at_bol ) + + yylineno++; +; + + return c; +} +#endif /* ifndef YY_NO_INPUT */ + +/** Immediately switch to a different input stream. + * @param input_file A readable stream. + * + * @note This function does not reset the start condition to @c INITIAL . + */ + void yyrestart (FILE * input_file ) +{ + + if ( ! YY_CURRENT_BUFFER ){ + yyensure_buffer_stack (); + YY_CURRENT_BUFFER_LVALUE = + yy_create_buffer(yyin,YY_BUF_SIZE ); + } + + yy_init_buffer(YY_CURRENT_BUFFER,input_file ); + yy_load_buffer_state( ); +} + +/** Switch to a different input buffer. + * @param new_buffer The new input buffer. + * + */ + void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) +{ + + /* TODO. We should be able to replace this entire function body + * with + * yypop_buffer_state(); + * yypush_buffer_state(new_buffer); + */ + yyensure_buffer_stack (); + if ( YY_CURRENT_BUFFER == new_buffer ) + return; + + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *(yy_c_buf_p) = (yy_hold_char); + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + YY_CURRENT_BUFFER_LVALUE = new_buffer; + yy_load_buffer_state( ); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + (yy_did_buffer_switch_on_eof) = 1; +} + +static void yy_load_buffer_state (void) +{ + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; + yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; + (yy_hold_char) = *(yy_c_buf_p); +} + +/** Allocate and initialize an input buffer state. + * @param file A readable stream. + * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. + * + * @return the allocated buffer state. + */ + YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) +{ + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer(b,file ); + + return b; +} + +/** Destroy the buffer. + * @param b a buffer created with yy_create_buffer() + * + */ + void yy_delete_buffer (YY_BUFFER_STATE b ) +{ + + if ( ! b ) + return; + + if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ + YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yyfree((void *) b->yy_ch_buf ); + + yyfree((void *) b ); +} + +#ifndef __cplusplus +extern int isatty (int ); +#endif /* __cplusplus */ + +/* Initializes or reinitializes a buffer. + * This function is sometimes called more than once on the same buffer, + * such as during a yyrestart() or at EOF. + */ + static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) + +{ + int oerrno = errno; + + yy_flush_buffer(b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + + /* If b is the current buffer, then yy_init_buffer was _probably_ + * called from yyrestart() or through yy_get_next_buffer. + * In that case, we don't want to reset the lineno or column. + */ + if (b != YY_CURRENT_BUFFER){ + b->yy_bs_lineno = 1; + b->yy_bs_column = 0; + } + + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; + + errno = oerrno; +} + +/** Discard all buffered characters. On the next scan, YY_INPUT will be called. + * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. + * + */ + void yy_flush_buffer (YY_BUFFER_STATE b ) +{ + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == YY_CURRENT_BUFFER ) + yy_load_buffer_state( ); +} + +/** Pushes the new state onto the stack. The new state becomes + * the current state. This function will allocate the stack + * if necessary. + * @param new_buffer The new state. + * + */ +void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) +{ + if (new_buffer == NULL) + return; + + yyensure_buffer_stack(); + + /* This block is copied from yy_switch_to_buffer. */ + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *(yy_c_buf_p) = (yy_hold_char); + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + /* Only push if top exists. Otherwise, replace top. */ + if (YY_CURRENT_BUFFER) + (yy_buffer_stack_top)++; + YY_CURRENT_BUFFER_LVALUE = new_buffer; + + /* copied from yy_switch_to_buffer. */ + yy_load_buffer_state( ); + (yy_did_buffer_switch_on_eof) = 1; +} + +/** Removes and deletes the top of the stack, if present. + * The next element becomes the new top. + * + */ +void yypop_buffer_state (void) +{ + if (!YY_CURRENT_BUFFER) + return; + + yy_delete_buffer(YY_CURRENT_BUFFER ); + YY_CURRENT_BUFFER_LVALUE = NULL; + if ((yy_buffer_stack_top) > 0) + --(yy_buffer_stack_top); + + if (YY_CURRENT_BUFFER) { + yy_load_buffer_state( ); + (yy_did_buffer_switch_on_eof) = 1; + } +} + +/* Allocates the stack if it does not exist. + * Guarantees space for at least one push. + */ +static void yyensure_buffer_stack (void) +{ + int num_to_alloc; + + if (!(yy_buffer_stack)) { + + /* First allocation is just for 2 elements, since we don't know if this + * scanner will even need a stack. We use 2 instead of 1 to avoid an + * immediate realloc on the next call. + */ + num_to_alloc = 1; + (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc + (num_to_alloc * sizeof(struct yy_buffer_state*) + ); + if ( ! (yy_buffer_stack) ) + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); + + memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); + + (yy_buffer_stack_max) = num_to_alloc; + (yy_buffer_stack_top) = 0; + return; + } + + if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ + + /* Increase the buffer to prepare for a possible push. */ + int grow_size = 8 /* arbitrary grow size */; + + num_to_alloc = (yy_buffer_stack_max) + grow_size; + (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc + ((yy_buffer_stack), + num_to_alloc * sizeof(struct yy_buffer_state*) + ); + if ( ! (yy_buffer_stack) ) + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); + + /* zero only the new slots.*/ + memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); + (yy_buffer_stack_max) = num_to_alloc; + } +} + +/** Setup the input buffer state to scan directly from a user-specified character buffer. + * @param base the character buffer + * @param size the size in bytes of the character buffer + * + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) +{ + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return 0; + + b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = 0; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer(b ); + + return b; +} + +/** Setup the input buffer state to scan a string. The next call to yylex() will + * scan from a @e copy of @a str. + * @param yystr a NUL-terminated string to scan + * + * @return the newly allocated buffer state object. + * @note If you want to scan bytes that may contain NUL values, then use + * yy_scan_bytes() instead. + */ +YY_BUFFER_STATE yy_scan_string (yyconst char * yystr ) +{ + + return yy_scan_bytes(yystr,strlen(yystr) ); +} + +/** Setup the input buffer state to scan the given bytes. The next call to yylex() will + * scan from a @e copy of @a bytes. + * @param yybytes the byte buffer to scan + * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. + * + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, int _yybytes_len ) +{ + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = _yybytes_len + 2; + buf = (char *) yyalloc(n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < _yybytes_len; ++i ) + buf[i] = yybytes[i]; + + buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer(buf,n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; +} + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +static void yy_fatal_error (yyconst char* msg ) +{ + (void) fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); +} + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + int yyless_macro_arg = (n); \ + YY_LESS_LINENO(yyless_macro_arg);\ + yytext[yyleng] = (yy_hold_char); \ + (yy_c_buf_p) = yytext + yyless_macro_arg; \ + (yy_hold_char) = *(yy_c_buf_p); \ + *(yy_c_buf_p) = '\0'; \ + yyleng = yyless_macro_arg; \ + } \ + while ( 0 ) + +/* Accessor methods (get/set functions) to struct members. */ + +/** Get the current line number. + * + */ +int yyget_lineno (void) +{ + + return yylineno; +} + +/** Get the input stream. + * + */ +FILE *yyget_in (void) +{ + return yyin; +} + +/** Get the output stream. + * + */ +FILE *yyget_out (void) +{ + return yyout; +} + +/** Get the length of the current token. + * + */ +int yyget_leng (void) +{ + return yyleng; +} + +/** Get the current token. + * + */ + +char *yyget_text (void) +{ + return yytext; +} + +/** Set the current line number. + * @param line_number + * + */ +void yyset_lineno (int line_number ) +{ + + yylineno = line_number; +} + +/** Set the input stream. This does not discard the current + * input buffer. + * @param in_str A readable stream. + * + * @see yy_switch_to_buffer + */ +void yyset_in (FILE * in_str ) +{ + yyin = in_str ; +} + +void yyset_out (FILE * out_str ) +{ + yyout = out_str ; +} + +int yyget_debug (void) +{ + return yy_flex_debug; +} + +void yyset_debug (int bdebug ) +{ + yy_flex_debug = bdebug ; +} + +static int yy_init_globals (void) +{ + /* Initialization is the same as for the non-reentrant scanner. + * This function is called from yylex_destroy(), so don't allocate here. + */ + + /* We do not touch yylineno unless the option is enabled. */ + yylineno = 1; + + (yy_buffer_stack) = 0; + (yy_buffer_stack_top) = 0; + (yy_buffer_stack_max) = 0; + (yy_c_buf_p) = (char *) 0; + (yy_init) = 0; + (yy_start) = 0; + +/* Defined in main.c */ +#ifdef YY_STDINIT + yyin = stdin; + yyout = stdout; +#else + yyin = (FILE *) 0; + yyout = (FILE *) 0; +#endif + + /* For future reference: Set errno on error, since we are called by + * yylex_init() + */ + return 0; +} + +/* yylex_destroy is for both reentrant and non-reentrant scanners. */ +int yylex_destroy (void) +{ + + /* Pop the buffer stack, destroying each element. */ + while(YY_CURRENT_BUFFER){ + yy_delete_buffer(YY_CURRENT_BUFFER ); + YY_CURRENT_BUFFER_LVALUE = NULL; + yypop_buffer_state(); + } + + /* Destroy the stack itself. */ + yyfree((yy_buffer_stack) ); + (yy_buffer_stack) = NULL; + + /* Reset the globals. This is important in a non-reentrant scanner so the next time + * yylex() is called, initialization will occur. */ + yy_init_globals( ); + + return 0; +} + +/* + * Internal utility routines. + */ + +#ifndef yytext_ptr +static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ) +{ + register int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; +} +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen (yyconst char * s ) +{ + register int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; +} +#endif + +void *yyalloc (yy_size_t size ) +{ + return (void *) malloc( size ); +} + +void *yyrealloc (void * ptr, yy_size_t size ) +{ + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return (void *) realloc( (char *) ptr, size ); +} + +void yyfree (void * ptr ) +{ + free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ +} + +#define YYTABLES_NAME "yytables" + +#line 399 "lex.ll" + + + +// Local Variables: // +// fill-column: 110 // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // + Index: src/Parser/lex.l =================================================================== --- src/Parser/lex.l (revision 00cc023285120a85a7e80e417220f36483ebd413) +++ (revision ) @@ -1,406 +1,0 @@ -/* - * Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo - * - * The contents of this file are covered under the licence agreement in the - * file "LICENCE" distributed with Cforall. - * - * lex.l -- - * - * Author : Peter A. Buhr - * Created On : Sat Sep 22 08:58:10 2001 - * Last Modified By : Peter A. Buhr - * Last Modified On : Tue May 19 15:41:54 2015 - * Update Count : 331 - */ - -%option yylineno - -%{ -// This lexer assumes the program has been preprocessed by cpp. Hence, all user level preprocessor directive -// have been performed and removed from the source. The only exceptions are preprocessor directives passed to -// the compiler (e.g., line-number directives) and C/C++ style comments, which are ignored. - -//**************************** Includes and Defines **************************** - -#include - -#include "lex.h" -#include "ParseNode.h" -#include "cfa.tab.h" // YACC generated definitions based on C++ grammar - -char *yyfilename; -std::string *strtext; // accumulate parts of character and string constant value - -#define WHITE_RETURN(x) // do nothing -#define NEWLINE_RETURN() WHITE_RETURN('\n') -#define RETURN_VAL(x) yylval.tok.str = new std::string(yytext); \ - yylval.tok.loc.file = yyfilename; \ - yylval.tok.loc.line = yylineno; \ - return(x) -#define RETURN_STR(x) yylval.tok.str = strtext; \ - yylval.tok.loc.file = yyfilename; \ - yylval.tok.loc.line = yylineno; \ - return(x) - -#define KEYWORD_RETURN(x) RETURN_VAL(x) // keyword -#define IDENTIFIER_RETURN() RETURN_VAL((typedefTable.isIdentifier(yytext) ? IDENTIFIER : typedefTable.isTypedef(yytext) ? TYPEDEFname : TYPEGENname)) -//#define ATTRIBUTE_RETURN() RETURN_VAL((typedefTable.isIdentifier(yytext) ? ATTR_IDENTIFIER : typedefTable.isTypedef(yytext) ? ATTR_TYPEDEFname : ATTR_TYPEGENname)) -#define ATTRIBUTE_RETURN() RETURN_VAL(ATTR_IDENTIFIER) - -#define ASCIIOP_RETURN() RETURN_VAL((int)yytext[0]) // single character operator -#define NAMEDOP_RETURN(x) RETURN_VAL(x) // multichar operator, with a name - -#define NUMERIC_RETURN(x) rm_underscore(); RETURN_VAL(x) // numeric constant - -void rm_underscore() { - // remove underscores in numeric constant - int j = 0; - for ( int i = 0; yytext[i] != '\0'; i += 1 ) { - if ( yytext[i] != '_' ) { - yytext[j] = yytext[i]; - j += 1; - } // if - } // for - yyleng = j; - yytext[yyleng] = '\0'; -} - -%} - -octal [0-7] -nonzero [1-9] -decimal [0-9] -hex [0-9a-fA-F] -universal_char "\\"((u"_"?{hex_quad})|(U"_"?{hex_quad}{2})) - - // identifier, GCC: $ in identifier -identifier ([a-zA-Z_$]|{universal_char})([0-9a-zA-Z_$]|{universal_char})* - - // quoted identifier -quoted_identifier "`"{identifier}"`" - - // attribute identifier, GCC: $ in identifier -attr_identifier "@"{identifier} - - // numeric constants, CFA: '_' in constant -hex_quad {hex}("_"?{hex}){3} -integer_suffix "_"?(([uU][lL]?)|([uU]("ll"|"LL")?)|([lL][uU]?)|("ll"|"LL")[uU]?) - -octal_digits ({octal})|({octal}({octal}|"_")*{octal}) -octal_prefix "0""_"? -octal_constant (("0")|({octal_prefix}{octal_digits})){integer_suffix}? - -nonzero_digits ({nonzero})|({nonzero}({decimal}|"_")*{decimal}) -decimal_constant {nonzero_digits}{integer_suffix}? - -hex_digits ({hex})|({hex}({hex}|"_")*{hex}) -hex_prefix "0"[xX]"_"? -hex_constant {hex_prefix}{hex_digits}{integer_suffix}? - -decimal_digits ({decimal})|({decimal}({decimal}|"_")*{decimal}) -fractional_constant ({decimal_digits}?"."{decimal_digits})|({decimal_digits}".") -exponent "_"?[eE]"_"?[+-]?{decimal_digits} -floating_suffix "_"?[flFL] -floating_constant (({fractional_constant}{exponent}?)|({decimal_digits}{exponent})){floating_suffix}? - -binary_exponent "_"?[pP]"_"?[+-]?{decimal_digits} -hex_fractional_constant ({hex_digits}?"."{hex_digits})|({hex_digits}".") -hex_floating_constant {hex_prefix}(({hex_fractional_constant}{binary_exponent})|({hex_digits}{binary_exponent})){floating_suffix}? - - // character escape sequence, GCC: \e => esc character -simple_escape "\\"[abefnrtv'"?\\] - // ' stop highlighting -octal_escape "\\"{octal}("_"?{octal}){0,2} -hex_escape "\\""x""_"?{hex_digits} -escape_seq {simple_escape}|{octal_escape}|{hex_escape}|{universal_char} - - // display/white-space characters -h_tab [\011] -form_feed [\014] -v_tab [\013] -c_return [\015] -h_white [ ]|{h_tab} - - // operators -op_unary_only "~"|"!" -op_unary_binary "+"|"-"|"*" -op_unary_pre_post "++"|"--" -op_unary {op_unary_only}|{op_unary_binary}|{op_unary_pre_post} - -op_binary_only "/"|"%"|"^"|"&"|"|"|"<"|">"|"="|"=="|"!="|"<<"|">>"|"<="|">="|"+="|"-="|"*="|"/="|"%="|"&="|"|="|"^="|"<<="|">>=" -op_binary_over {op_unary_binary}|{op_binary_only} -op_binary_not_over "?"|"->"|"&&"|"||" -operator {op_unary_pre_post}|{op_binary_over}|{op_binary_not_over} - -%x COMMENT -%x BKQUOTE -%x QUOTE -%x STRING - -%% - /* line directives */ -^{h_white}*"#"{h_white}*[0-9]+{h_white}*["][^"\n]+["][^\n]*"\n" { - /* " stop highlighting */ - char *end_num; - char *begin_string, *end_string; - char *filename; - long lineno, length; - lineno = strtol( yytext + 1, &end_num, 0 ); - begin_string = strchr( end_num, '"' ); - if ( begin_string ) { - end_string = strchr( begin_string + 1, '"' ); - if ( end_string ) { - length = end_string - begin_string - 1; - filename = new char[ length + 1 ]; - memcpy( filename, begin_string + 1, length ); - filename[ length ] = '\0'; - //std::cout << "file " << filename << " line " << lineno << std::endl; - yylineno = lineno; - yyfilename = filename; - } // if - } // if -} - - /* ignore preprocessor directives (for now) */ -^{h_white}*"#"[^\n]*"\n" ; - - /* ignore C style comments */ -"/*" { BEGIN COMMENT; } -.|\n ; -"*/" { BEGIN 0; } - - /* ignore C++ style comments */ -"//"[^\n]*"\n" ; - - /* ignore whitespace */ -{h_white}+ { WHITE_RETURN(' '); } -({v_tab}|{c_return}|{form_feed})+ { WHITE_RETURN(' '); } -({h_white}|{v_tab}|{c_return}|{form_feed})*"\n" { NEWLINE_RETURN(); } - - /* keywords */ -_Alignas { KEYWORD_RETURN(ALIGNAS); } // C11 -_Alignof { KEYWORD_RETURN(ALIGNOF); } // C11 -__alignof { KEYWORD_RETURN(ALIGNOF); } // GCC -__alignof__ { KEYWORD_RETURN(ALIGNOF); } // GCC -asm { KEYWORD_RETURN(ASM); } -__asm { KEYWORD_RETURN(ASM); } // GCC -__asm__ { KEYWORD_RETURN(ASM); } // GCC -_Atomic { KEYWORD_RETURN(ATOMIC); } // C11 -__attribute { KEYWORD_RETURN(ATTRIBUTE); } // GCC -__attribute__ { KEYWORD_RETURN(ATTRIBUTE); } // GCC -auto { KEYWORD_RETURN(AUTO); } -_Bool { KEYWORD_RETURN(BOOL); } // C99 -break { KEYWORD_RETURN(BREAK); } -case { KEYWORD_RETURN(CASE); } -catch { KEYWORD_RETURN(CATCH); } // CFA -char { KEYWORD_RETURN(CHAR); } -choose { KEYWORD_RETURN(CHOOSE); } // CFA -_Complex { KEYWORD_RETURN(COMPLEX); } // C99 -__complex { KEYWORD_RETURN(COMPLEX); } // GCC -__complex__ { KEYWORD_RETURN(COMPLEX); } // GCC -const { KEYWORD_RETURN(CONST); } -__const { KEYWORD_RETURN(CONST); } // GCC -__const__ { KEYWORD_RETURN(CONST); } // GCC -context { KEYWORD_RETURN(CONTEXT); } // CFA -continue { KEYWORD_RETURN(CONTINUE); } -default { KEYWORD_RETURN(DEFAULT); } -do { KEYWORD_RETURN(DO); } -double { KEYWORD_RETURN(DOUBLE); } -dtype { KEYWORD_RETURN(DTYPE); } // CFA -else { KEYWORD_RETURN(ELSE); } -enum { KEYWORD_RETURN(ENUM); } -__extension__ { KEYWORD_RETURN(EXTENSION); } // GCC -extern { KEYWORD_RETURN(EXTERN); } -fallthru { KEYWORD_RETURN(FALLTHRU); } // CFA -finally { KEYWORD_RETURN(FINALLY); } // CFA -float { KEYWORD_RETURN(FLOAT); } -__float128 { KEYWORD_RETURN(FLOAT); } // GCC -for { KEYWORD_RETURN(FOR); } -forall { KEYWORD_RETURN(FORALL); } // CFA -fortran { KEYWORD_RETURN(FORTRAN); } -ftype { KEYWORD_RETURN(FTYPE); } // CFA -_Generic { KEYWORD_RETURN(GENERIC); } // C11 -goto { KEYWORD_RETURN(GOTO); } -if { KEYWORD_RETURN(IF); } -_Imaginary { KEYWORD_RETURN(IMAGINARY); } // C99 -__imag { KEYWORD_RETURN(IMAGINARY); } // GCC -__imag__ { KEYWORD_RETURN(IMAGINARY); } // GCC -inline { KEYWORD_RETURN(INLINE); } // C99 -__inline { KEYWORD_RETURN(INLINE); } // GCC -__inline__ { KEYWORD_RETURN(INLINE); } // GCC -int { KEYWORD_RETURN(INT); } -__int128 { KEYWORD_RETURN(INT); } // GCC -__label__ { KEYWORD_RETURN(LABEL); } // GCC -long { KEYWORD_RETURN(LONG); } -lvalue { KEYWORD_RETURN(LVALUE); } // CFA -_Noreturn { KEYWORD_RETURN(NORETURN); } // C11 -register { KEYWORD_RETURN(REGISTER); } -restrict { KEYWORD_RETURN(RESTRICT); } // C99 -__restrict { KEYWORD_RETURN(RESTRICT); } // GCC -__restrict__ { KEYWORD_RETURN(RESTRICT); } // GCC -return { KEYWORD_RETURN(RETURN); } -short { KEYWORD_RETURN(SHORT); } -signed { KEYWORD_RETURN(SIGNED); } -__signed { KEYWORD_RETURN(SIGNED); } // GCC -__signed__ { KEYWORD_RETURN(SIGNED); } // GCC -sizeof { KEYWORD_RETURN(SIZEOF); } -static { KEYWORD_RETURN(STATIC); } -_Static_assert { KEYWORD_RETURN(STATICASSERT); } // C11 -struct { KEYWORD_RETURN(STRUCT); } -switch { KEYWORD_RETURN(SWITCH); } -_Thread_local { KEYWORD_RETURN(THREADLOCAL); } // C11 -throw { KEYWORD_RETURN(THROW); } // CFA -try { KEYWORD_RETURN(TRY); } // CFA -type { KEYWORD_RETURN(TYPE); } // CFA -typedef { KEYWORD_RETURN(TYPEDEF); } -typeof { KEYWORD_RETURN(TYPEOF); } // GCC -__typeof { KEYWORD_RETURN(TYPEOF); } // GCC -__typeof__ { KEYWORD_RETURN(TYPEOF); } // GCC -union { KEYWORD_RETURN(UNION); } -unsigned { KEYWORD_RETURN(UNSIGNED); } -void { KEYWORD_RETURN(VOID); } -volatile { KEYWORD_RETURN(VOLATILE); } -__volatile { KEYWORD_RETURN(VOLATILE); } // GCC -__volatile__ { KEYWORD_RETURN(VOLATILE); } // GCC -while { KEYWORD_RETURN(WHILE); } - - /* identifier */ -{identifier} { IDENTIFIER_RETURN(); } -{attr_identifier} { ATTRIBUTE_RETURN(); } -"`" { BEGIN BKQUOTE; } -{identifier} { IDENTIFIER_RETURN(); } -"`" { BEGIN 0; } - - /* numeric constants */ -"0" { NUMERIC_RETURN(ZERO); } // CFA -"1" { NUMERIC_RETURN(ONE); } // CFA -{decimal_constant} { NUMERIC_RETURN(INTEGERconstant); } -{octal_constant} { NUMERIC_RETURN(INTEGERconstant); } -{hex_constant} { NUMERIC_RETURN(INTEGERconstant); } -{floating_constant} { NUMERIC_RETURN(FLOATINGconstant); } -{hex_floating_constant} { NUMERIC_RETURN(FLOATINGconstant); } - - /* character constant, allows empty value */ -"L"?"_"?['] { BEGIN QUOTE; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); } -[^'\\\n]* { *strtext += std::string( yytext ); } -['\n] { BEGIN 0; *strtext += std::string( yytext); RETURN_STR(CHARACTERconstant); } - /* ' stop highlighting */ - - /* string constant */ -"L"?"_"?["] { BEGIN STRING; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); } -[^"\\\n]* { *strtext += std::string( yytext ); } -["\n] { BEGIN 0; *strtext += std::string( yytext); RETURN_STR(STRINGliteral); } - /* " stop highlighting */ - -{escape_seq} { rm_underscore(); *strtext += std::string( yytext ); } -[\\] { *strtext += std::string( yytext ); } // unknown escape character - - /* punctuation */ -"[" { ASCIIOP_RETURN(); } -"]" { ASCIIOP_RETURN(); } -"(" { ASCIIOP_RETURN(); } -")" { ASCIIOP_RETURN(); } -"{" { ASCIIOP_RETURN(); } -"}" { ASCIIOP_RETURN(); } -"," { ASCIIOP_RETURN(); } // also operator -":" { ASCIIOP_RETURN(); } -";" { ASCIIOP_RETURN(); } -"." { ASCIIOP_RETURN(); } // also operator -"..." { NAMEDOP_RETURN(ELLIPSIS); } - - /* alternative C99 brackets, "<:" & "<:<:" handled by preprocessor */ -"<:" { RETURN_VAL('['); } -":>" { RETURN_VAL(']'); } -"<%" { RETURN_VAL('{'); } -"%>" { RETURN_VAL('}'); } - - /* operators */ -"!" { ASCIIOP_RETURN(); } -"+" { ASCIIOP_RETURN(); } -"-" { ASCIIOP_RETURN(); } -"*" { ASCIIOP_RETURN(); } -"/" { ASCIIOP_RETURN(); } -"%" { ASCIIOP_RETURN(); } -"^" { ASCIIOP_RETURN(); } -"~" { ASCIIOP_RETURN(); } -"&" { ASCIIOP_RETURN(); } -"|" { ASCIIOP_RETURN(); } -"<" { ASCIIOP_RETURN(); } -">" { ASCIIOP_RETURN(); } -"=" { ASCIIOP_RETURN(); } -"?" { ASCIIOP_RETURN(); } - -"++" { NAMEDOP_RETURN(ICR); } -"--" { NAMEDOP_RETURN(DECR); } -"==" { NAMEDOP_RETURN(EQ); } -"!=" { NAMEDOP_RETURN(NE); } -"<<" { NAMEDOP_RETURN(LS); } -">>" { NAMEDOP_RETURN(RS); } -"<=" { NAMEDOP_RETURN(LE); } -">=" { NAMEDOP_RETURN(GE); } -"&&" { NAMEDOP_RETURN(ANDAND); } -"||" { NAMEDOP_RETURN(OROR); } -"->" { NAMEDOP_RETURN(ARROW); } -"+=" { NAMEDOP_RETURN(PLUSassign); } -"-=" { NAMEDOP_RETURN(MINUSassign); } -"*=" { NAMEDOP_RETURN(MULTassign); } -"/=" { NAMEDOP_RETURN(DIVassign); } -"%=" { NAMEDOP_RETURN(MODassign); } -"&=" { NAMEDOP_RETURN(ANDassign); } -"|=" { NAMEDOP_RETURN(ORassign); } -"^=" { NAMEDOP_RETURN(ERassign); } -"<<=" { NAMEDOP_RETURN(LSassign); } -">>=" { NAMEDOP_RETURN(RSassign); } - - /* CFA, operator identifier */ -{op_unary}"?" { IDENTIFIER_RETURN(); } // unary -"?"({op_unary_pre_post}|"()"|"[?]") { IDENTIFIER_RETURN(); } -"?"{op_binary_over}"?" { IDENTIFIER_RETURN(); } // binary - /* - This rule handles ambiguous cases with operator identifiers, e.g., "int *?*?()", where the string "*?*?" - can be lexed as "*"/"?*?" or "*?"/"*?". Since it is common practise to put a unary operator juxtaposed - to an identifier, e.g., "*i", users will be annoyed if they cannot do this with respect to operator - identifiers. Even with this special hack, there are 5 general cases that cannot be handled. The first - case is for the function-call identifier "?()": - - int * ?()(); // declaration: space required after '*' - * ?()(); // expression: space required after '*' - - Without the space, the string "*?()" is ambiguous without N character look ahead; it requires scanning - ahead to determine if there is a '(', which is the start of an argument/parameter list. - - The 4 remaining cases occur in expressions: - - i++?i:0; // space required before '?' - i--?i:0; // space required before '?' - i?++i:0; // space required after '?' - i?--i:0; // space required after '?' - - In the first two cases, the string "i++?" is ambiguous, where this string can be lexed as "i"/"++?" or - "i++"/"?"; it requires scanning ahead to determine if there is a '(', which is the start of an argument - list. In the second two cases, the string "?++x" is ambiguous, where this string can be lexed as - "?++"/"x" or "?"/"++x"; it requires scanning ahead to determine if there is a '(', which is the start of - an argument list. - */ -{op_unary}"?"(({op_unary_pre_post}|"[?]")|({op_binary_over}"?")) { - // 1 or 2 character unary operator ? - int i = yytext[1] == '?' ? 1 : 2; - yyless( i ); // put back characters up to first '?' - if ( i > 1 ) { - NAMEDOP_RETURN( yytext[0] == '+' ? ICR : DECR ); - } else { - ASCIIOP_RETURN(); - } // if -} - - /* unknown characters */ -. { printf("unknown character(s):\"%s\" on line %d\n", yytext, yylineno); } - -%% - -// Local Variables: // -// fill-column: 110 // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: src/Parser/lex.ll =================================================================== --- src/Parser/lex.ll (revision 56c393547addff0a409b2886d25499bdf0079ca7) +++ src/Parser/lex.ll (revision 56c393547addff0a409b2886d25499bdf0079ca7) @@ -0,0 +1,406 @@ +/* + * Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo + * + * The contents of this file are covered under the licence agreement in the + * file "LICENCE" distributed with Cforall. + * + * lex.l -- + * + * Author : Peter A. Buhr + * Created On : Sat Sep 22 08:58:10 2001 + * Last Modified By : Peter A. Buhr + * Last Modified On : Sun May 31 23:41:32 2015 + * Update Count : 334 + */ + +%option yylineno + +%{ +// This lexer assumes the program has been preprocessed by cpp. Hence, all user level preprocessor directive +// have been performed and removed from the source. The only exceptions are preprocessor directives passed to +// the compiler (e.g., line-number directives) and C/C++ style comments, which are ignored. + +//**************************** Includes and Defines **************************** + +#include + +#include "lex.h" +#include "ParseNode.h" +#include "parser.h" // YACC generated definitions based on C++ grammar + +char *yyfilename; +std::string *strtext; // accumulate parts of character and string constant value + +#define WHITE_RETURN(x) // do nothing +#define NEWLINE_RETURN() WHITE_RETURN('\n') +#define RETURN_VAL(x) yylval.tok.str = new std::string(yytext); \ + yylval.tok.loc.file = yyfilename; \ + yylval.tok.loc.line = yylineno; \ + return(x) +#define RETURN_STR(x) yylval.tok.str = strtext; \ + yylval.tok.loc.file = yyfilename; \ + yylval.tok.loc.line = yylineno; \ + return(x) + +#define KEYWORD_RETURN(x) RETURN_VAL(x) // keyword +#define IDENTIFIER_RETURN() RETURN_VAL((typedefTable.isIdentifier(yytext) ? IDENTIFIER : typedefTable.isTypedef(yytext) ? TYPEDEFname : TYPEGENname)) +//#define ATTRIBUTE_RETURN() RETURN_VAL((typedefTable.isIdentifier(yytext) ? ATTR_IDENTIFIER : typedefTable.isTypedef(yytext) ? ATTR_TYPEDEFname : ATTR_TYPEGENname)) +#define ATTRIBUTE_RETURN() RETURN_VAL(ATTR_IDENTIFIER) + +#define ASCIIOP_RETURN() RETURN_VAL((int)yytext[0]) // single character operator +#define NAMEDOP_RETURN(x) RETURN_VAL(x) // multichar operator, with a name + +#define NUMERIC_RETURN(x) rm_underscore(); RETURN_VAL(x) // numeric constant + +void rm_underscore() { + // remove underscores in numeric constant + int j = 0; + for ( int i = 0; yytext[i] != '\0'; i += 1 ) { + if ( yytext[i] != '_' ) { + yytext[j] = yytext[i]; + j += 1; + } // if + } // for + yyleng = j; + yytext[yyleng] = '\0'; +} + +%} + +octal [0-7] +nonzero [1-9] +decimal [0-9] +hex [0-9a-fA-F] +universal_char "\\"((u"_"?{hex_quad})|(U"_"?{hex_quad}{2})) + + // identifier, GCC: $ in identifier +identifier ([a-zA-Z_$]|{universal_char})([0-9a-zA-Z_$]|{universal_char})* + + // quoted identifier +quoted_identifier "`"{identifier}"`" + + // attribute identifier, GCC: $ in identifier +attr_identifier "@"{identifier} + + // numeric constants, CFA: '_' in constant +hex_quad {hex}("_"?{hex}){3} +integer_suffix "_"?(([uU][lL]?)|([uU]("ll"|"LL")?)|([lL][uU]?)|("ll"|"LL")[uU]?) + +octal_digits ({octal})|({octal}({octal}|"_")*{octal}) +octal_prefix "0""_"? +octal_constant (("0")|({octal_prefix}{octal_digits})){integer_suffix}? + +nonzero_digits ({nonzero})|({nonzero}({decimal}|"_")*{decimal}) +decimal_constant {nonzero_digits}{integer_suffix}? + +hex_digits ({hex})|({hex}({hex}|"_")*{hex}) +hex_prefix "0"[xX]"_"? +hex_constant {hex_prefix}{hex_digits}{integer_suffix}? + +decimal_digits ({decimal})|({decimal}({decimal}|"_")*{decimal}) +fractional_constant ({decimal_digits}?"."{decimal_digits})|({decimal_digits}".") +exponent "_"?[eE]"_"?[+-]?{decimal_digits} +floating_suffix "_"?[flFL] +floating_constant (({fractional_constant}{exponent}?)|({decimal_digits}{exponent})){floating_suffix}? + +binary_exponent "_"?[pP]"_"?[+-]?{decimal_digits} +hex_fractional_constant ({hex_digits}?"."{hex_digits})|({hex_digits}".") +hex_floating_constant {hex_prefix}(({hex_fractional_constant}{binary_exponent})|({hex_digits}{binary_exponent})){floating_suffix}? + + // character escape sequence, GCC: \e => esc character +simple_escape "\\"[abefnrtv'"?\\] + // ' stop highlighting +octal_escape "\\"{octal}("_"?{octal}){0,2} +hex_escape "\\""x""_"?{hex_digits} +escape_seq {simple_escape}|{octal_escape}|{hex_escape}|{universal_char} + + // display/white-space characters +h_tab [\011] +form_feed [\014] +v_tab [\013] +c_return [\015] +h_white [ ]|{h_tab} + + // operators +op_unary_only "~"|"!" +op_unary_binary "+"|"-"|"*" +op_unary_pre_post "++"|"--" +op_unary {op_unary_only}|{op_unary_binary}|{op_unary_pre_post} + +op_binary_only "/"|"%"|"^"|"&"|"|"|"<"|">"|"="|"=="|"!="|"<<"|">>"|"<="|">="|"+="|"-="|"*="|"/="|"%="|"&="|"|="|"^="|"<<="|">>=" +op_binary_over {op_unary_binary}|{op_binary_only} +op_binary_not_over "?"|"->"|"&&"|"||" +operator {op_unary_pre_post}|{op_binary_over}|{op_binary_not_over} + +%x COMMENT +%x BKQUOTE +%x QUOTE +%x STRING + +%% + /* line directives */ +^{h_white}*"#"{h_white}*[0-9]+{h_white}*["][^"\n]+["][^\n]*"\n" { + /* " stop highlighting */ + char *end_num; + char *begin_string, *end_string; + char *filename; + long lineno, length; + lineno = strtol( yytext + 1, &end_num, 0 ); + begin_string = strchr( end_num, '"' ); + if ( begin_string ) { + end_string = strchr( begin_string + 1, '"' ); + if ( end_string ) { + length = end_string - begin_string - 1; + filename = new char[ length + 1 ]; + memcpy( filename, begin_string + 1, length ); + filename[ length ] = '\0'; + //std::cout << "file " << filename << " line " << lineno << std::endl; + yylineno = lineno; + yyfilename = filename; + } // if + } // if +} + + /* ignore preprocessor directives (for now) */ +^{h_white}*"#"[^\n]*"\n" ; + + /* ignore C style comments */ +"/*" { BEGIN COMMENT; } +.|\n ; +"*/" { BEGIN 0; } + + /* ignore C++ style comments */ +"//"[^\n]*"\n" ; + + /* ignore whitespace */ +{h_white}+ { WHITE_RETURN(' '); } +({v_tab}|{c_return}|{form_feed})+ { WHITE_RETURN(' '); } +({h_white}|{v_tab}|{c_return}|{form_feed})*"\n" { NEWLINE_RETURN(); } + + /* keywords */ +_Alignas { KEYWORD_RETURN(ALIGNAS); } // C11 +_Alignof { KEYWORD_RETURN(ALIGNOF); } // C11 +__alignof { KEYWORD_RETURN(ALIGNOF); } // GCC +__alignof__ { KEYWORD_RETURN(ALIGNOF); } // GCC +asm { KEYWORD_RETURN(ASM); } +__asm { KEYWORD_RETURN(ASM); } // GCC +__asm__ { KEYWORD_RETURN(ASM); } // GCC +_Atomic { KEYWORD_RETURN(ATOMIC); } // C11 +__attribute { KEYWORD_RETURN(ATTRIBUTE); } // GCC +__attribute__ { KEYWORD_RETURN(ATTRIBUTE); } // GCC +auto { KEYWORD_RETURN(AUTO); } +_Bool { KEYWORD_RETURN(BOOL); } // C99 +break { KEYWORD_RETURN(BREAK); } +case { KEYWORD_RETURN(CASE); } +catch { KEYWORD_RETURN(CATCH); } // CFA +char { KEYWORD_RETURN(CHAR); } +choose { KEYWORD_RETURN(CHOOSE); } // CFA +_Complex { KEYWORD_RETURN(COMPLEX); } // C99 +__complex { KEYWORD_RETURN(COMPLEX); } // GCC +__complex__ { KEYWORD_RETURN(COMPLEX); } // GCC +const { KEYWORD_RETURN(CONST); } +__const { KEYWORD_RETURN(CONST); } // GCC +__const__ { KEYWORD_RETURN(CONST); } // GCC +context { KEYWORD_RETURN(CONTEXT); } // CFA +continue { KEYWORD_RETURN(CONTINUE); } +default { KEYWORD_RETURN(DEFAULT); } +do { KEYWORD_RETURN(DO); } +double { KEYWORD_RETURN(DOUBLE); } +dtype { KEYWORD_RETURN(DTYPE); } // CFA +else { KEYWORD_RETURN(ELSE); } +enum { KEYWORD_RETURN(ENUM); } +__extension__ { KEYWORD_RETURN(EXTENSION); } // GCC +extern { KEYWORD_RETURN(EXTERN); } +fallthru { KEYWORD_RETURN(FALLTHRU); } // CFA +finally { KEYWORD_RETURN(FINALLY); } // CFA +float { KEYWORD_RETURN(FLOAT); } +__float128 { KEYWORD_RETURN(FLOAT); } // GCC +for { KEYWORD_RETURN(FOR); } +forall { KEYWORD_RETURN(FORALL); } // CFA +fortran { KEYWORD_RETURN(FORTRAN); } +ftype { KEYWORD_RETURN(FTYPE); } // CFA +_Generic { KEYWORD_RETURN(GENERIC); } // C11 +goto { KEYWORD_RETURN(GOTO); } +if { KEYWORD_RETURN(IF); } +_Imaginary { KEYWORD_RETURN(IMAGINARY); } // C99 +__imag { KEYWORD_RETURN(IMAGINARY); } // GCC +__imag__ { KEYWORD_RETURN(IMAGINARY); } // GCC +inline { KEYWORD_RETURN(INLINE); } // C99 +__inline { KEYWORD_RETURN(INLINE); } // GCC +__inline__ { KEYWORD_RETURN(INLINE); } // GCC +int { KEYWORD_RETURN(INT); } +__int128 { KEYWORD_RETURN(INT); } // GCC +__label__ { KEYWORD_RETURN(LABEL); } // GCC +long { KEYWORD_RETURN(LONG); } +lvalue { KEYWORD_RETURN(LVALUE); } // CFA +_Noreturn { KEYWORD_RETURN(NORETURN); } // C11 +register { KEYWORD_RETURN(REGISTER); } +restrict { KEYWORD_RETURN(RESTRICT); } // C99 +__restrict { KEYWORD_RETURN(RESTRICT); } // GCC +__restrict__ { KEYWORD_RETURN(RESTRICT); } // GCC +return { KEYWORD_RETURN(RETURN); } +short { KEYWORD_RETURN(SHORT); } +signed { KEYWORD_RETURN(SIGNED); } +__signed { KEYWORD_RETURN(SIGNED); } // GCC +__signed__ { KEYWORD_RETURN(SIGNED); } // GCC +sizeof { KEYWORD_RETURN(SIZEOF); } +static { KEYWORD_RETURN(STATIC); } +_Static_assert { KEYWORD_RETURN(STATICASSERT); } // C11 +struct { KEYWORD_RETURN(STRUCT); } +switch { KEYWORD_RETURN(SWITCH); } +_Thread_local { KEYWORD_RETURN(THREADLOCAL); } // C11 +throw { KEYWORD_RETURN(THROW); } // CFA +try { KEYWORD_RETURN(TRY); } // CFA +type { KEYWORD_RETURN(TYPE); } // CFA +typedef { KEYWORD_RETURN(TYPEDEF); } +typeof { KEYWORD_RETURN(TYPEOF); } // GCC +__typeof { KEYWORD_RETURN(TYPEOF); } // GCC +__typeof__ { KEYWORD_RETURN(TYPEOF); } // GCC +union { KEYWORD_RETURN(UNION); } +unsigned { KEYWORD_RETURN(UNSIGNED); } +void { KEYWORD_RETURN(VOID); } +volatile { KEYWORD_RETURN(VOLATILE); } +__volatile { KEYWORD_RETURN(VOLATILE); } // GCC +__volatile__ { KEYWORD_RETURN(VOLATILE); } // GCC +while { KEYWORD_RETURN(WHILE); } + + /* identifier */ +{identifier} { IDENTIFIER_RETURN(); } +{attr_identifier} { ATTRIBUTE_RETURN(); } +"`" { BEGIN BKQUOTE; } +{identifier} { IDENTIFIER_RETURN(); } +"`" { BEGIN 0; } + + /* numeric constants */ +"0" { NUMERIC_RETURN(ZERO); } // CFA +"1" { NUMERIC_RETURN(ONE); } // CFA +{decimal_constant} { NUMERIC_RETURN(INTEGERconstant); } +{octal_constant} { NUMERIC_RETURN(INTEGERconstant); } +{hex_constant} { NUMERIC_RETURN(INTEGERconstant); } +{floating_constant} { NUMERIC_RETURN(FLOATINGconstant); } +{hex_floating_constant} { NUMERIC_RETURN(FLOATINGconstant); } + + /* character constant, allows empty value */ +"L"?"_"?['] { BEGIN QUOTE; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); } +[^'\\\n]* { *strtext += std::string( yytext ); } +['\n] { BEGIN 0; *strtext += std::string( yytext); RETURN_STR(CHARACTERconstant); } + /* ' stop highlighting */ + + /* string constant */ +"L"?"_"?["] { BEGIN STRING; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); } +[^"\\\n]* { *strtext += std::string( yytext ); } +["\n] { BEGIN 0; *strtext += std::string( yytext); RETURN_STR(STRINGliteral); } + /* " stop highlighting */ + +{escape_seq} { rm_underscore(); *strtext += std::string( yytext ); } +[\\] { *strtext += std::string( yytext ); } // unknown escape character + + /* punctuation */ +"[" { ASCIIOP_RETURN(); } +"]" { ASCIIOP_RETURN(); } +"(" { ASCIIOP_RETURN(); } +")" { ASCIIOP_RETURN(); } +"{" { ASCIIOP_RETURN(); } +"}" { ASCIIOP_RETURN(); } +"," { ASCIIOP_RETURN(); } // also operator +":" { ASCIIOP_RETURN(); } +";" { ASCIIOP_RETURN(); } +"." { ASCIIOP_RETURN(); } // also operator +"..." { NAMEDOP_RETURN(ELLIPSIS); } + + /* alternative C99 brackets, "<:" & "<:<:" handled by preprocessor */ +"<:" { RETURN_VAL('['); } +":>" { RETURN_VAL(']'); } +"<%" { RETURN_VAL('{'); } +"%>" { RETURN_VAL('}'); } + + /* operators */ +"!" { ASCIIOP_RETURN(); } +"+" { ASCIIOP_RETURN(); } +"-" { ASCIIOP_RETURN(); } +"*" { ASCIIOP_RETURN(); } +"/" { ASCIIOP_RETURN(); } +"%" { ASCIIOP_RETURN(); } +"^" { ASCIIOP_RETURN(); } +"~" { ASCIIOP_RETURN(); } +"&" { ASCIIOP_RETURN(); } +"|" { ASCIIOP_RETURN(); } +"<" { ASCIIOP_RETURN(); } +">" { ASCIIOP_RETURN(); } +"=" { ASCIIOP_RETURN(); } +"?" { ASCIIOP_RETURN(); } + +"++" { NAMEDOP_RETURN(ICR); } +"--" { NAMEDOP_RETURN(DECR); } +"==" { NAMEDOP_RETURN(EQ); } +"!=" { NAMEDOP_RETURN(NE); } +"<<" { NAMEDOP_RETURN(LS); } +">>" { NAMEDOP_RETURN(RS); } +"<=" { NAMEDOP_RETURN(LE); } +">=" { NAMEDOP_RETURN(GE); } +"&&" { NAMEDOP_RETURN(ANDAND); } +"||" { NAMEDOP_RETURN(OROR); } +"->" { NAMEDOP_RETURN(ARROW); } +"+=" { NAMEDOP_RETURN(PLUSassign); } +"-=" { NAMEDOP_RETURN(MINUSassign); } +"*=" { NAMEDOP_RETURN(MULTassign); } +"/=" { NAMEDOP_RETURN(DIVassign); } +"%=" { NAMEDOP_RETURN(MODassign); } +"&=" { NAMEDOP_RETURN(ANDassign); } +"|=" { NAMEDOP_RETURN(ORassign); } +"^=" { NAMEDOP_RETURN(ERassign); } +"<<=" { NAMEDOP_RETURN(LSassign); } +">>=" { NAMEDOP_RETURN(RSassign); } + + /* CFA, operator identifier */ +{op_unary}"?" { IDENTIFIER_RETURN(); } // unary +"?"({op_unary_pre_post}|"()"|"[?]") { IDENTIFIER_RETURN(); } +"?"{op_binary_over}"?" { IDENTIFIER_RETURN(); } // binary + /* + This rule handles ambiguous cases with operator identifiers, e.g., "int *?*?()", where the string "*?*?" + can be lexed as "*"/"?*?" or "*?"/"*?". Since it is common practise to put a unary operator juxtaposed + to an identifier, e.g., "*i", users will be annoyed if they cannot do this with respect to operator + identifiers. Even with this special hack, there are 5 general cases that cannot be handled. The first + case is for the function-call identifier "?()": + + int * ?()(); // declaration: space required after '*' + * ?()(); // expression: space required after '*' + + Without the space, the string "*?()" is ambiguous without N character look ahead; it requires scanning + ahead to determine if there is a '(', which is the start of an argument/parameter list. + + The 4 remaining cases occur in expressions: + + i++?i:0; // space required before '?' + i--?i:0; // space required before '?' + i?++i:0; // space required after '?' + i?--i:0; // space required after '?' + + In the first two cases, the string "i++?" is ambiguous, where this string can be lexed as "i"/"++?" or + "i++"/"?"; it requires scanning ahead to determine if there is a '(', which is the start of an argument + list. In the second two cases, the string "?++x" is ambiguous, where this string can be lexed as + "?++"/"x" or "?"/"++x"; it requires scanning ahead to determine if there is a '(', which is the start of + an argument list. + */ +{op_unary}"?"(({op_unary_pre_post}|"[?]")|({op_binary_over}"?")) { + // 1 or 2 character unary operator ? + int i = yytext[1] == '?' ? 1 : 2; + yyless( i ); // put back characters up to first '?' + if ( i > 1 ) { + NAMEDOP_RETURN( yytext[0] == '+' ? ICR : DECR ); + } else { + ASCIIOP_RETURN(); + } // if +} + + /* unknown characters */ +. { printf("unknown character(s):\"%s\" on line %d\n", yytext, yylineno); } + +%% + +// Local Variables: // +// fill-column: 110 // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/Parser/module.mk =================================================================== --- src/Parser/module.mk (revision 00cc023285120a85a7e80e417220f36483ebd413) +++ src/Parser/module.mk (revision 56c393547addff0a409b2886d25499bdf0079ca7) @@ -8,20 +8,19 @@ ## module.mk -- ## -## Author : Richard C. Bilson +## Author : Peter A. Buhr ## Created On : Sat May 16 15:29:09 2015 ## Last Modified By : Peter A. Buhr -## Last Modified On : Sat May 30 12:05:42 2015 -## Update Count : 16 +## Last Modified On : Sun May 31 23:52:20 2015 +## Update Count : 76 ############################################################################### -BUILT_SOURCES = Parser/cfa.tab.cc Parser/lex.yy.cc Parser/cfa.tab.h +BUILT_SOURCES = Parser/parser.h -YACC=bison -YFLAGS=-d --debug -v -LEX=flex -#LFLAGS= +AM_YFLAGS = -d -t -v -SRC += Parser/cfa.tab.cc \ - Parser/lex.yy.cc \ +MAINTAINERCLEANFILES = Parser/parser.output + +SRC += Parser/parser.yy \ + Parser/lex.ll \ Parser/TypedefTable.cc \ Parser/ParseNode.cc \ @@ -36,16 +35,2 @@ LIBS += -lfl - -Parser/Parser.cc: Parser/cfa.tab.h - -Parser/cfa.tab.cc: Parser/cfa.y - ${YACC} ${YFLAGS} $< --file-prefix=Parser/cfa - -mv Parser/cfa.tab.c Parser/cfa.tab.cc - -Parser/cfa.tab.h: Parser/cfa.tab.cc - -Parser/lex.yy.cc: Parser/lex.l Parser/lex.h Parser/cfa.tab.h Parser/TypedefTable.h - ${LEX} ${LFLAGS} -o$@ $< - -#Parser/lex.yy.o: Parser/lex.yy.cc Parser/ParseNode.h -# ${CXX} ${CXXFLAGS} -Wno-unused -c -o $@ $< Index: src/Parser/parser.cc =================================================================== --- src/Parser/parser.cc (revision 56c393547addff0a409b2886d25499bdf0079ca7) +++ src/Parser/parser.cc (revision 56c393547addff0a409b2886d25499bdf0079ca7) @@ -0,0 +1,9284 @@ +/* A Bison parser, made by GNU Bison 2.5. */ + +/* Bison implementation for Yacc-like parsers in C + + Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +/* As a special exception, you may create a larger work that contains + part or all of the Bison parser skeleton and distribute that work + under terms of your choice, so long as that work isn't itself a + parser generator using the skeleton or a modified version thereof + as a parser skeleton. Alternatively, if you modify or redistribute + the parser skeleton itself, you may (at your option) remove this + special exception, which will cause the skeleton and the resulting + Bison output files to be licensed under the GNU General Public + License without this special exception. + + This special exception was added by the Free Software Foundation in + version 2.2 of Bison. */ + +/* C LALR(1) parser skeleton written by Richard Stallman, by + simplifying the original so-called "semantic" parser. */ + +/* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local + variables, as they might otherwise be expanded by user macros. + There are some unavoidable exceptions within include files to + define necessary library symbols; they are noted "INFRINGES ON + USER NAME SPACE" below. */ + +/* Identify Bison output. */ +#define YYBISON 1 + +/* Bison version. */ +#define YYBISON_VERSION "2.5" + +/* Skeleton name. */ +#define YYSKELETON_NAME "yacc.c" + +/* Pure parsers. */ +#define YYPURE 0 + +/* Push parsers. */ +#define YYPUSH 0 + +/* Pull parsers. */ +#define YYPULL 1 + +/* Using locations. */ +#define YYLSP_NEEDED 0 + + + +/* Copy the first part of user declarations. */ + +/* Line 268 of yacc.c */ +#line 45 "parser.yy" + +#define YYDEBUG_LEXER_TEXT (yylval) // lexer loads this up each time +#define YYDEBUG 1 // get the pretty debugging code to compile + +#undef __GNUC_MINOR__ + +#include +#include +#include "TypedefTable.h" +#include "lex.h" +#include "ParseNode.h" +#include "LinkageSpec.h" + +DeclarationNode *theTree = 0; // the resulting parse tree +LinkageSpec::Type linkage = LinkageSpec::Cforall; +std::stack< LinkageSpec::Type > linkageStack; +TypedefTable typedefTable; + + +/* Line 268 of yacc.c */ +#line 91 "Parser/parser.cc" + +/* Enabling traces. */ +#ifndef YYDEBUG +# define YYDEBUG 1 +#endif + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE 0 +#endif + +/* Enabling the token table. */ +#ifndef YYTOKEN_TABLE +# define YYTOKEN_TABLE 0 +#endif + + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + TYPEDEF = 258, + AUTO = 259, + EXTERN = 260, + REGISTER = 261, + STATIC = 262, + INLINE = 263, + FORTRAN = 264, + CONST = 265, + VOLATILE = 266, + RESTRICT = 267, + FORALL = 268, + LVALUE = 269, + VOID = 270, + CHAR = 271, + SHORT = 272, + INT = 273, + LONG = 274, + FLOAT = 275, + DOUBLE = 276, + SIGNED = 277, + UNSIGNED = 278, + BOOL = 279, + COMPLEX = 280, + IMAGINARY = 281, + TYPEOF = 282, + LABEL = 283, + ENUM = 284, + STRUCT = 285, + UNION = 286, + TYPE = 287, + FTYPE = 288, + DTYPE = 289, + CONTEXT = 290, + SIZEOF = 291, + ATTRIBUTE = 292, + EXTENSION = 293, + IF = 294, + ELSE = 295, + SWITCH = 296, + CASE = 297, + DEFAULT = 298, + DO = 299, + WHILE = 300, + FOR = 301, + BREAK = 302, + CONTINUE = 303, + GOTO = 304, + RETURN = 305, + CHOOSE = 306, + FALLTHRU = 307, + TRY = 308, + CATCH = 309, + FINALLY = 310, + THROW = 311, + ASM = 312, + ALIGNAS = 313, + ALIGNOF = 314, + ATOMIC = 315, + GENERIC = 316, + NORETURN = 317, + STATICASSERT = 318, + THREADLOCAL = 319, + IDENTIFIER = 320, + QUOTED_IDENTIFIER = 321, + TYPEDEFname = 322, + TYPEGENname = 323, + ATTR_IDENTIFIER = 324, + ATTR_TYPEDEFname = 325, + ATTR_TYPEGENname = 326, + INTEGERconstant = 327, + FLOATINGconstant = 328, + CHARACTERconstant = 329, + STRINGliteral = 330, + ZERO = 331, + ONE = 332, + ARROW = 333, + ICR = 334, + DECR = 335, + LS = 336, + RS = 337, + LE = 338, + GE = 339, + EQ = 340, + NE = 341, + ANDAND = 342, + OROR = 343, + ELLIPSIS = 344, + MULTassign = 345, + DIVassign = 346, + MODassign = 347, + PLUSassign = 348, + MINUSassign = 349, + LSassign = 350, + RSassign = 351, + ANDassign = 352, + ERassign = 353, + ORassign = 354, + THEN = 355 + }; +#endif +/* Tokens. */ +#define TYPEDEF 258 +#define AUTO 259 +#define EXTERN 260 +#define REGISTER 261 +#define STATIC 262 +#define INLINE 263 +#define FORTRAN 264 +#define CONST 265 +#define VOLATILE 266 +#define RESTRICT 267 +#define FORALL 268 +#define LVALUE 269 +#define VOID 270 +#define CHAR 271 +#define SHORT 272 +#define INT 273 +#define LONG 274 +#define FLOAT 275 +#define DOUBLE 276 +#define SIGNED 277 +#define UNSIGNED 278 +#define BOOL 279 +#define COMPLEX 280 +#define IMAGINARY 281 +#define TYPEOF 282 +#define LABEL 283 +#define ENUM 284 +#define STRUCT 285 +#define UNION 286 +#define TYPE 287 +#define FTYPE 288 +#define DTYPE 289 +#define CONTEXT 290 +#define SIZEOF 291 +#define ATTRIBUTE 292 +#define EXTENSION 293 +#define IF 294 +#define ELSE 295 +#define SWITCH 296 +#define CASE 297 +#define DEFAULT 298 +#define DO 299 +#define WHILE 300 +#define FOR 301 +#define BREAK 302 +#define CONTINUE 303 +#define GOTO 304 +#define RETURN 305 +#define CHOOSE 306 +#define FALLTHRU 307 +#define TRY 308 +#define CATCH 309 +#define FINALLY 310 +#define THROW 311 +#define ASM 312 +#define ALIGNAS 313 +#define ALIGNOF 314 +#define ATOMIC 315 +#define GENERIC 316 +#define NORETURN 317 +#define STATICASSERT 318 +#define THREADLOCAL 319 +#define IDENTIFIER 320 +#define QUOTED_IDENTIFIER 321 +#define TYPEDEFname 322 +#define TYPEGENname 323 +#define ATTR_IDENTIFIER 324 +#define ATTR_TYPEDEFname 325 +#define ATTR_TYPEGENname 326 +#define INTEGERconstant 327 +#define FLOATINGconstant 328 +#define CHARACTERconstant 329 +#define STRINGliteral 330 +#define ZERO 331 +#define ONE 332 +#define ARROW 333 +#define ICR 334 +#define DECR 335 +#define LS 336 +#define RS 337 +#define LE 338 +#define GE 339 +#define EQ 340 +#define NE 341 +#define ANDAND 342 +#define OROR 343 +#define ELLIPSIS 344 +#define MULTassign 345 +#define DIVassign 346 +#define MODassign 347 +#define PLUSassign 348 +#define MINUSassign 349 +#define LSassign 350 +#define RSassign 351 +#define ANDassign 352 +#define ERassign 353 +#define ORassign 354 +#define THEN 355 + + + + +#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED +typedef union YYSTYPE +{ + +/* Line 293 of yacc.c */ +#line 107 "parser.yy" + + Token tok; + ParseNode *pn; + ExpressionNode *en; + DeclarationNode *decl; + DeclarationNode::TyCon aggKey; + DeclarationNode::TypeClass tclass; + StatementNode *sn; + ConstantNode *constant; + InitializerNode *in; + + + +/* Line 293 of yacc.c */ +#line 341 "Parser/parser.cc" +} YYSTYPE; +# define YYSTYPE_IS_TRIVIAL 1 +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 +#endif + + +/* Copy the second part of user declarations. */ + + +/* Line 343 of yacc.c */ +#line 353 "Parser/parser.cc" + +#ifdef short +# undef short +#endif + +#ifdef YYTYPE_UINT8 +typedef YYTYPE_UINT8 yytype_uint8; +#else +typedef unsigned char yytype_uint8; +#endif + +#ifdef YYTYPE_INT8 +typedef YYTYPE_INT8 yytype_int8; +#elif (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +typedef signed char yytype_int8; +#else +typedef short int yytype_int8; +#endif + +#ifdef YYTYPE_UINT16 +typedef YYTYPE_UINT16 yytype_uint16; +#else +typedef unsigned short int yytype_uint16; +#endif + +#ifdef YYTYPE_INT16 +typedef YYTYPE_INT16 yytype_int16; +#else +typedef short int yytype_int16; +#endif + +#ifndef YYSIZE_T +# ifdef __SIZE_TYPE__ +# define YYSIZE_T __SIZE_TYPE__ +# elif defined size_t +# define YYSIZE_T size_t +# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# else +# define YYSIZE_T unsigned int +# endif +#endif + +#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) + +#ifndef YY_ +# if defined YYENABLE_NLS && YYENABLE_NLS +# if ENABLE_NLS +# include /* INFRINGES ON USER NAME SPACE */ +# define YY_(msgid) dgettext ("bison-runtime", msgid) +# endif +# endif +# ifndef YY_ +# define YY_(msgid) msgid +# endif +#endif + +/* Suppress unused-variable warnings by "using" E. */ +#if ! defined lint || defined __GNUC__ +# define YYUSE(e) ((void) (e)) +#else +# define YYUSE(e) /* empty */ +#endif + +/* Identity function, used to suppress warnings about constant conditions. */ +#ifndef lint +# define YYID(n) (n) +#else +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static int +YYID (int yyi) +#else +static int +YYID (yyi) + int yyi; +#endif +{ + return yyi; +} +#endif + +#if ! defined yyoverflow || YYERROR_VERBOSE + +/* The parser invokes alloca or malloc; define the necessary symbols. */ + +# ifdef YYSTACK_USE_ALLOCA +# if YYSTACK_USE_ALLOCA +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# elif defined __BUILTIN_VA_ARG_INCR +# include /* INFRINGES ON USER NAME SPACE */ +# elif defined _AIX +# define YYSTACK_ALLOC __alloca +# elif defined _MSC_VER +# include /* INFRINGES ON USER NAME SPACE */ +# define alloca _alloca +# else +# define YYSTACK_ALLOC alloca +# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +# include /* INFRINGES ON USER NAME SPACE */ +# ifndef EXIT_SUCCESS +# define EXIT_SUCCESS 0 +# endif +# endif +# endif +# endif +# endif + +# ifdef YYSTACK_ALLOC + /* Pacify GCC's `empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) +# ifndef YYSTACK_ALLOC_MAXIMUM + /* The OS might guarantee only one guard page at the bottom of the stack, + and a page size can be as small as 4096 bytes. So we cannot safely + invoke alloca (N) if N exceeds 4096. Use a slightly smaller number + to allow for a few compiler-allocated temporary stack slots. */ +# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ +# endif +# else +# define YYSTACK_ALLOC YYMALLOC +# define YYSTACK_FREE YYFREE +# ifndef YYSTACK_ALLOC_MAXIMUM +# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM +# endif +# if (defined __cplusplus && ! defined EXIT_SUCCESS \ + && ! ((defined YYMALLOC || defined malloc) \ + && (defined YYFREE || defined free))) +# include /* INFRINGES ON USER NAME SPACE */ +# ifndef EXIT_SUCCESS +# define EXIT_SUCCESS 0 +# endif +# endif +# ifndef YYMALLOC +# define YYMALLOC malloc +# if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# ifndef YYFREE +# define YYFREE free +# if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +void free (void *); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# endif +#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ + + +#if (! defined yyoverflow \ + && (! defined __cplusplus \ + || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + yytype_int16 yyss_alloc; + YYSTYPE yyvs_alloc; +}; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ + + YYSTACK_GAP_MAXIMUM) + +# define YYCOPY_NEEDED 1 + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ + do \ + { \ + YYSIZE_T yynewbytes; \ + YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ + Stack = &yyptr->Stack_alloc; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / sizeof (*yyptr); \ + } \ + while (YYID (0)) + +#endif + +#if defined YYCOPY_NEEDED && YYCOPY_NEEDED +/* Copy COUNT objects from FROM to TO. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if defined __GNUC__ && 1 < __GNUC__ +# define YYCOPY(To, From, Count) \ + __builtin_memcpy (To, From, (Count) * sizeof (*(From))) +# else +# define YYCOPY(To, From, Count) \ + do \ + { \ + YYSIZE_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (To)[yyi] = (From)[yyi]; \ + } \ + while (YYID (0)) +# endif +# endif +#endif /* !YYCOPY_NEEDED */ + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL 238 +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST 12086 + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS 125 +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS 235 +/* YYNRULES -- Number of rules. */ +#define YYNRULES 733 +/* YYNRULES -- Number of states. */ +#define YYNSTATES 1550 + +/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ +#define YYUNDEFTOK 2 +#define YYMAXUTOK 355 + +#define YYTRANSLATE(YYX) \ + ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + +/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +static const yytype_uint8 yytranslate[] = +{ + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 110, 2, 2, 2, 117, 112, 2, + 101, 102, 111, 113, 108, 114, 105, 116, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 109, 124, + 118, 123, 119, 122, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 103, 2, 104, 120, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 106, 121, 107, 115, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 1, 2, 3, 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 +}; + +#if YYDEBUG +/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ +static const yytype_uint16 yyprhs[] = +{ + 0, 0, 3, 4, 5, 7, 9, 11, 13, 15, + 17, 19, 21, 23, 25, 27, 29, 32, 34, 36, + 38, 40, 44, 48, 50, 57, 62, 66, 74, 78, + 86, 89, 92, 100, 102, 106, 107, 109, 113, 121, + 131, 133, 137, 139, 143, 151, 155, 163, 165, 168, + 171, 174, 177, 180, 183, 186, 191, 193, 198, 203, + 206, 211, 214, 216, 218, 220, 222, 224, 229, 234, + 236, 240, 244, 248, 250, 254, 258, 260, 264, 268, + 270, 274, 278, 282, 286, 288, 292, 296, 298, 302, + 304, 308, 310, 314, 316, 320, 322, 326, 328, 334, + 339, 345, 347, 349, 353, 357, 360, 361, 363, 368, + 374, 381, 389, 391, 395, 397, 399, 401, 403, 405, + 407, 409, 411, 413, 415, 417, 421, 422, 424, 426, + 428, 430, 432, 434, 436, 438, 440, 445, 448, 456, + 458, 462, 464, 467, 469, 472, 474, 477, 480, 486, + 494, 500, 510, 516, 526, 528, 532, 534, 536, 540, + 544, 547, 549, 552, 555, 556, 558, 561, 565, 566, + 568, 571, 575, 579, 584, 585, 587, 589, 592, 598, + 606, 613, 620, 625, 629, 634, 637, 641, 644, 648, + 652, 656, 659, 663, 667, 672, 674, 680, 687, 697, + 708, 711, 713, 716, 719, 722, 724, 731, 740, 751, + 764, 765, 767, 769, 773, 778, 780, 784, 786, 788, + 790, 794, 796, 798, 800, 804, 805, 807, 811, 816, + 818, 822, 824, 826, 830, 834, 838, 842, 846, 849, + 853, 860, 864, 868, 873, 875, 878, 881, 885, 891, + 902, 913, 921, 929, 935, 945, 948, 951, 957, 961, + 967, 972, 976, 981, 986, 994, 998, 1002, 1006, 1010, + 1015, 1022, 1024, 1026, 1028, 1030, 1032, 1034, 1036, 1038, + 1039, 1041, 1043, 1046, 1048, 1050, 1052, 1054, 1056, 1058, + 1060, 1061, 1067, 1069, 1072, 1076, 1078, 1081, 1083, 1085, + 1087, 1089, 1091, 1093, 1095, 1097, 1099, 1101, 1103, 1105, + 1107, 1109, 1111, 1113, 1115, 1117, 1119, 1121, 1124, 1127, + 1131, 1135, 1137, 1141, 1143, 1146, 1149, 1152, 1157, 1162, + 1167, 1172, 1174, 1177, 1180, 1184, 1186, 1189, 1192, 1194, + 1197, 1200, 1204, 1206, 1209, 1212, 1214, 1216, 1221, 1224, + 1230, 1240, 1248, 1259, 1272, 1280, 1294, 1297, 1300, 1302, + 1305, 1308, 1312, 1315, 1319, 1321, 1324, 1328, 1331, 1334, + 1339, 1340, 1342, 1345, 1348, 1350, 1351, 1353, 1356, 1359, + 1365, 1372, 1375, 1378, 1383, 1384, 1387, 1388, 1390, 1392, + 1394, 1400, 1406, 1412, 1414, 1420, 1426, 1436, 1438, 1444, + 1445, 1447, 1449, 1455, 1457, 1459, 1465, 1471, 1473, 1477, + 1481, 1486, 1488, 1490, 1492, 1494, 1497, 1499, 1503, 1507, + 1509, 1512, 1514, 1518, 1520, 1522, 1524, 1526, 1528, 1530, + 1532, 1534, 1536, 1538, 1540, 1543, 1545, 1547, 1549, 1552, + 1553, 1556, 1558, 1563, 1565, 1568, 1572, 1577, 1580, 1583, + 1585, 1588, 1591, 1597, 1603, 1611, 1618, 1620, 1623, 1626, + 1630, 1635, 1641, 1644, 1647, 1652, 1653, 1658, 1661, 1663, + 1665, 1667, 1668, 1671, 1677, 1683, 1697, 1699, 1701, 1705, + 1709, 1712, 1716, 1720, 1723, 1728, 1730, 1737, 1747, 1748, + 1760, 1762, 1766, 1770, 1774, 1776, 1778, 1784, 1787, 1793, + 1794, 1796, 1798, 1802, 1803, 1805, 1807, 1809, 1811, 1812, + 1819, 1822, 1824, 1827, 1832, 1835, 1839, 1843, 1847, 1852, + 1858, 1864, 1870, 1877, 1879, 1881, 1883, 1887, 1888, 1894, + 1895, 1897, 1899, 1902, 1909, 1911, 1915, 1916, 1918, 1923, + 1925, 1927, 1929, 1931, 1934, 1936, 1939, 1942, 1944, 1948, + 1951, 1955, 1959, 1962, 1967, 1972, 1976, 1985, 1989, 1992, + 1994, 1997, 2004, 2013, 2017, 2020, 2024, 2028, 2033, 2038, + 2042, 2044, 2046, 2048, 2053, 2060, 2064, 2067, 2071, 2075, + 2080, 2085, 2089, 2092, 2094, 2097, 2100, 2102, 2106, 2109, + 2113, 2117, 2120, 2125, 2130, 2134, 2141, 2150, 2154, 2157, + 2159, 2162, 2165, 2168, 2172, 2176, 2179, 2184, 2189, 2193, + 2200, 2209, 2213, 2216, 2218, 2221, 2224, 2226, 2229, 2233, + 2237, 2240, 2245, 2252, 2261, 2263, 2266, 2269, 2271, 2274, + 2277, 2281, 2285, 2287, 2292, 2297, 2301, 2307, 2316, 2320, + 2325, 2331, 2333, 2339, 2345, 2352, 2359, 2361, 2364, 2367, + 2369, 2372, 2375, 2379, 2383, 2385, 2390, 2395, 2399, 2405, + 2414, 2418, 2420, 2423, 2425, 2430, 2437, 2443, 2450, 2458, + 2466, 2468, 2471, 2474, 2476, 2479, 2482, 2486, 2490, 2492, + 2497, 2502, 2506, 2515, 2519, 2521, 2523, 2526, 2528, 2530, + 2533, 2537, 2540, 2544, 2547, 2551, 2557, 2560, 2567, 2571, + 2574, 2580, 2583, 2590, 2594, 2597, 2604, 2611, 2618, 2626, + 2628, 2631, 2633, 2635, 2637, 2640, 2644, 2647, 2651, 2654, + 2658, 2664, 2671, 2674, 2680, 2687, 2690, 2696, 2704, 2711, + 2718, 2719, 2721, 2722 +}; + +/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +static const yytype_int16 yyrhs[] = +{ + 288, 0, -1, -1, -1, 72, -1, 73, -1, 74, + -1, 65, -1, 69, -1, 132, -1, 65, -1, 69, + -1, 65, -1, 76, -1, 77, -1, 75, -1, 133, + 75, -1, 65, -1, 132, -1, 128, -1, 133, -1, + 101, 160, 102, -1, 101, 164, 102, -1, 134, -1, + 135, 103, 126, 155, 127, 104, -1, 135, 101, 136, + 102, -1, 135, 105, 131, -1, 135, 105, 103, 126, + 138, 127, 104, -1, 135, 78, 131, -1, 135, 78, + 103, 126, 138, 127, 104, -1, 135, 79, -1, 135, + 80, -1, 101, 262, 102, 106, 266, 358, 107, -1, + 137, -1, 136, 108, 137, -1, -1, 155, -1, 131, + 109, 155, -1, 103, 126, 155, 127, 104, 109, 155, + -1, 103, 126, 155, 108, 158, 127, 104, 109, 155, + -1, 139, -1, 138, 108, 139, -1, 131, -1, 131, + 105, 139, -1, 131, 105, 103, 126, 138, 127, 104, + -1, 131, 78, 139, -1, 131, 78, 103, 126, 138, + 127, 104, -1, 135, -1, 79, 140, -1, 80, 140, + -1, 38, 142, -1, 141, 142, -1, 110, 142, -1, + 111, 142, -1, 36, 140, -1, 36, 101, 262, 102, + -1, 69, -1, 69, 101, 263, 102, -1, 69, 101, + 137, 102, -1, 59, 140, -1, 59, 101, 262, 102, + -1, 87, 131, -1, 112, -1, 113, -1, 114, -1, + 115, -1, 140, -1, 101, 262, 102, 142, -1, 101, + 262, 102, 157, -1, 142, -1, 143, 111, 142, -1, + 143, 116, 142, -1, 143, 117, 142, -1, 143, -1, + 144, 113, 143, -1, 144, 114, 143, -1, 144, -1, + 145, 81, 144, -1, 145, 82, 144, -1, 145, -1, + 146, 118, 145, -1, 146, 119, 145, -1, 146, 83, + 145, -1, 146, 84, 145, -1, 146, -1, 147, 85, + 146, -1, 147, 86, 146, -1, 147, -1, 148, 112, + 147, -1, 148, -1, 149, 120, 148, -1, 149, -1, + 150, 121, 149, -1, 150, -1, 151, 87, 150, -1, + 151, -1, 152, 88, 151, -1, 152, -1, 152, 122, + 160, 109, 153, -1, 152, 122, 109, 153, -1, 152, + 122, 160, 109, 157, -1, 153, -1, 153, -1, 140, + 123, 155, -1, 140, 159, 155, -1, 157, 359, -1, + -1, 155, -1, 103, 126, 127, 104, -1, 103, 126, + 155, 127, 104, -1, 103, 126, 108, 158, 127, 104, + -1, 103, 126, 155, 108, 158, 127, 104, -1, 156, + -1, 158, 108, 156, -1, 90, -1, 91, -1, 92, + -1, 93, -1, 94, -1, 95, -1, 96, -1, 97, + -1, 98, -1, 99, -1, 155, -1, 160, 108, 155, + -1, -1, 160, -1, 163, -1, 164, -1, 168, -1, + 169, -1, 181, -1, 183, -1, 184, -1, 189, -1, + 131, 109, 298, 162, -1, 106, 107, -1, 106, 126, + 126, 198, 165, 127, 107, -1, 166, -1, 165, 126, + 166, -1, 201, -1, 38, 201, -1, 294, -1, 162, + 127, -1, 162, -1, 167, 162, -1, 161, 124, -1, + 39, 101, 160, 102, 162, -1, 39, 101, 160, 102, + 162, 40, 162, -1, 41, 101, 160, 102, 174, -1, + 41, 101, 160, 102, 106, 126, 194, 175, 107, -1, + 51, 101, 160, 102, 174, -1, 51, 101, 160, 102, + 106, 126, 194, 177, 107, -1, 154, -1, 154, 89, + 154, -1, 296, -1, 170, -1, 171, 108, 170, -1, + 42, 171, 109, -1, 43, 109, -1, 172, -1, 173, + 172, -1, 173, 162, -1, -1, 176, -1, 173, 167, + -1, 176, 173, 167, -1, -1, 178, -1, 173, 180, + -1, 173, 167, 179, -1, 178, 173, 180, -1, 178, + 173, 167, 179, -1, -1, 180, -1, 52, -1, 52, + 124, -1, 45, 101, 160, 102, 162, -1, 44, 162, + 45, 101, 160, 102, 124, -1, 46, 101, 126, 182, + 102, 162, -1, 161, 127, 124, 161, 124, 161, -1, + 201, 161, 124, 161, -1, 49, 131, 124, -1, 49, + 111, 160, 124, -1, 48, 124, -1, 48, 131, 124, + -1, 47, 124, -1, 47, 131, 124, -1, 50, 161, + 124, -1, 56, 155, 124, -1, 56, 124, -1, 53, + 164, 185, -1, 53, 164, 187, -1, 53, 164, 185, + 187, -1, 186, -1, 54, 101, 89, 102, 164, -1, + 186, 54, 101, 89, 102, 164, -1, 54, 101, 126, + 126, 188, 127, 102, 164, 127, -1, 186, 54, 101, + 126, 126, 188, 127, 102, 164, 127, -1, 55, 164, + -1, 214, -1, 214, 295, -1, 214, 343, -1, 352, + 131, -1, 352, -1, 57, 215, 101, 154, 102, 124, + -1, 57, 215, 101, 154, 109, 190, 102, 124, -1, + 57, 215, 101, 154, 109, 190, 109, 190, 102, 124, + -1, 57, 215, 101, 154, 109, 190, 109, 190, 109, + 193, 102, 124, -1, -1, 191, -1, 192, -1, 191, + 108, 192, -1, 75, 101, 154, 102, -1, 75, -1, + 193, 108, 75, -1, 127, -1, 195, -1, 201, -1, + 195, 126, 201, -1, 127, -1, 197, -1, 211, -1, + 197, 126, 211, -1, -1, 199, -1, 28, 200, 124, + -1, 199, 28, 200, 124, -1, 261, -1, 200, 108, + 261, -1, 202, -1, 211, -1, 203, 127, 124, -1, + 208, 127, 124, -1, 205, 127, 124, -1, 279, 127, + 124, -1, 282, 127, 124, -1, 204, 264, -1, 220, + 204, 264, -1, 203, 127, 108, 126, 259, 264, -1, + 353, 259, 297, -1, 356, 259, 297, -1, 216, 356, + 259, 297, -1, 206, -1, 216, 206, -1, 220, 206, + -1, 220, 216, 206, -1, 205, 127, 108, 126, 259, + -1, 103, 126, 127, 104, 129, 101, 126, 247, 127, + 102, -1, 103, 126, 127, 104, 67, 101, 126, 247, + 127, 102, -1, 356, 259, 101, 126, 247, 127, 102, + -1, 207, 259, 101, 126, 247, 127, 102, -1, 103, + 126, 249, 127, 104, -1, 103, 126, 249, 127, 108, + 126, 250, 127, 104, -1, 3, 204, -1, 3, 206, + -1, 208, 127, 108, 126, 131, -1, 3, 214, 295, + -1, 209, 127, 108, 126, 295, -1, 216, 3, 214, + 295, -1, 214, 3, 295, -1, 214, 3, 216, 295, + -1, 3, 131, 123, 155, -1, 210, 127, 108, 126, + 131, 123, 155, -1, 212, 127, 124, -1, 209, 127, + 124, -1, 210, 127, 124, -1, 229, 127, 124, -1, + 213, 295, 297, 264, -1, 212, 108, 298, 295, 297, + 264, -1, 225, -1, 229, -1, 231, -1, 270, -1, + 226, -1, 230, -1, 232, -1, 271, -1, -1, 216, + -1, 217, -1, 216, 217, -1, 218, -1, 300, -1, + 10, -1, 12, -1, 11, -1, 14, -1, 60, -1, + -1, 13, 101, 219, 272, 102, -1, 221, -1, 216, + 221, -1, 220, 216, 221, -1, 222, -1, 221, 222, + -1, 223, -1, 5, -1, 7, -1, 4, -1, 6, + -1, 8, -1, 9, -1, 16, -1, 21, -1, 20, + -1, 18, -1, 19, -1, 17, -1, 22, -1, 23, + -1, 15, -1, 24, -1, 25, -1, 26, -1, 226, + -1, 220, 226, -1, 225, 222, -1, 225, 222, 216, + -1, 225, 222, 226, -1, 227, -1, 215, 228, 215, + -1, 224, -1, 216, 224, -1, 227, 217, -1, 227, + 224, -1, 27, 101, 263, 102, -1, 27, 101, 160, + 102, -1, 71, 101, 263, 102, -1, 71, 101, 160, + 102, -1, 230, -1, 220, 230, -1, 229, 222, -1, + 229, 222, 216, -1, 233, -1, 216, 233, -1, 230, + 217, -1, 232, -1, 220, 232, -1, 231, 222, -1, + 231, 222, 216, -1, 67, -1, 216, 67, -1, 232, + 217, -1, 234, -1, 244, -1, 235, 106, 236, 107, + -1, 235, 261, -1, 235, 261, 106, 236, 107, -1, + 235, 101, 126, 272, 127, 102, 106, 236, 107, -1, + 235, 101, 126, 272, 127, 102, 261, -1, 235, 101, + 126, 272, 127, 102, 261, 106, 236, 107, -1, 235, + 101, 126, 272, 127, 102, 101, 278, 102, 106, 236, + 107, -1, 235, 101, 126, 278, 127, 102, 261, -1, + 235, 101, 126, 272, 127, 102, 101, 278, 102, 261, + 106, 236, 107, -1, 30, 298, -1, 31, 298, -1, + 237, -1, 236, 237, -1, 238, 124, -1, 38, 238, + 124, -1, 239, 124, -1, 38, 239, 124, -1, 352, + -1, 352, 261, -1, 238, 108, 261, -1, 238, 108, + -1, 214, 240, -1, 239, 108, 298, 240, -1, -1, + 242, -1, 304, 241, -1, 317, 241, -1, 343, -1, + -1, 242, -1, 109, 154, -1, 29, 298, -1, 243, + 106, 245, 358, 107, -1, 243, 261, 106, 245, 358, + 107, -1, 243, 261, -1, 261, 246, -1, 245, 108, + 261, 246, -1, -1, 123, 154, -1, -1, 248, -1, + 250, -1, 249, -1, 249, 127, 108, 126, 250, -1, + 250, 127, 108, 126, 89, -1, 249, 127, 108, 126, + 89, -1, 254, -1, 250, 127, 108, 126, 254, -1, + 249, 127, 108, 126, 254, -1, 249, 127, 108, 126, + 250, 127, 108, 126, 254, -1, 255, -1, 250, 127, + 108, 126, 255, -1, -1, 252, -1, 253, -1, 253, + 127, 108, 126, 89, -1, 257, -1, 256, -1, 253, + 127, 108, 126, 257, -1, 253, 127, 108, 126, 256, + -1, 256, -1, 348, 259, 359, -1, 356, 259, 359, + -1, 216, 356, 259, 359, -1, 206, -1, 257, -1, + 348, -1, 356, -1, 216, 356, -1, 357, -1, 213, + 322, 359, -1, 213, 326, 359, -1, 213, -1, 213, + 337, -1, 131, -1, 258, 108, 131, -1, 129, -1, + 67, -1, 68, -1, 130, -1, 67, -1, 68, -1, + 131, -1, 67, -1, 68, -1, 352, -1, 214, -1, + 214, 343, -1, 352, -1, 357, -1, 214, -1, 214, + 331, -1, -1, 123, 265, -1, 155, -1, 106, 266, + 358, 107, -1, 265, -1, 267, 265, -1, 266, 108, + 265, -1, 266, 108, 267, 265, -1, 268, 109, -1, + 261, 109, -1, 269, -1, 268, 269, -1, 105, 261, + -1, 103, 126, 155, 127, 104, -1, 103, 126, 296, + 127, 104, -1, 103, 126, 154, 89, 154, 127, 104, + -1, 105, 103, 126, 138, 127, 104, -1, 271, -1, + 220, 271, -1, 270, 222, -1, 270, 222, 216, -1, + 68, 101, 278, 102, -1, 216, 68, 101, 278, 102, + -1, 271, 217, -1, 273, 359, -1, 272, 108, 273, + 359, -1, -1, 275, 261, 274, 276, -1, 214, 322, + -1, 32, -1, 34, -1, 33, -1, -1, 276, 277, + -1, 121, 261, 101, 278, 102, -1, 121, 106, 126, + 284, 107, -1, 121, 101, 126, 272, 127, 102, 106, + 126, 284, 107, 101, 278, 102, -1, 263, -1, 155, + -1, 278, 108, 263, -1, 278, 108, 155, -1, 32, + 280, -1, 221, 32, 280, -1, 279, 108, 280, -1, + 281, 276, -1, 281, 276, 123, 263, -1, 261, -1, + 260, 101, 126, 272, 127, 102, -1, 35, 261, 101, + 126, 272, 127, 102, 106, 107, -1, -1, 35, 261, + 101, 126, 272, 127, 102, 106, 283, 284, 107, -1, + 285, -1, 284, 126, 285, -1, 286, 127, 124, -1, + 287, 127, 124, -1, 204, -1, 206, -1, 286, 127, + 108, 126, 259, -1, 214, 295, -1, 287, 127, 108, + 126, 295, -1, -1, 289, -1, 291, -1, 289, 126, + 291, -1, -1, 289, -1, 201, -1, 293, -1, 189, + -1, -1, 5, 75, 292, 106, 290, 107, -1, 38, + 291, -1, 294, -1, 309, 164, -1, 313, 126, 196, + 164, -1, 205, 164, -1, 213, 309, 164, -1, 216, + 309, 164, -1, 220, 309, 164, -1, 220, 216, 309, + 164, -1, 213, 313, 126, 196, 164, -1, 216, 313, + 126, 196, 164, -1, 220, 313, 126, 196, 164, -1, + 220, 216, 313, 126, 196, 164, -1, 304, -1, 309, + -1, 317, -1, 154, 115, 154, -1, -1, 57, 101, + 133, 102, 298, -1, -1, 299, -1, 300, -1, 299, + 300, -1, 37, 101, 101, 301, 102, 102, -1, 302, + -1, 301, 108, 302, -1, -1, 303, -1, 303, 101, + 161, 102, -1, 259, -1, 223, -1, 224, -1, 217, + -1, 305, 298, -1, 306, -1, 307, 298, -1, 308, + 298, -1, 129, -1, 101, 305, 102, -1, 111, 304, + -1, 111, 216, 304, -1, 101, 306, 102, -1, 305, + 335, -1, 101, 306, 102, 335, -1, 101, 307, 102, + 336, -1, 101, 307, 102, -1, 101, 306, 102, 101, + 126, 251, 127, 102, -1, 101, 308, 102, -1, 310, + 298, -1, 311, -1, 312, 298, -1, 305, 101, 126, + 251, 127, 102, -1, 101, 311, 102, 101, 126, 251, + 127, 102, -1, 101, 310, 102, -1, 111, 309, -1, + 111, 216, 309, -1, 101, 311, 102, -1, 101, 311, + 102, 335, -1, 101, 312, 102, 336, -1, 101, 312, + 102, -1, 314, -1, 315, -1, 316, -1, 305, 101, + 258, 102, -1, 101, 315, 102, 101, 258, 102, -1, + 101, 314, 102, -1, 111, 313, -1, 111, 216, 313, + -1, 101, 315, 102, -1, 101, 315, 102, 335, -1, + 101, 316, 102, 336, -1, 101, 316, 102, -1, 318, + 298, -1, 319, -1, 320, 298, -1, 321, 298, -1, + 67, -1, 101, 318, 102, -1, 111, 317, -1, 111, + 216, 317, -1, 101, 319, 102, -1, 318, 335, -1, + 101, 319, 102, 335, -1, 101, 320, 102, 336, -1, + 101, 320, 102, -1, 318, 101, 126, 251, 127, 102, + -1, 101, 319, 102, 101, 126, 251, 127, 102, -1, + 101, 321, 102, -1, 305, 298, -1, 323, -1, 324, + 298, -1, 325, 298, -1, 111, 322, -1, 111, 216, + 322, -1, 101, 323, 102, -1, 305, 341, -1, 101, + 323, 102, 335, -1, 101, 324, 102, 336, -1, 101, + 324, 102, -1, 305, 101, 126, 251, 127, 102, -1, + 101, 323, 102, 101, 126, 251, 127, 102, -1, 101, + 325, 102, -1, 327, 298, -1, 328, -1, 329, 298, + -1, 330, 298, -1, 67, -1, 111, 326, -1, 111, + 216, 326, -1, 101, 328, 102, -1, 327, 341, -1, + 101, 328, 102, 341, -1, 327, 101, 126, 251, 127, + 102, -1, 101, 328, 102, 101, 126, 251, 127, 102, + -1, 332, -1, 333, 298, -1, 334, 298, -1, 111, + -1, 111, 216, -1, 111, 331, -1, 111, 216, 331, + -1, 101, 332, 102, -1, 335, -1, 101, 332, 102, + 335, -1, 101, 333, 102, 336, -1, 101, 333, 102, + -1, 101, 126, 251, 127, 102, -1, 101, 332, 102, + 101, 126, 251, 127, 102, -1, 101, 334, 102, -1, + 103, 126, 127, 104, -1, 103, 126, 127, 104, 336, + -1, 336, -1, 103, 126, 155, 127, 104, -1, 103, + 126, 111, 127, 104, -1, 336, 103, 126, 155, 127, + 104, -1, 336, 103, 126, 111, 127, 104, -1, 338, + -1, 339, 298, -1, 340, 298, -1, 111, -1, 111, + 216, -1, 111, 337, -1, 111, 216, 337, -1, 101, + 338, 102, -1, 341, -1, 101, 338, 102, 341, -1, + 101, 339, 102, 336, -1, 101, 339, 102, -1, 101, + 126, 251, 127, 102, -1, 101, 338, 102, 101, 126, + 251, 127, 102, -1, 101, 340, 102, -1, 342, -1, + 342, 336, -1, 336, -1, 103, 126, 127, 104, -1, + 103, 126, 216, 111, 127, 104, -1, 103, 126, 216, + 127, 104, -1, 103, 126, 216, 155, 127, 104, -1, + 103, 126, 7, 215, 155, 127, 104, -1, 103, 126, + 216, 7, 155, 127, 104, -1, 344, -1, 345, 298, + -1, 346, 298, -1, 111, -1, 111, 216, -1, 111, + 343, -1, 111, 216, 343, -1, 101, 344, 102, -1, + 335, -1, 101, 344, 102, 335, -1, 101, 345, 102, + 336, -1, 101, 345, 102, -1, 101, 344, 102, 101, + 126, 251, 127, 102, -1, 101, 346, 102, -1, 348, + -1, 356, -1, 216, 356, -1, 349, -1, 350, -1, + 111, 214, -1, 216, 111, 214, -1, 111, 357, -1, + 216, 111, 357, -1, 111, 347, -1, 216, 111, 347, + -1, 103, 126, 127, 104, 214, -1, 351, 214, -1, + 103, 126, 127, 104, 336, 214, -1, 351, 336, 214, + -1, 336, 214, -1, 103, 126, 127, 104, 349, -1, + 351, 349, -1, 103, 126, 127, 104, 336, 349, -1, + 351, 336, 349, -1, 336, 349, -1, 103, 126, 216, + 111, 127, 104, -1, 103, 126, 216, 155, 127, 104, + -1, 103, 126, 220, 155, 127, 104, -1, 103, 126, + 220, 216, 155, 127, 104, -1, 356, -1, 216, 356, + -1, 353, -1, 354, -1, 355, -1, 111, 214, -1, + 216, 111, 214, -1, 111, 357, -1, 216, 111, 357, + -1, 111, 352, -1, 216, 111, 352, -1, 103, 126, + 127, 104, 214, -1, 103, 126, 127, 104, 336, 214, + -1, 336, 214, -1, 103, 126, 127, 104, 354, -1, + 103, 126, 127, 104, 336, 354, -1, 336, 354, -1, + 103, 126, 250, 127, 104, -1, 103, 126, 127, 104, + 101, 247, 102, -1, 356, 101, 126, 247, 127, 102, + -1, 207, 101, 126, 247, 127, 102, -1, -1, 108, + -1, -1, 123, 155, -1 +}; + +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const yytype_uint16 yyrline[] = +{ + 0, 281, 281, 287, 297, 298, 299, 303, 304, 305, + 309, 310, 314, 318, 319, 323, 324, 330, 332, 334, + 336, 338, 340, 345, 346, 352, 354, 356, 357, 359, + 360, 362, 365, 370, 371, 377, 378, 379, 384, 386, + 391, 392, 396, 398, 400, 402, 404, 409, 410, 412, + 414, 416, 418, 420, 426, 428, 430, 432, 434, 436, + 438, 440, 445, 446, 447, 448, 452, 453, 455, 460, + 461, 463, 465, 470, 471, 473, 478, 479, 481, 486, + 487, 489, 491, 493, 498, 499, 501, 506, 507, 512, + 513, 518, 519, 524, 525, 530, 531, 536, 537, 539, + 541, 546, 551, 552, 554, 556, 562, 563, 569, 571, + 573, 575, 580, 581, 586, 587, 588, 589, 590, 591, + 592, 593, 594, 595, 599, 600, 606, 607, 613, 614, + 615, 616, 617, 618, 619, 620, 624, 629, 631, 641, + 642, 647, 649, 651, 653, 657, 658, 663, 668, 671, + 673, 675, 681, 683, 691, 692, 694, 698, 699, 704, + 705, 710, 711, 715, 720, 721, 725, 727, 733, 734, + 738, 740, 742, 744, 750, 751, 755, 756, 760, 762, + 764, 769, 771, 777, 779, 783, 787, 791, 795, 799, + 801, 803, 808, 810, 812, 821, 824, 826, 831, 833, + 838, 851, 852, 857, 859, 864, 868, 870, 872, 874, + 878, 880, 884, 885, 889, 893, 894, 900, 902, 906, + 907, 912, 914, 918, 919, 923, 925, 929, 930, 934, + 935, 939, 940, 956, 957, 958, 959, 960, 964, 969, + 976, 986, 991, 996, 1004, 1009, 1014, 1019, 1024, 1032, + 1037, 1050, 1056, 1063, 1065, 1072, 1077, 1082, 1094, 1099, + 1104, 1109, 1114, 1122, 1127, 1135, 1136, 1137, 1138, 1144, + 1149, 1157, 1158, 1159, 1160, 1164, 1165, 1166, 1167, 1172, + 1173, 1183, 1184, 1189, 1190, 1195, 1197, 1199, 1201, 1203, + 1206, 1205, 1217, 1218, 1220, 1230, 1231, 1236, 1240, 1242, + 1244, 1246, 1248, 1251, 1256, 1258, 1260, 1262, 1264, 1266, + 1268, 1270, 1272, 1274, 1276, 1278, 1284, 1285, 1287, 1289, + 1291, 1296, 1297, 1303, 1304, 1306, 1308, 1313, 1315, 1317, + 1319, 1324, 1325, 1327, 1329, 1334, 1335, 1337, 1342, 1343, + 1345, 1347, 1352, 1354, 1356, 1361, 1362, 1366, 1368, 1370, + 1372, 1374, 1376, 1378, 1380, 1383, 1388, 1390, 1395, 1397, + 1402, 1403, 1405, 1406, 1411, 1412, 1414, 1416, 1421, 1423, + 1429, 1430, 1432, 1435, 1438, 1443, 1444, 1449, 1454, 1458, + 1460, 1462, 1467, 1469, 1475, 1476, 1484, 1485, 1489, 1490, + 1491, 1493, 1495, 1503, 1504, 1506, 1508, 1513, 1514, 1520, + 1521, 1525, 1526, 1531, 1532, 1533, 1535, 1544, 1545, 1547, + 1550, 1552, 1556, 1557, 1558, 1560, 1562, 1566, 1571, 1579, + 1580, 1589, 1591, 1596, 1597, 1598, 1602, 1603, 1604, 1608, + 1609, 1610, 1614, 1615, 1616, 1621, 1622, 1623, 1624, 1630, + 1631, 1635, 1636, 1640, 1641, 1642, 1643, 1658, 1659, 1664, + 1665, 1669, 1671, 1675, 1677, 1679, 1703, 1704, 1706, 1708, + 1713, 1715, 1717, 1722, 1723, 1729, 1728, 1732, 1736, 1738, + 1740, 1746, 1747, 1752, 1757, 1759, 1764, 1766, 1767, 1769, + 1774, 1776, 1778, 1783, 1785, 1790, 1795, 1803, 1809, 1808, + 1822, 1823, 1828, 1829, 1833, 1838, 1843, 1851, 1856, 1867, + 1868, 1879, 1880, 1886, 1887, 1891, 1892, 1893, 1896, 1895, + 1906, 1911, 1918, 1924, 1933, 1939, 1945, 1951, 1957, 1965, + 1971, 1979, 1985, 1994, 1995, 1996, 2000, 2004, 2006, 2009, + 2011, 2015, 2016, 2020, 2024, 2025, 2028, 2030, 2031, 2035, + 2036, 2037, 2038, 2073, 2074, 2075, 2076, 2080, 2085, 2090, + 2092, 2094, 2099, 2101, 2103, 2105, 2110, 2112, 2122, 2123, + 2124, 2128, 2130, 2132, 2137, 2139, 2141, 2146, 2148, 2150, + 2159, 2160, 2161, 2165, 2167, 2169, 2174, 2176, 2178, 2183, + 2185, 2187, 2202, 2203, 2204, 2205, 2209, 2214, 2219, 2221, + 2223, 2228, 2230, 2232, 2234, 2239, 2241, 2243, 2253, 2254, + 2255, 2256, 2260, 2262, 2264, 2269, 2271, 2273, 2275, 2280, + 2282, 2284, 2315, 2316, 2317, 2318, 2322, 2330, 2332, 2334, + 2339, 2341, 2346, 2348, 2362, 2363, 2364, 2368, 2370, 2372, + 2374, 2376, 2381, 2382, 2384, 2386, 2391, 2393, 2395, 2401, + 2403, 2405, 2409, 2411, 2413, 2415, 2429, 2430, 2431, 2435, + 2437, 2439, 2441, 2443, 2448, 2449, 2451, 2453, 2458, 2460, + 2462, 2468, 2469, 2471, 2481, 2484, 2486, 2489, 2491, 2493, + 2506, 2507, 2508, 2512, 2514, 2516, 2518, 2520, 2525, 2526, + 2528, 2530, 2535, 2537, 2545, 2546, 2547, 2552, 2553, 2557, + 2559, 2561, 2563, 2565, 2567, 2574, 2576, 2578, 2580, 2582, + 2584, 2586, 2588, 2590, 2592, 2597, 2599, 2601, 2606, 2632, + 2633, 2635, 2639, 2640, 2644, 2646, 2648, 2650, 2652, 2654, + 2661, 2663, 2665, 2667, 2669, 2671, 2676, 2681, 2683, 2685, + 2705, 2707, 2712, 2713 +}; +#endif + +#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE +/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + "$end", "error", "$undefined", "TYPEDEF", "AUTO", "EXTERN", "REGISTER", + "STATIC", "INLINE", "FORTRAN", "CONST", "VOLATILE", "RESTRICT", "FORALL", + "LVALUE", "VOID", "CHAR", "SHORT", "INT", "LONG", "FLOAT", "DOUBLE", + "SIGNED", "UNSIGNED", "BOOL", "COMPLEX", "IMAGINARY", "TYPEOF", "LABEL", + "ENUM", "STRUCT", "UNION", "TYPE", "FTYPE", "DTYPE", "CONTEXT", "SIZEOF", + "ATTRIBUTE", "EXTENSION", "IF", "ELSE", "SWITCH", "CASE", "DEFAULT", + "DO", "WHILE", "FOR", "BREAK", "CONTINUE", "GOTO", "RETURN", "CHOOSE", + "FALLTHRU", "TRY", "CATCH", "FINALLY", "THROW", "ASM", "ALIGNAS", + "ALIGNOF", "ATOMIC", "GENERIC", "NORETURN", "STATICASSERT", + "THREADLOCAL", "IDENTIFIER", "QUOTED_IDENTIFIER", "TYPEDEFname", + "TYPEGENname", "ATTR_IDENTIFIER", "ATTR_TYPEDEFname", "ATTR_TYPEGENname", + "INTEGERconstant", "FLOATINGconstant", "CHARACTERconstant", + "STRINGliteral", "ZERO", "ONE", "ARROW", "ICR", "DECR", "LS", "RS", "LE", + "GE", "EQ", "NE", "ANDAND", "OROR", "ELLIPSIS", "MULTassign", + "DIVassign", "MODassign", "PLUSassign", "MINUSassign", "LSassign", + "RSassign", "ANDassign", "ERassign", "ORassign", "THEN", "'('", "')'", + "'['", "']'", "'.'", "'{'", "'}'", "','", "':'", "'!'", "'*'", "'&'", + "'+'", "'-'", "'~'", "'/'", "'%'", "'<'", "'>'", "'^'", "'|'", "'?'", + "'='", "';'", "$accept", "push", "pop", "constant", "identifier", + "no_01_identifier", "no_attr_identifier", "zero_one", + "string_literal_list", "primary_expression", "postfix_expression", + "argument_expression_list", "argument_expression", "field_list", "field", + "unary_expression", "unary_operator", "cast_expression", + "multiplicative_expression", "additive_expression", "shift_expression", + "relational_expression", "equality_expression", "AND_expression", + "exclusive_OR_expression", "inclusive_OR_expression", + "logical_AND_expression", "logical_OR_expression", + "conditional_expression", "constant_expression", "assignment_expression", + "assignment_expression_opt", "tuple", "tuple_expression_list", + "assignment_operator", "comma_expression", "comma_expression_opt", + "statement", "labeled_statement", "compound_statement", + "block_item_list", "block_item", "statement_list", + "expression_statement", "selection_statement", "case_value", + "case_value_list", "case_label", "case_label_list", "case_clause", + "switch_clause_list_opt", "switch_clause_list", "choose_clause_list_opt", + "choose_clause_list", "fall_through_opt", "fall_through", + "iteration_statement", "for_control_expression", "jump_statement", + "exception_statement", "handler_list", "handler_clause", + "finally_clause", "exception_declaration", "asm_statement", + "asm_operands_opt", "asm_operands_list", "asm_operand", + "asm_clobbers_list", "declaration_list_opt", "declaration_list", + "old_declaration_list_opt", "old_declaration_list", + "label_declaration_opt", "label_declaration_list", "label_list", + "declaration", "new_declaration", "new_variable_declaration", + "new_variable_specifier", "new_function_declaration", + "new_function_specifier", "new_function_return", + "new_typedef_declaration", "typedef_declaration", "typedef_expression", + "old_declaration", "declaring_list", "declaration_specifier", + "type_specifier", "type_qualifier_list_opt", "type_qualifier_list", + "type_qualifier", "type_qualifier_name", "$@1", + "declaration_qualifier_list", "storage_class_list", "storage_class", + "storage_class_name", "basic_type_name", "basic_declaration_specifier", + "basic_type_specifier", "direct_type_name", "indirect_type_name", + "sue_declaration_specifier", "sue_type_specifier", + "typedef_declaration_specifier", "typedef_type_specifier", + "elaborated_type_name", "aggregate_name", "aggregate_key", + "field_declaration_list", "field_declaration", + "new_field_declaring_list", "field_declaring_list", "field_declarator", + "bit_subrange_size_opt", "bit_subrange_size", "enum_key", "enum_name", + "enumerator_list", "enumerator_value_opt", "new_parameter_type_list_opt", + "new_parameter_type_list", "new_parameter_list", + "new_abstract_parameter_list", "parameter_type_list_opt", + "parameter_type_list", "parameter_list", "new_parameter_declaration", + "new_abstract_parameter_declaration", "parameter_declaration", + "abstract_parameter_declaration", "identifier_list", + "identifier_or_typedef_name", "no_01_identifier_or_typedef_name", + "no_attr_identifier_or_typedef_name", "type_name_no_function", + "type_name", "initializer_opt", "initializer", "initializer_list", + "designation", "designator_list", "designator", + "typegen_declaration_specifier", "typegen_type_specifier", + "type_parameter_list", "type_parameter", "$@2", "type_class", + "assertion_list_opt", "assertion", "type_name_list", + "type_declaring_list", "type_declarator", "type_declarator_name", + "context_specifier", "$@3", "context_declaration_list", + "context_declaration", "new_context_declaring_list", + "context_declaring_list", "translation_unit", "external_definition_list", + "external_definition_list_opt", "external_definition", "$@4", + "external_function_definition", "function_definition", "declarator", + "subrange", "asm_name_opt", "attribute_list_opt", "attribute_list", + "attribute", "attribute_parameter_list", "attrib", "any_word", + "variable_declarator", "paren_identifier", "variable_ptr", + "variable_array", "variable_function", "function_declarator", + "function_no_ptr", "function_ptr", "function_array", + "old_function_declarator", "old_function_no_ptr", "old_function_ptr", + "old_function_array", "typedef_redeclarator", "paren_typedef", + "typedef_ptr", "typedef_array", "typedef_function", + "identifier_parameter_declarator", "identifier_parameter_ptr", + "identifier_parameter_array", "identifier_parameter_function", + "typedef_parameter_redeclarator", "typedef", "typedef_parameter_ptr", + "typedef_parameter_array", "typedef_parameter_function", + "abstract_declarator", "abstract_ptr", "abstract_array", + "abstract_function", "array_dimension", "multi_array_dimension", + "abstract_parameter_declarator", "abstract_parameter_ptr", + "abstract_parameter_array", "abstract_parameter_function", + "array_parameter_dimension", "array_parameter_1st_dimension", + "variable_abstract_declarator", "variable_abstract_ptr", + "variable_abstract_array", "variable_abstract_function", + "new_identifier_parameter_declarator_tuple", + "new_identifier_parameter_declarator_no_tuple", + "new_identifier_parameter_ptr", "new_identifier_parameter_array", + "new_array_parameter_1st_dimension", "new_abstract_declarator_tuple", + "new_abstract_declarator_no_tuple", "new_abstract_ptr", + "new_abstract_array", "new_abstract_tuple", "new_abstract_function", + "comma_opt", "assignment_opt", 0 +}; +#endif + +# ifdef YYPRINT +/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to + token YYLEX-NUM. */ +static const yytype_uint16 yytoknum[] = +{ + 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, + 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, + 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, + 355, 40, 41, 91, 93, 46, 123, 125, 44, 58, + 33, 42, 38, 43, 45, 126, 47, 37, 60, 62, + 94, 124, 63, 61, 59 +}; +# endif + +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const yytype_uint16 yyr1[] = +{ + 0, 125, 126, 127, 128, 128, 128, 129, 129, 129, + 130, 130, 131, 132, 132, 133, 133, 134, 134, 134, + 134, 134, 134, 135, 135, 135, 135, 135, 135, 135, + 135, 135, 135, 136, 136, 137, 137, 137, 137, 137, + 138, 138, 139, 139, 139, 139, 139, 140, 140, 140, + 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, + 140, 140, 141, 141, 141, 141, 142, 142, 142, 143, + 143, 143, 143, 144, 144, 144, 145, 145, 145, 146, + 146, 146, 146, 146, 147, 147, 147, 148, 148, 149, + 149, 150, 150, 151, 151, 152, 152, 153, 153, 153, + 153, 154, 155, 155, 155, 155, 156, 156, 157, 157, + 157, 157, 158, 158, 159, 159, 159, 159, 159, 159, + 159, 159, 159, 159, 160, 160, 161, 161, 162, 162, + 162, 162, 162, 162, 162, 162, 163, 164, 164, 165, + 165, 166, 166, 166, 166, 167, 167, 168, 169, 169, + 169, 169, 169, 169, 170, 170, 170, 171, 171, 172, + 172, 173, 173, 174, 175, 175, 176, 176, 177, 177, + 178, 178, 178, 178, 179, 179, 180, 180, 181, 181, + 181, 182, 182, 183, 183, 183, 183, 183, 183, 183, + 183, 183, 184, 184, 184, 185, 185, 185, 186, 186, + 187, 188, 188, 188, 188, 188, 189, 189, 189, 189, + 190, 190, 191, 191, 192, 193, 193, 194, 194, 195, + 195, 196, 196, 197, 197, 198, 198, 199, 199, 200, + 200, 201, 201, 202, 202, 202, 202, 202, 203, 203, + 203, 204, 204, 204, 205, 205, 205, 205, 205, 206, + 206, 206, 206, 207, 207, 208, 208, 208, 209, 209, + 209, 209, 209, 210, 210, 211, 211, 211, 211, 212, + 212, 213, 213, 213, 213, 214, 214, 214, 214, 215, + 215, 216, 216, 217, 217, 218, 218, 218, 218, 218, + 219, 218, 220, 220, 220, 221, 221, 222, 223, 223, + 223, 223, 223, 223, 224, 224, 224, 224, 224, 224, + 224, 224, 224, 224, 224, 224, 225, 225, 225, 225, + 225, 226, 226, 227, 227, 227, 227, 228, 228, 228, + 228, 229, 229, 229, 229, 230, 230, 230, 231, 231, + 231, 231, 232, 232, 232, 233, 233, 234, 234, 234, + 234, 234, 234, 234, 234, 234, 235, 235, 236, 236, + 237, 237, 237, 237, 238, 238, 238, 238, 239, 239, + 240, 240, 240, 240, 240, 241, 241, 242, 243, 244, + 244, 244, 245, 245, 246, 246, 247, 247, 248, 248, + 248, 248, 248, 249, 249, 249, 249, 250, 250, 251, + 251, 252, 252, 253, 253, 253, 253, 254, 254, 254, + 254, 254, 255, 255, 255, 255, 255, 256, 256, 257, + 257, 258, 258, 259, 259, 259, 260, 260, 260, 261, + 261, 261, 262, 262, 262, 263, 263, 263, 263, 264, + 264, 265, 265, 266, 266, 266, 266, 267, 267, 268, + 268, 269, 269, 269, 269, 269, 270, 270, 270, 270, + 271, 271, 271, 272, 272, 274, 273, 273, 275, 275, + 275, 276, 276, 277, 277, 277, 278, 278, 278, 278, + 279, 279, 279, 280, 280, 281, 281, 282, 283, 282, + 284, 284, 285, 285, 286, 286, 286, 287, 287, 288, + 288, 289, 289, 290, 290, 291, 291, 291, 292, 291, + 291, 293, 293, 293, 294, 294, 294, 294, 294, 294, + 294, 294, 294, 295, 295, 295, 296, 297, 297, 298, + 298, 299, 299, 300, 301, 301, 302, 302, 302, 303, + 303, 303, 303, 304, 304, 304, 304, 305, 305, 306, + 306, 306, 307, 307, 307, 307, 308, 308, 309, 309, + 309, 310, 310, 310, 311, 311, 311, 312, 312, 312, + 313, 313, 313, 314, 314, 314, 315, 315, 315, 316, + 316, 316, 317, 317, 317, 317, 318, 318, 319, 319, + 319, 320, 320, 320, 320, 321, 321, 321, 322, 322, + 322, 322, 323, 323, 323, 324, 324, 324, 324, 325, + 325, 325, 326, 326, 326, 326, 327, 328, 328, 328, + 329, 329, 330, 330, 331, 331, 331, 332, 332, 332, + 332, 332, 333, 333, 333, 333, 334, 334, 334, 335, + 335, 335, 336, 336, 336, 336, 337, 337, 337, 338, + 338, 338, 338, 338, 339, 339, 339, 339, 340, 340, + 340, 341, 341, 341, 342, 342, 342, 342, 342, 342, + 343, 343, 343, 344, 344, 344, 344, 344, 345, 345, + 345, 345, 346, 346, 347, 347, 347, 348, 348, 349, + 349, 349, 349, 349, 349, 350, 350, 350, 350, 350, + 350, 350, 350, 350, 350, 351, 351, 351, 351, 352, + 352, 352, 353, 353, 354, 354, 354, 354, 354, 354, + 355, 355, 355, 355, 355, 355, 356, 357, 357, 357, + 358, 358, 359, 359 +}; + +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const yytype_uint8 yyr2[] = +{ + 0, 2, 0, 0, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, + 1, 3, 3, 1, 6, 4, 3, 7, 3, 7, + 2, 2, 7, 1, 3, 0, 1, 3, 7, 9, + 1, 3, 1, 3, 7, 3, 7, 1, 2, 2, + 2, 2, 2, 2, 2, 4, 1, 4, 4, 2, + 4, 2, 1, 1, 1, 1, 1, 4, 4, 1, + 3, 3, 3, 1, 3, 3, 1, 3, 3, 1, + 3, 3, 3, 3, 1, 3, 3, 1, 3, 1, + 3, 1, 3, 1, 3, 1, 3, 1, 5, 4, + 5, 1, 1, 3, 3, 2, 0, 1, 4, 5, + 6, 7, 1, 3, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 3, 0, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 4, 2, 7, 1, + 3, 1, 2, 1, 2, 1, 2, 2, 5, 7, + 5, 9, 5, 9, 1, 3, 1, 1, 3, 3, + 2, 1, 2, 2, 0, 1, 2, 3, 0, 1, + 2, 3, 3, 4, 0, 1, 1, 2, 5, 7, + 6, 6, 4, 3, 4, 2, 3, 2, 3, 3, + 3, 2, 3, 3, 4, 1, 5, 6, 9, 10, + 2, 1, 2, 2, 2, 1, 6, 8, 10, 12, + 0, 1, 1, 3, 4, 1, 3, 1, 1, 1, + 3, 1, 1, 1, 3, 0, 1, 3, 4, 1, + 3, 1, 1, 3, 3, 3, 3, 3, 2, 3, + 6, 3, 3, 4, 1, 2, 2, 3, 5, 10, + 10, 7, 7, 5, 9, 2, 2, 5, 3, 5, + 4, 3, 4, 4, 7, 3, 3, 3, 3, 4, + 6, 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, + 0, 5, 1, 2, 3, 1, 2, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 2, 2, 3, + 3, 1, 3, 1, 2, 2, 2, 4, 4, 4, + 4, 1, 2, 2, 3, 1, 2, 2, 1, 2, + 2, 3, 1, 2, 2, 1, 1, 4, 2, 5, + 9, 7, 10, 12, 7, 13, 2, 2, 1, 2, + 2, 3, 2, 3, 1, 2, 3, 2, 2, 4, + 0, 1, 2, 2, 1, 0, 1, 2, 2, 5, + 6, 2, 2, 4, 0, 2, 0, 1, 1, 1, + 5, 5, 5, 1, 5, 5, 9, 1, 5, 0, + 1, 1, 5, 1, 1, 5, 5, 1, 3, 3, + 4, 1, 1, 1, 1, 2, 1, 3, 3, 1, + 2, 1, 3, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 2, 1, 1, 1, 2, 0, + 2, 1, 4, 1, 2, 3, 4, 2, 2, 1, + 2, 2, 5, 5, 7, 6, 1, 2, 2, 3, + 4, 5, 2, 2, 4, 0, 4, 2, 1, 1, + 1, 0, 2, 5, 5, 13, 1, 1, 3, 3, + 2, 3, 3, 2, 4, 1, 6, 9, 0, 11, + 1, 3, 3, 3, 1, 1, 5, 2, 5, 0, + 1, 1, 3, 0, 1, 1, 1, 1, 0, 6, + 2, 1, 2, 4, 2, 3, 3, 3, 4, 5, + 5, 5, 6, 1, 1, 1, 3, 0, 5, 0, + 1, 1, 2, 6, 1, 3, 0, 1, 4, 1, + 1, 1, 1, 2, 1, 2, 2, 1, 3, 2, + 3, 3, 2, 4, 4, 3, 8, 3, 2, 1, + 2, 6, 8, 3, 2, 3, 3, 4, 4, 3, + 1, 1, 1, 4, 6, 3, 2, 3, 3, 4, + 4, 3, 2, 1, 2, 2, 1, 3, 2, 3, + 3, 2, 4, 4, 3, 6, 8, 3, 2, 1, + 2, 2, 2, 3, 3, 2, 4, 4, 3, 6, + 8, 3, 2, 1, 2, 2, 1, 2, 3, 3, + 2, 4, 6, 8, 1, 2, 2, 1, 2, 2, + 3, 3, 1, 4, 4, 3, 5, 8, 3, 4, + 5, 1, 5, 5, 6, 6, 1, 2, 2, 1, + 2, 2, 3, 3, 1, 4, 4, 3, 5, 8, + 3, 1, 2, 1, 4, 6, 5, 6, 7, 7, + 1, 2, 2, 1, 2, 2, 3, 3, 1, 4, + 4, 3, 8, 3, 1, 1, 2, 1, 1, 2, + 3, 2, 3, 2, 3, 5, 2, 6, 3, 2, + 5, 2, 6, 3, 2, 6, 6, 6, 7, 1, + 2, 1, 1, 1, 2, 3, 2, 3, 2, 3, + 5, 6, 2, 5, 6, 2, 5, 7, 6, 6, + 0, 1, 0, 2 +}; + +/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM. + Performed when YYTABLE doesn't specify something else to do. Zero + means the default is an error. */ +static const yytype_uint16 yydefact[] = +{ + 279, 279, 300, 298, 301, 299, 302, 303, 285, 287, + 286, 0, 288, 312, 304, 309, 307, 308, 306, 305, + 310, 311, 313, 314, 315, 529, 529, 529, 0, 0, + 0, 279, 279, 289, 7, 342, 0, 8, 13, 14, + 0, 2, 279, 547, 9, 507, 505, 231, 3, 439, + 3, 244, 0, 3, 3, 3, 232, 3, 0, 0, + 0, 280, 281, 283, 279, 292, 295, 297, 323, 271, + 316, 321, 272, 331, 273, 338, 335, 345, 0, 0, + 346, 274, 456, 3, 3, 0, 2, 501, 506, 511, + 284, 0, 0, 529, 559, 529, 2, 570, 571, 572, + 279, 0, 712, 713, 0, 12, 279, 0, 255, 256, + 0, 280, 275, 276, 277, 278, 508, 290, 378, 530, + 531, 356, 357, 12, 430, 431, 11, 426, 429, 0, + 485, 480, 471, 430, 431, 0, 0, 510, 0, 280, + 279, 0, 0, 0, 0, 0, 0, 0, 0, 279, + 2, 0, 714, 280, 564, 576, 718, 711, 709, 716, + 0, 0, 238, 2, 0, 514, 424, 425, 423, 0, + 0, 0, 0, 529, 0, 586, 0, 0, 527, 523, + 529, 544, 529, 529, 524, 2, 525, 529, 583, 529, + 529, 0, 0, 0, 279, 279, 298, 343, 0, 2, + 279, 245, 282, 293, 324, 336, 0, 2, 0, 439, + 246, 280, 317, 332, 339, 457, 0, 2, 0, 296, + 318, 325, 326, 0, 333, 337, 340, 344, 2, 279, + 348, 0, 381, 458, 462, 0, 0, 0, 1, 279, + 2, 512, 558, 560, 279, 2, 722, 280, 725, 527, + 527, 280, 0, 0, 0, 258, 529, 524, 2, 279, + 0, 0, 279, 532, 2, 483, 2, 536, 0, 0, + 0, 0, 17, 56, 4, 5, 6, 15, 0, 0, + 0, 279, 2, 0, 279, 62, 63, 64, 65, 19, + 18, 20, 23, 47, 66, 0, 69, 73, 76, 79, + 84, 87, 89, 91, 93, 95, 97, 102, 477, 732, + 437, 476, 0, 435, 436, 0, 548, 563, 566, 569, + 575, 578, 581, 2, 279, 0, 3, 411, 0, 419, + 280, 279, 292, 316, 272, 331, 338, 3, 3, 393, + 397, 407, 412, 456, 279, 413, 687, 688, 279, 414, + 416, 279, 2, 565, 577, 710, 2, 2, 233, 2, + 0, 0, 441, 440, 137, 2, 2, 235, 2, 2, + 234, 2, 266, 2, 267, 0, 265, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 549, 588, 0, 439, + 2, 543, 552, 641, 545, 546, 515, 279, 2, 582, + 591, 584, 585, 0, 261, 279, 279, 322, 0, 280, + 279, 279, 715, 719, 717, 516, 279, 527, 239, 247, + 294, 0, 2, 517, 279, 481, 319, 320, 268, 334, + 341, 279, 279, 2, 370, 279, 358, 0, 0, 364, + 709, 279, 730, 384, 0, 459, 482, 236, 237, 502, + 279, 421, 0, 279, 221, 0, 2, 223, 0, 280, + 0, 241, 2, 242, 263, 0, 0, 2, 279, 527, + 279, 468, 470, 469, 0, 0, 732, 0, 279, 0, + 279, 472, 279, 542, 540, 541, 539, 0, 534, 537, + 66, 101, 0, 279, 54, 50, 279, 59, 279, 279, + 48, 49, 61, 2, 124, 0, 0, 433, 0, 432, + 279, 52, 53, 16, 0, 30, 31, 35, 2, 0, + 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, + 0, 0, 51, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 105, 2, 627, 438, 624, 529, 529, + 632, 460, 279, 2, 567, 2, 568, 0, 579, 580, + 279, 2, 279, 0, 689, 280, 693, 684, 685, 691, + 279, 0, 616, 2, 2, 649, 529, 732, 599, 529, + 529, 732, 529, 613, 529, 529, 663, 420, 646, 529, + 529, 654, 661, 279, 415, 280, 0, 0, 279, 699, + 280, 704, 732, 696, 279, 701, 732, 0, 279, 279, + 0, 3, 17, 2, 0, 0, 443, 730, 0, 0, + 449, 225, 0, 279, 0, 0, 0, 527, 551, 555, + 557, 587, 590, 594, 597, 550, 589, 0, 269, 3, + 0, 279, 262, 0, 0, 0, 0, 260, 0, 2, + 0, 0, 243, 518, 279, 0, 437, 3, 3, 0, + 0, 279, 0, 0, 673, 368, 371, 375, 529, 375, + 678, 374, 670, 529, 529, 347, 359, 367, 360, 529, + 362, 365, 279, 731, 0, 0, 382, 730, 280, 3, + 400, 3, 404, 403, 573, 0, 513, 279, 3, 3, + 279, 419, 280, 3, 413, 414, 2, 0, 0, 0, + 467, 291, 279, 463, 465, 3, 2, 2, 0, 484, + 3, 0, 536, 126, 0, 210, 0, 0, 2, 0, + 0, 36, 0, 0, 279, 21, 0, 22, 0, 673, + 434, 0, 106, 0, 3, 2, 28, 2, 0, 33, + 0, 2, 26, 103, 104, 70, 71, 72, 74, 75, + 77, 78, 82, 83, 80, 81, 85, 86, 88, 90, + 92, 94, 96, 0, 0, 733, 279, 0, 0, 0, + 628, 629, 625, 626, 479, 478, 279, 0, 0, 0, + 280, 279, 279, 643, 686, 342, 0, 720, 279, 723, + 642, 2, 279, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 650, 602, 617, 651, 2, 598, 605, 417, + 600, 601, 418, 2, 612, 620, 614, 615, 647, 648, + 662, 690, 694, 692, 732, 253, 2, 726, 2, 408, + 698, 703, 409, 279, 3, 387, 3, 3, 3, 439, + 0, 3, 3, 2, 451, 448, 731, 0, 444, 2, + 447, 450, 0, 279, 226, 248, 3, 257, 259, 0, + 439, 2, 553, 554, 2, 592, 593, 0, 3, 0, + 519, 3, 328, 327, 330, 329, 461, 279, 0, 520, + 0, 521, 2, 627, 0, 0, 361, 363, 2, 0, + 0, 0, 0, 0, 377, 674, 675, 372, 376, 373, + 671, 672, 366, 370, 349, 384, 379, 385, 0, 0, + 0, 422, 224, 0, 0, 3, 2, 649, 415, 0, + 509, 0, 732, 471, 0, 279, 279, 279, 0, 533, + 535, 127, 0, 206, 0, 0, 211, 212, 55, 60, + 279, 0, 58, 57, 0, 0, 125, 674, 0, 67, + 68, 107, 112, 3, 108, 106, 0, 0, 3, 25, + 35, 3, 0, 99, 0, 3, 631, 635, 638, 630, + 3, 574, 108, 2, 279, 3, 3, 280, 0, 2, + 2, 721, 724, 0, 3, 604, 608, 611, 619, 653, + 657, 660, 279, 0, 3, 603, 618, 652, 279, 279, + 410, 279, 279, 279, 0, 0, 0, 0, 240, 108, + 0, 101, 0, 3, 3, 0, 445, 0, 442, 0, + 0, 229, 279, 0, 0, 126, 0, 0, 0, 0, + 0, 126, 0, 0, 0, 2, 0, 0, 3, 128, + 129, 2, 139, 130, 131, 132, 133, 134, 135, 141, + 143, 0, 0, 0, 270, 279, 279, 529, 639, 0, + 0, 0, 522, 628, 0, 0, 279, 279, 677, 681, + 683, 676, 369, 383, 380, 561, 2, 645, 644, 0, + 650, 2, 464, 466, 486, 3, 494, 495, 0, 2, + 490, 3, 3, 0, 0, 538, 0, 0, 210, 0, + 3, 37, 108, 730, 106, 0, 3, 642, 42, 3, + 40, 3, 34, 0, 3, 98, 100, 0, 2, 633, + 634, 0, 695, 279, 700, 279, 0, 0, 0, 3, + 279, 279, 279, 619, 0, 2, 606, 607, 2, 621, + 2, 655, 656, 0, 664, 0, 3, 0, 3, 3, + 3, 3, 395, 394, 398, 0, 729, 2, 2, 728, + 109, 0, 0, 0, 0, 3, 446, 3, 0, 227, + 142, 3, 280, 279, 0, 0, 0, 0, 2, 187, + 0, 185, 0, 0, 0, 0, 0, 0, 191, 0, + 279, 529, 147, 144, 279, 0, 0, 252, 264, 3, + 3, 528, 640, 595, 279, 279, 279, 351, 354, 0, + 2, 679, 680, 279, 251, 279, 0, 497, 474, 279, + 0, 0, 473, 488, 0, 207, 0, 213, 106, 0, + 0, 113, 110, 0, 0, 0, 0, 0, 0, 24, + 0, 636, 279, 562, 697, 702, 705, 706, 707, 0, + 3, 3, 658, 279, 279, 279, 3, 3, 0, 666, + 0, 0, 0, 0, 727, 279, 279, 3, 526, 109, + 453, 0, 0, 230, 280, 0, 0, 0, 0, 279, + 188, 186, 0, 183, 189, 0, 0, 0, 192, 195, + 193, 190, 0, 126, 140, 138, 228, 0, 0, 0, + 279, 279, 108, 279, 402, 406, 405, 0, 491, 2, + 492, 2, 493, 487, 279, 214, 0, 0, 3, 642, + 32, 111, 2, 45, 2, 43, 41, 29, 109, 27, + 3, 708, 0, 0, 3, 3, 3, 0, 0, 665, + 667, 609, 622, 254, 2, 392, 3, 391, 0, 455, + 452, 126, 0, 0, 126, 3, 0, 126, 184, 0, + 2, 200, 194, 0, 108, 136, 556, 596, 0, 350, + 279, 3, 2, 0, 0, 2, 208, 215, 0, 0, + 0, 0, 0, 0, 250, 249, 0, 0, 0, 668, + 669, 279, 0, 454, 148, 0, 0, 2, 161, 126, + 150, 0, 178, 0, 126, 0, 2, 152, 0, 2, + 2, 279, 0, 352, 0, 279, 496, 498, 489, 0, + 0, 111, 38, 3, 3, 637, 610, 623, 659, 396, + 126, 154, 157, 0, 156, 160, 3, 163, 162, 0, + 126, 180, 126, 3, 0, 279, 0, 2, 279, 279, + 682, 2, 209, 216, 0, 0, 0, 149, 0, 0, + 159, 217, 164, 2, 219, 179, 0, 182, 168, 196, + 3, 201, 205, 0, 279, 353, 279, 0, 39, 46, + 44, 155, 158, 126, 0, 165, 279, 126, 126, 0, + 169, 0, 0, 673, 202, 203, 204, 197, 3, 355, + 279, 145, 166, 151, 126, 220, 181, 176, 174, 170, + 153, 126, 0, 674, 0, 0, 146, 167, 177, 171, + 175, 174, 172, 3, 0, 475, 173, 198, 3, 199 +}; + +/* YYDEFGOTO[NTERM-NUM]. */ +static const yytype_int16 yydefgoto[] = +{ + -1, 812, 454, 289, 43, 127, 128, 290, 291, 292, + 293, 758, 740, 1129, 1130, 294, 295, 296, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 1032, + 504, 972, 309, 973, 531, 951, 1057, 1521, 1059, 1060, + 1061, 1062, 1522, 1063, 1064, 1452, 1453, 1418, 1419, 1420, + 1504, 1505, 1509, 1510, 1539, 1540, 1065, 1376, 1066, 1067, + 1308, 1309, 1310, 1490, 1068, 955, 956, 957, 1398, 1482, + 1483, 455, 456, 873, 874, 1040, 46, 47, 48, 49, + 50, 327, 151, 53, 54, 55, 56, 57, 329, 59, + 60, 251, 62, 63, 262, 331, 332, 66, 67, 68, + 69, 112, 71, 194, 334, 113, 74, 114, 76, 77, + 78, 435, 436, 437, 438, 675, 917, 676, 79, 80, + 442, 696, 854, 855, 337, 338, 699, 700, 701, 339, + 340, 341, 342, 452, 169, 129, 130, 508, 311, 162, + 626, 627, 628, 629, 630, 81, 115, 475, 476, 943, + 477, 265, 481, 312, 83, 131, 132, 84, 1334, 1109, + 1110, 1111, 1112, 85, 86, 717, 87, 261, 88, 89, + 178, 1034, 662, 391, 119, 90, 487, 488, 489, 179, + 256, 181, 182, 183, 257, 93, 94, 95, 96, 97, + 98, 99, 186, 187, 188, 189, 190, 823, 588, 589, + 590, 591, 592, 593, 594, 595, 556, 557, 558, 559, + 680, 100, 597, 598, 599, 600, 601, 602, 916, 682, + 683, 684, 576, 345, 346, 347, 348, 439, 157, 102, + 103, 349, 350, 694, 553 +}; + +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +#define YYPACT_NINF -1291 +static const yytype_int16 yypact[] = +{ + 3767, 2676, -1291, 62, -1291, -1291, -1291, -1291, -1291, -1291, + -1291, 146, -1291, -1291, -1291, -1291, -1291, -1291, -1291, -1291, + -1291, -1291, -1291, -1291, -1291, 115, 115, 115, 905, 892, + 225, 4876, 1045, -1291, -1291, -1291, 234, -1291, -1291, -1291, + 678, -1291, 2287, -1291, -1291, -1291, -1291, -1291, -1291, 63, + 239, -1291, 1646, -1291, -1291, -1291, -1291, 252, 886, 360, + 99, 7577, -1291, -1291, 9303, 1009, -1291, -1291, -1291, 1359, + 399, 5014, 640, 618, 1359, 728, -1291, -1291, 365, 285, + -1291, 1359, 1167, 282, -1291, 469, 486, -1291, -1291, -1291, + -1291, 345, 239, 115, -1291, 115, -1291, -1291, -1291, -1291, + 10104, 1646, -1291, -1291, 1646, -1291, 10163, 377, -1291, -1291, + 1212, 10222, -1291, 1045, 1045, 1045, -1291, -1291, -1291, 115, + -1291, -1291, -1291, 406, 455, 458, -1291, -1291, -1291, 466, + -1291, -1291, -1291, -1291, -1291, 475, 515, -1291, 538, 1045, + 8846, 1230, 47, 506, 511, 552, 556, 559, 591, 7019, + -1291, 604, -1291, 9372, -1291, -1291, -1291, -1291, 614, -1291, + 250, 3635, -1291, 620, 260, -1291, -1291, -1291, -1291, 645, + 270, 290, 311, 115, 629, -1291, 886, 1586, 701, -1291, + 122, -1291, 115, 115, 239, -1291, -1291, 145, -1291, 115, + 115, 2053, 660, 672, 1045, 11990, -1291, -1291, 676, -1291, + 2287, -1291, -1291, 1359, -1291, -1291, 239, -1291, 1646, 63, + -1291, 7818, -1291, 1045, 1045, 1045, 239, -1291, 905, -1291, + 3082, -1291, -1291, 666, 1045, -1291, 1045, -1291, -1291, 5469, + 699, 892, 721, 1045, -1291, 905, 706, 710, -1291, 4876, + 778, -1291, -1291, -1291, 6212, -1291, -1291, 5247, -1291, 701, + 141, 10222, 11181, 1212, 2053, -1291, 171, -1291, -1291, 10163, + 1646, 744, 11930, -1291, -1291, 401, -1291, 11692, 11409, 11466, + 11409, 11523, -1291, 753, -1291, -1291, -1291, -1291, 11580, 11580, + 778, 8528, -1291, 11409, 8952, -1291, -1291, -1291, -1291, -1291, + -1291, 782, -1291, 993, 2004, 11409, -1291, 364, 202, 603, + 611, 697, 758, 762, 769, 821, 44, -1291, -1291, 789, + 446, -1291, 353, -1291, -1291, 1230, -1291, -1291, 434, 816, + -1291, 572, 816, -1291, 8634, 818, -1291, -1291, 1508, 1393, + 8274, 11990, 1359, -1291, 1359, 1045, 1045, -1291, -1291, -1291, + -1291, -1291, -1291, 1045, 10281, 1646, -1291, -1291, 10340, 1905, + -1291, 7019, -1291, -1291, -1291, -1291, -1291, -1291, -1291, -1291, + 5697, 11409, -1291, -1291, -1291, -1291, -1291, -1291, -1291, -1291, + -1291, -1291, -1291, -1291, -1291, 1212, -1291, 936, 839, 846, + 864, 951, 873, 893, 897, 1586, -1291, -1291, 902, 63, + -1291, -1291, -1291, 925, -1291, -1291, -1291, 6212, -1291, -1291, + -1291, -1291, -1291, 2053, -1291, 8846, 8846, -1291, 1212, 12018, + 8846, 7926, -1291, -1291, -1291, -1291, 6212, 141, -1291, -1291, + 1359, 239, -1291, -1291, 6212, -1291, 3835, -1291, -1291, 1045, + 1045, 5848, 10399, -1291, 1122, 9570, -1291, 315, 316, 892, + -1291, 5469, 935, 923, 892, 1045, -1291, -1291, -1291, -1291, + 10759, -1291, 387, 11958, -1291, 239, 964, -1291, 1212, 11767, + 11238, -1291, -1291, -1291, -1291, 999, 2053, -1291, 8339, 701, + 7468, -1291, -1291, -1291, 752, 594, 789, 892, 11930, 537, + 10163, -1291, 11930, -1291, -1291, -1291, -1291, 624, -1291, 973, + -1291, -1291, 152, 8528, -1291, -1291, 8528, -1291, 8740, 8528, + -1291, -1291, -1291, -1291, -1291, 664, 979, 483, 982, -1291, + 6675, -1291, -1291, -1291, 65, -1291, -1291, 11295, -1291, 91, + -1291, -1291, -1291, -1291, -1291, -1291, -1291, -1291, -1291, -1291, + 11181, 11181, -1291, 11409, 11409, 11409, 11409, 11409, 11409, 11409, + 11409, 11409, 11409, 11409, 11409, 11409, 11409, 11409, 11409, 11409, + 11409, 3856, 11181, -1291, 446, 1147, -1291, -1291, 115, 115, + -1291, -1291, 8846, -1291, -1291, -1291, 925, 778, -1291, 925, + 6675, -1291, 9058, 989, -1291, 10458, -1291, -1291, 614, -1291, + 8198, 991, -1291, 306, -1291, 1892, 253, 789, -1291, 115, + 115, 789, 258, -1291, 115, 115, 925, -1291, -1291, 115, + 115, -1291, 816, 10517, 1646, 11898, 307, 330, 10517, -1291, + 10694, -1291, 789, -1291, 10281, -1291, 162, 1003, 7991, 7991, + 1646, 5948, 1007, -1291, 361, 1011, -1291, 1000, 3635, 682, + -1291, 1096, 1646, 7991, 778, 1212, 778, 701, 705, 816, + -1291, -1291, 717, 816, -1291, -1291, -1291, 1051, -1291, 11352, + 239, 10759, -1291, 702, 1025, 723, 1027, -1291, 734, -1291, + 1026, 239, -1291, -1291, 6212, 239, 1580, 1024, 1032, 341, + 385, 7131, 1763, 11409, 2122, -1291, -1291, 1035, 43, 1035, + -1291, -1291, -1291, 115, 115, -1291, -1291, 892, -1291, 115, + -1291, -1291, 9629, 892, 1028, 11409, -1291, 935, 11898, -1291, + -1291, 1031, -1291, -1291, -1291, 778, -1291, 11833, 11409, -1291, + 7991, 675, 8274, -1291, -1291, 614, 1034, 1038, 752, 2429, + -1291, -1291, 11930, -1291, -1291, 1024, -1291, -1291, 1047, -1291, + 1024, 1048, 11692, 11181, 1029, 1076, 1060, 1061, -1291, 1055, + 1064, -1291, 1065, 1067, 6788, -1291, 11181, -1291, 483, 1926, + -1291, 6058, 11181, 1068, 1063, -1291, -1291, -1291, 756, -1291, + 11181, -1291, -1291, -1291, -1291, -1291, -1291, -1291, 364, 364, + 202, 202, 603, 603, 603, 603, 611, 611, 697, 758, + 762, 769, 821, 11409, 790, -1291, 10759, 1072, 1073, 1080, + 1147, -1291, -1291, -1291, -1291, -1291, 10759, 11352, 760, 1081, + 7243, 9164, 7019, -1291, -1291, 1085, 1089, -1291, 10104, -1291, + -1291, 306, 10759, 1010, 1090, 1092, 1093, 1098, 1099, 1100, + 1101, 4615, 1892, -1291, -1291, -1291, -1291, -1291, -1291, -1291, + -1291, -1291, -1291, -1291, -1291, -1291, -1291, -1291, -1291, -1291, + 925, -1291, -1291, -1291, 789, -1291, -1291, -1291, -1291, -1291, + -1291, -1291, -1291, 9986, -1291, -1291, 1103, 1104, -1291, 63, + 1105, 1063, 5948, -1291, -1291, -1291, 5697, 1107, -1291, -1291, + -1291, -1291, 892, 6285, 1187, -1291, -1291, -1291, -1291, 1106, + 63, -1291, -1291, 925, -1291, -1291, 925, 175, 11409, 1112, + -1291, -1291, -1291, -1291, -1291, -1291, -1291, 7019, 512, -1291, + 239, -1291, 1580, 1740, 1132, 1133, -1291, -1291, -1291, 1120, + 880, 1136, 1143, 1144, -1291, 2122, -1291, -1291, -1291, -1291, + -1291, -1291, -1291, 1122, -1291, 923, -1291, -1291, 1140, 1149, + 1148, -1291, -1291, 1156, 1157, -1291, 675, 2323, -1291, 374, + -1291, 2429, 789, -1291, 1150, 11930, 10576, 8846, 1160, -1291, + -1291, 1155, 1163, -1291, 1165, 173, 1161, -1291, 1166, 1166, + 6675, 11181, -1291, -1291, 1166, 1169, -1291, 1926, 5697, -1291, + -1291, -1291, -1291, 1172, 4760, 11181, 1180, 778, 5948, -1291, + 11295, -1291, 778, -1291, 11181, -1291, 792, 816, -1291, -1291, + -1291, -1291, 5313, -1291, 8634, -1291, -1291, 7355, 1183, -1291, + -1291, -1291, -1291, 1191, -1291, 828, 816, -1291, 866, 887, + 816, -1291, 1045, 1190, 4985, -1291, -1291, -1291, 10759, 10759, + -1291, 8404, 8404, 7991, 1194, 1192, 1193, 1200, -1291, -1291, + 1199, 450, 221, 1063, -1291, 778, -1291, 3635, -1291, 11181, + 501, -1291, 6563, 1207, 1208, 11124, 1209, 1210, 112, 142, + 54, 11181, 1213, 239, 5569, -1291, 1211, 1197, -1291, -1291, + -1291, 1215, -1291, -1291, -1291, -1291, -1291, -1291, -1291, -1291, + -1291, 892, 1223, 11181, -1291, 10759, 10759, 115, 816, 1224, + 1225, 1085, -1291, 1740, 651, 892, 6675, 10635, 924, 816, + -1291, -1291, -1291, -1291, -1291, -1291, -1291, -1291, -1291, 1226, + 2323, -1291, -1291, 1206, -1291, 1024, -1291, -1291, 1212, 1228, + -1291, -1291, -1291, 765, 1232, -1291, 11409, 1216, 1076, 1076, + 1234, -1291, 9688, 1000, 11181, 1240, 1172, 563, 227, 1239, + -1291, 1234, -1291, 1246, 1239, -1291, -1291, 1251, -1291, -1291, + 925, 1252, -1291, 10281, -1291, 6907, 1254, 1256, 1257, -1291, + 10045, 7991, 7991, -1291, 1253, -1291, -1291, 925, -1291, -1291, + -1291, -1291, 925, 11181, -1291, 11181, 11409, 1267, -1291, -1291, + -1291, -1291, -1291, -1291, -1291, 1273, -1291, -1291, -1291, -1291, + -1291, 11409, 11409, 1275, 1276, 1239, -1291, -1291, 892, -1291, + -1291, -1291, 7753, 10576, 11181, 11181, 1287, 11181, -1291, -1291, + 1260, -1291, 1263, 11181, 1264, 1266, 11181, 938, -1291, 1268, + 6675, 115, -1291, -1291, 6285, 1229, 542, -1291, -1291, -1291, + -1291, -1291, 925, -1291, 9440, 8846, 5469, 1285, -1291, 1289, + -1291, -1291, 925, 10967, -1291, 8339, 1295, -1291, -1291, 10576, + 548, 582, -1291, 1291, 1297, -1291, 219, -1291, 11181, 1298, + 1299, -1291, -1291, 1301, 98, 168, 778, 1303, 1305, -1291, + 1306, -1291, 10759, -1291, -1291, -1291, -1291, -1291, -1291, 1309, + -1291, -1291, -1291, 10759, 10759, 10759, -1291, -1291, 1311, -1291, + 1315, 1318, 1322, 507, -1291, 8058, 8166, -1291, -1291, 689, + -1291, 1321, 1325, -1291, 8469, 767, 776, 1329, 779, 6439, + -1291, -1291, 609, -1291, -1291, 784, 1330, 239, 1371, 1379, + -1291, -1291, 1332, 11124, -1291, -1291, -1291, 1336, 1337, 808, + 9750, 5469, 9508, 10759, -1291, -1291, -1291, 1328, -1291, -1291, + -1291, -1291, -1291, -1291, 10576, -1291, 1316, 1368, 1172, 97, + -1291, -1291, -1291, -1291, -1291, -1291, -1291, -1291, 1342, -1291, + -1291, -1291, 1343, 1350, -1291, -1291, -1291, 1352, 1355, -1291, + -1291, -1291, -1291, -1291, -1291, -1291, 1361, -1291, 1362, -1291, + -1291, 11124, 118, 11181, 11124, -1291, 1365, 11181, -1291, 186, + 1382, -1291, -1291, 1353, 9270, -1291, -1291, -1291, 497, -1291, + 9809, -1291, -1291, 1646, 1212, 1369, -1291, -1291, 825, 1364, + 11181, 778, 778, 1377, -1291, -1291, 1378, 1380, 1384, -1291, + -1291, 8404, 1381, -1291, 1447, 11409, 1383, -1291, -1291, 11044, + -1291, 837, -1291, 1366, 11124, 1373, -1291, -1291, 1396, -1291, + 1406, 5469, 1394, -1291, 1397, 10576, -1291, -1291, -1291, 1386, + 1426, 1399, -1291, 1239, 1239, -1291, -1291, -1291, -1291, -1291, + 11124, 240, -1291, 900, -1291, -1291, 4527, -1291, -1291, 1387, + 11181, -1291, 11181, 4527, 239, 10399, 1401, -1291, 9868, 5469, + -1291, 1405, -1291, -1291, 11181, 1402, 1412, -1291, 11409, 11409, + -1291, -1291, 990, 130, -1291, -1291, 1404, -1291, 990, -1291, + -1291, 1855, 778, 239, 10399, -1291, 9927, 1424, -1291, -1291, + -1291, -1291, -1291, 11044, 1419, 990, 7686, 11181, 10964, 1422, + 990, 1431, 1855, 2409, -1291, -1291, -1291, -1291, -1291, -1291, + 8846, -1291, 10846, -1291, 11044, -1291, -1291, 1410, 10765, -1291, + -1291, 10964, 239, 2409, 1440, 850, -1291, 10846, -1291, -1291, + -1291, 10765, -1291, -1291, 239, -1291, -1291, -1291, -1291, -1291 +}; + +/* YYPGOTO[NTERM-NUM]. */ +static const yytype_int16 yypgoto[] = +{ + -1291, 4245, 3306, -1291, 1116, -1291, -1, 2, 896, -1291, + -1291, -1291, -495, -897, -137, 5431, -1291, 913, 541, 551, + 480, 578, 1002, 1004, 1001, 1005, 1006, -1291, 40, -196, + 5036, 426, -670, -935, -1291, 410, -536, 405, -1291, 215, + -1291, 338, -1139, -1291, -1291, 76, -1291, -1286, -974, 178, + -1291, -1291, -1291, -1291, 21, -1264, -1291, -1291, -1291, -1291, + -1291, -1291, 251, 72, 70, 452, -1291, 461, -1291, 108, + -1291, -221, -1291, -1291, -1291, 510, -756, -1291, -1291, 0, + -911, 123, 2941, -1291, -1291, -1291, -4, -1291, 104, 656, + -23, 1441, 3190, -1291, -1291, 57, 83, 545, -242, 1645, + -1291, 1583, -1291, -1291, 105, 2213, -1291, 2417, 430, -1291, + -1291, -424, -392, 1159, 1162, 665, 908, 386, -1291, -1291, + 1151, 667, -582, -1291, -560, 393, -622, -1291, -1291, -913, + -944, -339, 625, 1039, -8, -1291, 220, 304, -284, -197, + -141, 644, 727, -1291, 986, -1291, 2799, -407, 895, -1291, + -1291, 677, -1291, -399, -1291, -84, -1291, -1291, -1291, -1255, + 388, -1291, -1291, -1291, 1154, -1291, 85, -1291, -1291, -787, + -102, -1290, -38, 1983, -1291, 2958, -1291, 894, -1291, -164, + 127, -169, -166, -161, 4, -37, -35, -34, 791, 51, + 55, 59, -101, -155, -153, -140, -138, -299, -486, -465, + -454, -533, -1291, -528, -1291, -1291, -539, -526, -507, -477, + 1502, 4608, -529, -535, -530, -514, -525, -1291, -360, -646, + -641, -638, -576, -285, -303, -1291, -1291, 1288, 18, -86, + -1291, 339, 120, -577, -382 +}; + +/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule which + number is the opposite. If YYTABLE_NINF, syntax error. */ +#define YYTABLE_NINF -505 +static const yytype_int16 yytable[] = +{ + 107, 108, 44, 143, 92, 144, 145, 378, 255, 138, + 379, 658, 418, 386, 248, 380, 791, 692, 101, 101, + 363, 381, 759, 382, 667, 484, 911, 842, 787, 891, + 587, 912, 668, 44, 913, 92, 383, 858, 384, 577, + 1126, 611, 44, 686, 44, 615, 154, 788, 818, 101, + 867, 876, 824, 819, 44, 817, 825, 64, 856, 856, + 44, 828, 184, 44, 209, 206, 44, 835, 216, 820, + 45, 725, 492, 856, 681, 730, 387, 789, 1174, 1395, + 30, 970, 101, 65, 378, 1134, 1070, 379, 64, 404, + 386, 146, 380, 249, 723, 147, 250, 814, 381, 148, + 382, 45, 911, 44, 58, 72, 44, 912, 1172, 1173, + 913, 702, 44, 383, 65, 384, 137, 1069, 815, 105, + 928, 654, 656, 51, 109, 1454, 192, 91, 935, 816, + 105, 1191, 550, 1458, 425, 58, 72, 116, 1185, 143, + 389, 144, 145, 44, 203, 154, 390, 750, 240, 316, + 856, 446, 30, 387, 51, 44, 105, 353, 91, 30, + 1415, 1416, 159, 105, 985, 1203, 551, 142, 755, 91, + 193, 407, -218, -218, 990, 720, 650, 105, 44, 44, + 1471, 154, 30, 714, 201, 180, 161, 210, 91, 1454, + 1004, 91, 648, 44, 761, 661, 729, 952, 388, -109, + 417, 1342, 44, 665, 154, 829, 1400, 105, 30, 832, + 44, 461, 463, 44, 742, 421, 143, 1458, 144, 145, + -109, 645, 1458, 240, 1417, 390, 159, 146, 1415, 1416, + 849, 147, 814, 105, 852, 148, 1199, -218, 1458, 451, + 457, 44, 462, 92, 1529, 1458, 398, 117, 390, 135, + 513, 989, 469, 815, 734, 44, 44, 101, 154, 486, + 314, 735, 44, 462, 816, 165, 1201, 1542, 91, 44, + 677, 1344, 467, 637, 390, 1117, 818, 1077, 795, 502, + 91, 819, 1118, 1003, 646, 552, 1190, 577, 828, 1016, + 30, 1174, 1426, 1017, 420, 30, 64, 820, 230, 232, + 686, 652, 645, 377, 180, 1254, 657, 241, 491, 45, + 1181, 851, 702, 1338, 1136, 536, 537, 44, 577, 353, + 414, 1336, 65, 577, 449, 814, 136, 91, 1337, 1478, + 44, 44, 1255, 679, 419, 140, 1182, 612, 91, 104, + 104, 616, 1174, 58, 72, 163, 815, 44, 458, 72, + 105, 44, 133, 134, 826, 1182, 584, 816, 357, 833, + 173, 584, 51, 191, 791, 646, 91, 720, 366, 1528, + 104, 34, 1172, 1173, 358, 37, 787, 44, 369, 414, + 465, 158, 38, 39, 367, 1537, 714, 44, 1191, 353, + 235, 231, 1541, 457, 370, 788, 1169, 1170, 371, 396, + 208, 818, -275, 104, 159, 44, 819, 811, 825, 584, + 44, 845, 457, 203, 372, 846, 814, 585, 842, 373, + 457, 415, 820, 687, 689, 789, 105, 1070, 133, 134, + 105, 423, 133, 134, 847, 374, 44, 815, 848, 688, + 690, 1175, 91, 900, 579, 158, 240, 702, 816, 687, + 260, 443, 107, 1219, 1220, 561, 586, 702, 1069, 714, + 44, 562, 1020, 856, 863, 906, 228, 1174, 44, 238, + 353, 229, 44, 702, 92, 533, 44, 914, 847, 158, + 534, 535, 1101, 1159, 1161, 1132, -500, 868, 101, 704, + 484, 205, 355, 689, 809, 705, 506, 739, 1449, 927, + 252, 458, 72, 378, 1443, 1444, 379, -10, 1503, 907, + 386, 380, 180, 756, 1508, 1205, 739, 381, 762, 382, + 458, 72, 479, 1015, 480, 314, 314, 64, 458, 72, + 314, 1524, 383, 878, 384, 563, 1531, 390, 1105, 158, + 45, 205, 203, 1377, 989, 1191, 1250, 554, 1113, 390, + 208, 314, 1191, 65, -102, 1091, -427, 555, -102, -428, + 1102, 678, 105, 681, 133, 134, 451, 264, 440, 1270, + 1271, 1017, 711, 387, 58, 72, 266, 34, 104, 1081, + 625, 37, 44, 205, 748, 44, 390, 44, 38, 39, + 355, 856, 856, 51, 749, 1191, 844, 91, 158, 880, + 314, 586, 105, 1431, 133, 134, 44, 1091, 317, 1188, + 219, 1363, 859, 318, 220, 1364, 267, 224, 314, 226, + 440, -276, 44, 158, 875, 1189, 233, 801, 8, 9, + 10, 11, 12, 877, 44, 879, 663, 44, 726, 268, + 1350, 205, 1015, 727, 2, 196, 4, 5, 6, 7, + 1188, 1354, 1355, 1356, 319, 30, 1329, 110, 320, 691, + 457, 321, 1028, 578, 443, -109, 1316, -109, 44, 604, + 706, -109, 1330, 567, 44, 390, 44, 205, 33, 702, + 702, 205, 314, 1074, 538, 539, -109, -109, 420, 1144, + 1331, 505, 579, 322, 540, 541, 721, 724, 152, 728, + 1484, 1391, 722, 932, 931, 352, 1332, 1484, 506, 577, + 813, 506, 586, 491, 506, 356, 105, 746, 133, 134, + 44, 44, 1002, 843, 486, 1036, 731, 364, 579, 542, + 543, -277, 732, 1378, 44, 491, 702, 702, 8, 9, + 10, 11, 12, 34, 158, 158, 368, 37, 219, 158, + 1525, 645, 1225, 376, 38, 39, 246, 1226, 388, 677, + 205, 405, 152, 1375, -3, 30, 745, 809, 458, 72, + 158, 440, 746, 406, 440, 711, 936, 410, 584, 40, + 440, 203, 544, 545, 1015, 869, 937, 624, 33, 141, + 428, 870, -452, 586, -452, 203, 310, 736, -452, 910, + 737, 678, 1320, 743, 892, 441, 881, 715, 390, 104, + 746, 458, 72, 44, 646, 653, 655, 34, 884, 158, + 390, 37, 679, 983, 44, 894, 1319, 444, 38, 39, + 447, 746, 440, 155, 448, 440, 896, 158, 440, 205, + 1265, 1425, 562, 105, 864, 813, 586, 1144, 711, 185, + 470, 408, 207, 718, 498, 217, 412, 513, 979, 801, + 714, 713, 991, 719, 980, 890, 911, 1242, 705, 1371, + 546, 912, 1056, 562, 913, 746, 899, 219, 1372, 224, + 901, 1374, 547, 203, 746, 434, 1379, 746, 809, 205, + 548, 101, 746, 1138, 1325, 390, 1186, 1390, 746, 984, + 44, 158, 1031, 505, 44, 44, 505, 922, 549, 505, + 1388, 578, 552, 925, 804, 412, 562, 44, 474, 565, + 1244, 1144, 580, 702, 1486, 44, 1487, 1439, 686, 1155, + 64, 390, 155, 1440, 702, 702, 702, 507, 813, 1459, + 152, 638, 578, 44, 354, 746, 1106, 578, 639, 586, + 714, 34, 1545, 175, 801, 37, 65, 105, 562, 133, + 134, 784, 38, 39, 101, 219, 640, 1158, 155, 584, + 123, 1526, 124, 125, 126, 642, 1128, 58, 72, 739, + 574, 1128, 316, 390, 702, 1287, 1288, 176, 1160, 1163, + 584, 155, 1306, 1307, 44, 643, 51, 177, 686, 644, + 609, 809, 422, 647, 613, 205, 1237, 1468, 1479, 1480, + 715, 857, 857, 2, 196, 4, 5, 6, 7, 1144, + 772, 773, 774, 775, 1135, 1230, 857, 390, 245, 813, + 586, 440, 1415, 1416, 1128, 205, 809, 240, 316, 390, + 205, 218, 678, 693, 1056, 1496, 695, 1200, 1202, 1204, + 678, 938, 398, 641, 390, 8, 9, 10, 11, 12, + 101, 310, 310, 918, 713, 918, 310, 314, 586, 1107, + -222, 514, 515, 516, 733, 703, 686, 768, 769, 1031, + 420, 747, 30, 715, 751, 44, 625, 666, 434, 770, + 771, 434, 1041, 803, 517, 810, 518, 434, 519, 1193, + 467, 316, 390, 857, 686, 33, 354, 853, 866, 110, + 44, 826, 316, 584, 843, 1082, -12, 1343, 1345, 1346, + 865, 1535, 776, 777, 872, 65, 277, 893, 205, 895, + 898, 1515, 722, -401, 474, 926, 310, 713, 474, 604, + 562, -504, 205, 801, 673, 940, 458, 72, 947, 507, + 949, 954, 507, 953, 310, 507, 491, 8, 9, 10, + 11, 12, 958, 959, 961, 51, 962, 963, 168, 964, + -278, 975, 974, 1091, 986, 987, 354, 8, 9, 10, + 11, 12, 988, 495, 30, 992, 999, 34, 625, 175, + 1000, 37, 1005, 209, 1006, 1007, 511, 512, 38, 39, + 1008, 1009, 1010, 1011, 30, -389, -388, 33, 532, 1029, + 586, 101, 104, 1056, 1038, 1071, 1078, 168, 310, 1451, + 168, 491, 491, 672, 1087, 390, 44, 33, 574, 1073, + 205, 673, 101, 674, 1084, 1085, 807, 512, 1088, 1106, + 8, 9, 10, 11, 12, 1089, 1090, 1094, 554, 711, + 390, 1095, 1104, 1128, 1128, 1128, 1096, 101, 555, 841, + 1097, 1098, 1114, 746, 574, 1115, 1116, 30, 1207, 1119, + 850, 64, 968, 1122, 512, 203, 703, 34, 1058, 175, + 1124, 37, 1501, 1451, 1127, 104, 158, 1150, 38, 39, + 33, 1041, 1437, 1153, 1164, 34, 1176, 65, 809, 37, + 1177, 1178, 1179, 1180, 1227, 1228, 38, 39, 1194, 1195, + 1197, 1198, 1056, 253, 1206, 201, 210, 101, 58, 72, + 1211, 1212, -3, 254, 168, 1217, 1223, 479, 1234, 1224, + 156, 40, 1297, 578, 1106, 1238, 1315, 51, 1243, 711, + 1245, 141, 1248, 378, 1252, 314, 379, 1256, 434, 386, + 1259, 380, 101, 1261, 1263, 1272, 1193, 381, 1266, 382, + 1267, 1268, 1107, 2, 196, 4, 5, 6, 7, 645, + 1056, 1279, 383, 1056, 384, 1284, 168, 420, 474, 1289, + 1290, 104, 65, 168, 1300, 1436, 44, 1301, 1303, 1514, + 1304, 1321, 1311, 1322, 156, 44, 44, 1327, 1333, 1335, + 1128, 1128, 1339, 458, 72, 1341, 1340, 1347, 1293, 1348, + 1349, 703, 387, 1351, 1171, 1359, 857, 419, 1056, 1360, + 1361, 703, 51, 1056, 1362, 1369, 1307, 205, 313, 1370, + 1373, 1380, 646, 1383, 1392, 1106, 1384, 703, 1386, 1387, + 1396, 61, 111, 1397, 168, 1404, 765, 766, 767, 1056, + 1196, 1400, 1405, 101, 1430, 491, 1409, 1107, 34, 1410, + 582, 168, 37, -390, 1001, 168, 1413, 1424, 1441, 38, + 39, 1428, 61, 139, 101, 143, 1438, 144, 145, 1445, + 1446, 101, 1447, 153, 715, 512, 1448, 1450, 413, 1364, + 1460, 1516, 1455, 44, 583, 1466, 584, 1462, 1464, 1470, + 1469, 1473, 1056, 1493, 585, 211, 1499, 1056, 1474, 807, + 1472, 1485, 1497, 1193, 44, 44, 1500, 154, 491, 491, + 1193, 1056, 1381, 1056, 101, 1520, 1523, 1056, 1507, 1530, + 1056, 208, 104, 1532, 1538, 44, 1056, 353, 713, 65, + 1056, 247, 1544, 887, 857, 857, 65, 413, 778, 780, + 1251, 779, 1314, 104, 781, 1502, 782, 1427, 1107, 1382, + 458, 72, 1546, 1193, 158, 440, 1518, 458, 72, 509, + 1246, 1488, 156, 34, 715, 166, 167, 37, 104, 51, + 1247, 1216, 315, 70, 38, 39, 51, 919, 1092, 65, + 330, 669, 1093, 1037, 670, 697, 8, 9, 10, 11, + 12, 474, 1108, 310, 1295, 1296, 798, 1298, 1432, 352, + 458, 72, 1123, 1302, 70, 871, 1305, 942, 385, 1058, + 1103, 512, 205, 30, 716, 0, 950, 1328, 0, 51, + 807, 0, 403, 208, 0, 139, 409, 0, 104, 465, + 314, 153, 0, 703, 703, 34, 33, 212, 1142, 37, + 841, 34, 0, 175, 0, 37, 38, 39, 0, 440, + 440, 426, 38, 39, 969, 429, 0, 430, 0, 0, + 0, 0, 0, 104, 445, 0, 0, 0, 1366, 1489, + 61, 902, 392, 390, 0, 459, 0, 176, 0, 400, + 0, 903, 0, 313, 313, 466, 806, 177, 313, 0, + 703, 703, 0, 409, 0, 0, 204, 0, 1517, 0, + 0, 34, 0, 166, 167, 37, 222, 0, 1385, 313, + 168, 0, 38, 39, 205, 0, 0, 0, 0, 440, + 0, 0, 333, 0, 0, 0, 168, 0, 0, 0, + 0, 0, 0, 807, 0, 0, 0, 1543, 168, 0, + 8, 9, 10, 11, 12, 0, 204, 0, 392, 1548, + 0, 0, 0, 0, 0, 575, 0, 0, 313, 0, + 440, 0, 605, 0, 104, 0, 1414, 30, 807, 1422, + 0, 509, 0, 1421, 509, 610, 313, 509, 0, 610, + 0, 0, 330, 0, 0, 104, 0, 0, 204, 1264, + 33, 512, 104, 427, 440, 34, 1142, 440, 440, 37, + 0, 0, 560, 0, 0, 0, 38, 39, 0, 0, + 564, 0, 70, 568, 1457, 0, 0, 70, 34, 1461, + 175, 0, 37, 440, 0, 440, 0, 0, 459, 38, + 39, 902, 0, 390, 0, 104, 0, 0, 168, 0, + 313, 903, 330, 0, 0, 1477, 204, 459, 1326, 158, + 0, 0, 0, 0, 672, 459, 390, 0, 0, 0, + 0, 0, 0, 0, 674, 0, 0, 0, 0, 392, + 1142, 310, 434, 400, 0, 0, 0, 703, 0, 0, + 0, 698, 204, 0, 409, 1108, 204, 0, 703, 703, + 703, 0, 8, 9, 10, 11, 12, 512, 0, 712, + 0, 61, 485, 0, 212, 0, 0, 0, 0, 409, + 34, 0, 175, 409, 37, 0, 0, 1536, 0, 30, + 0, 38, 39, 1536, 333, 0, 8, 9, 10, 11, + 12, 0, 1536, 0, 0, 0, 1536, 0, 703, 0, + 0, 330, 33, 0, 0, 495, 1512, 34, 390, 582, + 0, 37, 0, 30, 0, 0, 1513, 392, 38, 39, + 34, 0, 166, 167, 37, 204, 434, 434, 1142, 0, + 70, 38, 39, 0, 0, 0, 33, 0, 0, 0, + 1108, 0, 0, 583, 333, 584, 790, 0, 0, 70, + 0, 0, 0, 585, 0, 0, 356, 70, 118, 121, + 122, 800, 0, 575, 806, 0, 0, 0, 0, 0, + 0, 247, 0, 0, 0, 0, 822, 748, 0, 390, + 0, 0, 0, 333, 0, 0, 0, 749, 0, 0, + 807, 0, 0, 0, 575, 0, 434, 0, 0, 575, + 0, 333, 0, 70, 204, 610, 560, 560, 0, 330, + 330, 0, 0, 8, 9, 10, 11, 12, 0, 0, + 0, 204, 0, 0, 330, 0, 242, 0, 243, 512, + 0, 0, 0, 0, 0, 0, 0, 434, 0, 0, + 30, 1108, 698, 333, 520, 521, 522, 523, 524, 525, + 526, 527, 528, 529, 204, 459, 0, 0, 806, 0, + 0, 0, 712, 33, 0, 915, 0, 0, 34, 0, + 175, 1491, 37, 0, 434, 434, 0, 530, 0, 38, + 39, 0, 8, 9, 10, 11, 12, 0, 0, 0, + 882, 0, 0, 0, 885, 0, 0, 0, 459, 0, + 1491, 330, 434, 333, 253, 0, 375, 0, 0, 30, + 941, 0, 0, 409, 254, 394, 395, 0, 560, 0, + 399, 0, 401, 402, 0, 0, 310, 0, 0, 0, + 392, 0, 33, 0, 0, 712, 0, 34, 0, 175, + 967, 37, 0, 0, 0, 0, 0, 0, 38, 39, + 0, 333, 333, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 73, 0, 0, 333, 0, 0, 0, + 204, 0, 0, 672, 0, 390, 0, 698, 0, 0, + 0, 0, 0, 674, 333, 313, 0, 698, 0, 0, + 0, 0, 997, 800, 73, 0, 0, 70, 0, 247, + 204, 0, 0, 698, 333, 204, 0, 0, 0, 0, + 0, 0, 1014, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 213, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 70, 0, 560, 333, 247, 0, 0, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 61, 0, 25, 26, 27, 0, + 0, 0, 0, 0, 30, 0, 0, 333, 0, 0, + 0, 0, 0, 8, 9, 10, 11, 12, 800, 0, + 806, 0, 0, 204, 1083, 0, 0, 33, 0, 0, + 0, 0, 34, 0, 35, 36, 37, 204, 0, 0, + 30, 0, 335, 38, 39, 0, 0, 0, 0, 333, + 0, 0, 0, 0, 0, 0, 0, 485, 1100, 333, + 0, 0, 0, 33, 212, 333, 409, 111, 40, 0, + 150, 0, 0, 0, 0, 333, 0, 0, 42, 0, + 0, 330, 0, 0, 560, 560, 0, 0, 0, 0, + 0, 0, 392, 0, 0, 247, 0, 75, 0, 8, + 9, 10, 11, 12, 936, 0, 584, 0, 0, 0, + 0, 0, 0, 610, 937, 575, 0, 0, 0, 8, + 9, 10, 11, 12, 0, 204, 30, 0, 75, 0, + 0, 0, 73, 139, 0, 0, 70, 73, 0, 698, + 698, 0, 330, 330, 330, 0, 30, 0, 0, 33, + 0, 0, 0, 0, 34, 0, 175, 0, 37, 0, + 333, 214, 0, 1192, 0, 38, 39, 0, 1139, 33, + 0, 0, 0, 0, 34, 0, 0, 0, 37, 0, + 806, 0, 0, 0, 0, 38, 39, 1156, 0, 168, + 1512, 0, 390, 313, 0, 0, 698, 698, 0, 0, + 1513, 0, 0, 0, 0, 0, 0, 800, 247, 0, + 718, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 719, 792, 793, 333, 213, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 247, 335, 0, 336, 0, 0, 827, + 0, 0, 830, 831, 0, 834, 0, 836, 837, 0, + 0, 0, 838, 839, 610, 560, 712, 0, 0, 0, + 1231, 610, 330, 330, 0, 0, 0, 0, 0, 0, + 0, 333, 333, 0, 333, 333, 333, 0, 0, 0, + 73, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 335, 70, 0, 0, 0, 73, + 0, 0, 0, 0, 1294, 0, 0, 73, 0, 0, + 0, 0, 204, 0, 0, 0, 0, 0, 0, 0, + 0, 330, 0, 0, 0, 61, 75, 0, 333, 333, + 0, 75, 0, 335, 0, 610, 920, 921, 0, 333, + 0, 0, 923, 0, 698, 0, 712, 0, 0, 0, + 111, 335, 0, 73, 0, 0, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 698, 0, 25, 26, 27, 0, 0, + 0, 0, 0, 30, 698, 698, 698, 0, 0, 0, + 0, 0, 0, 335, 0, 0, 330, 330, 333, 0, + 0, 0, 0, 0, 333, 333, 33, 0, 0, 0, + 1192, 105, 0, 35, 36, 0, 0, 0, 214, 0, + 0, 0, 0, 1492, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 610, 698, 0, 0, 0, 336, 0, + 0, 0, 0, 0, 0, 111, 212, 0, 0, 41, + 0, 0, 1492, 335, 0, 0, 0, 106, 0, 0, + 0, 0, 0, 333, 0, 0, 0, 70, 0, 82, + 0, 0, 0, 0, 0, 0, 0, 0, 313, 0, + 0, 0, 0, 0, 75, 0, 333, 0, 333, 0, + 0, 0, 0, 0, 0, 247, 0, 0, 336, 0, + 82, 335, 335, 75, 0, 0, 0, 204, 0, 0, + 0, 75, 0, 0, 0, 333, 335, 0, 0, 0, + 0, 0, 330, 0, 0, 0, 333, 333, 333, 0, + 0, 0, 0, 215, 335, 0, 0, 336, 333, 333, + 0, 0, 0, 0, 0, 0, 111, 73, 0, 0, + 0, 0, 70, 0, 335, 336, 0, 75, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1192, 0, 0, + 0, 0, 0, 0, 1192, 0, 333, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 73, 0, 0, 335, 0, 0, 0, 336, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 204, + 0, 52, 52, 0, 0, 0, 0, 1192, 343, 0, + 0, 0, 0, 0, 1533, 0, 0, 335, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 52, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 120, 120, 120, 0, 336, 0, 0, + 0, 0, 0, 0, 333, 0, 0, 0, 0, 335, + 0, 0, 52, 0, 0, 52, 0, 0, 0, 335, + 0, 0, 0, 0, 213, 335, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 335, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 336, 336, 0, 82, 70, + 0, 0, 0, 82, 0, 0, 70, 0, 0, 0, + 336, 120, 0, 120, 0, 0, 0, 0, 0, 0, + 1221, 0, 0, 0, 0, 0, 0, 0, 336, 0, + 0, 0, 0, 0, 0, 0, 0, 263, 0, 0, + 0, 75, 0, 0, 0, 0, 73, 0, 336, 70, + 328, 0, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, -279, + 335, 0, 0, 0, 0, 0, 0, 0, 0, 30, + 0, 0, 0, 0, 75, 0, 0, 336, 0, 0, + 215, 120, 0, 0, 0, 0, 0, 0, 120, 0, + 120, 120, 33, 0, 0, 120, 0, 120, 120, 0, + 343, 0, 52, -279, 0, 0, 0, 0, 0, 0, + 0, 336, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 335, 0, 0, 0, 0, 0, 0, + 52, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1313, 0, 82, 0, 0, 0, + 0, 0, 0, 336, 0, 0, 0, 0, 0, 0, + 343, 0, 0, 336, 120, 82, 0, 0, 214, 336, + 0, 0, 0, 82, 0, 0, 0, 0, 0, 336, + 0, 335, 335, 0, 335, 335, 335, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 343, + 0, 202, 0, 0, 0, 73, 0, 0, 0, 0, + 0, 221, 0, 225, 0, 227, 0, 343, 0, 82, + 0, 0, 234, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 335, 335, + 75, 0, 328, 0, 0, 0, 0, 0, 0, 335, + 0, 202, 0, 225, 227, 234, 0, 0, 0, 343, + 0, 0, 0, 0, 336, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 202, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 202, 0, 0, 0, 0, 0, 0, + 0, 0, 328, 0, 160, 0, 164, 0, 335, 170, + 171, 172, 0, 174, 335, 335, 0, 0, 0, 343, + 0, 0, 0, 0, 0, 0, 0, 336, 223, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 236, + 237, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 202, 0, 225, 227, 234, 213, 0, 0, 0, + 0, 52, 0, 0, 0, 0, 0, 343, 343, 0, + 0, 0, 0, 335, 0, 0, 0, 73, 0, 0, + 0, 0, 343, 0, 0, 336, 336, 202, 336, 336, + 336, 202, 0, 0, 0, 0, 335, 0, 335, 0, + 343, 328, 0, 0, 0, 325, 0, 483, 0, 75, + 0, 0, 0, 82, 0, 0, 0, 0, 0, 0, + 343, 0, 0, 0, 0, 335, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 335, 335, 335, 0, + 0, 0, 336, 336, 0, 0, 0, 0, 335, 335, + 0, 0, 0, 336, 0, 202, 82, 0, 0, 343, + 0, 328, 73, 0, 0, 0, 120, 120, 0, 0, + 202, 0, 0, 0, 0, 225, 227, 0, 0, 0, + 0, 0, 0, 234, 0, 0, 335, 0, 0, 0, + 0, 0, 0, 343, 120, 0, 0, 120, 120, 0, + 120, 0, 120, 120, 0, 0, 0, 120, 120, 328, + 328, 0, 336, 0, 0, 0, 0, 0, 336, 336, + 0, 0, 0, 0, 328, 202, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 343, 0, 0, 0, 0, + 0, 0, 0, 202, 0, 343, 0, 0, 0, 202, + 215, 343, 0, 0, 0, 0, 0, 0, 0, 0, + 214, 343, 0, 0, 0, 0, 202, 0, 0, 202, + 202, 0, 0, 0, 335, 0, 0, 336, 0, 0, + 573, 75, 581, 0, 0, 202, 120, 0, 0, 0, + 0, 120, 120, 606, 607, 0, 0, 120, 0, 202, + 336, 328, 336, 0, 0, 0, 202, 617, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 73, + 0, 269, 82, 270, 0, 0, 73, 0, 0, 336, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 336, 336, 336, 0, 271, 0, 343, 0, 0, 0, + 272, 0, 336, 336, 273, 0, 0, 274, 275, 276, + 277, 38, 39, 0, 278, 279, 75, 660, 0, 73, + 0, 0, 280, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 281, 0, 359, 0, + 336, 360, 0, 328, 0, 283, 361, 285, 286, 287, + 288, 0, 0, 0, 0, 0, 0, 0, 0, 343, + 0, 0, 0, 0, 0, 202, 0, -499, 0, 0, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 0, 202, 25, 26, 27, 28, + 202, 0, 29, 0, 30, 31, 0, 0, 0, 0, + 0, 0, 0, 0, 52, 0, 753, 343, 343, 0, + 343, 343, 343, 0, 32, 0, 0, 33, 336, 0, + 0, 0, 34, 0, 35, 36, 37, 0, 328, 0, + 0, 82, 0, 38, 39, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, -280, 0, 0, 0, 0, 0, 40, 0, + 41, 0, 30, 75, 343, 343, 799, 0, 42, 0, + 75, 0, 0, 0, 0, 343, 0, 52, 202, 0, + 0, 0, 269, 0, 270, 33, 0, 0, 0, 0, + 0, 328, 202, 0, 0, 0, -280, 0, 0, 0, + 0, 0, 0, 0, 0, 271, 0, 0, 0, 0, + 0, 272, 483, 75, 0, 273, 0, 860, 274, 275, + 276, 277, 38, 39, 0, 278, 279, 0, 0, 0, + 0, 0, 0, 280, 343, 0, 0, 0, 0, 0, + 343, 343, 0, 0, 0, 889, 0, 281, 0, 359, + 0, 0, 328, 328, 328, 783, 283, 361, 285, 286, + 287, 288, 0, 904, 905, 0, 0, 909, 0, 0, + 202, 0, 0, 52, 0, 0, 0, 0, 0, 0, + 202, 0, 215, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 929, 0, 930, 0, 343, + 0, 0, 202, 82, 933, 934, 0, 0, 0, 939, + 0, 0, 0, 0, 0, 0, 0, 328, 0, 0, + 0, 944, 343, 0, 343, 120, 948, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 965, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 976, 343, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 343, 343, 343, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 343, 343, 0, 0, 0, 0, + 0, 0, 328, 328, 0, 0, 0, 0, 82, 0, + 0, 0, 0, 0, 0, 202, 0, 0, 998, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 343, 0, 0, 0, 0, 1013, 0, 0, + 0, 202, 0, 52, 52, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 328, 0, 0, 0, 52, 0, 202, 0, 0, + 1024, 0, 1025, 1026, 1027, 0, 0, 1030, 860, 120, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 52, 0, 1072, 0, 0, 0, 0, 202, 0, 0, + 0, 0, 0, 0, 573, 0, 0, 1079, 0, 0, + 0, 0, 0, 1080, 202, 0, 0, 0, 0, 0, + 343, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 328, 328, 0, 0, + 0, 0, 0, 0, 0, 52, 0, 0, 0, 0, + 52, 1099, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 82, 0, 0, 0, 0, + 0, 0, 82, 0, 0, 0, 753, 0, 0, 0, + 0, 0, 0, 202, 0, 52, 0, 0, 0, 1125, + 0, 0, 0, 0, 860, 0, 149, 1133, 0, 0, + 202, 1137, 0, 0, 0, 0, 1141, 0, 0, 0, + 1146, 1147, 1148, 0, 0, 82, 0, 0, 0, 0, + 1154, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1167, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 239, 0, 0, 0, 0, 0, 0, 0, 1183, + 1184, 244, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 328, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1213, 0, 0, 1215, 0, 0, + 0, 0, 0, 0, 0, 0, 52, 0, 0, 0, + 0, 0, 202, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1229, 0, 0, 351, 0, 52, 0, 0, + 0, 0, 0, 0, 52, 0, 0, 0, 365, 0, + 0, 1236, 0, 0, 0, 0, 0, 1240, 1241, 0, + 0, 0, 0, 0, 0, 0, 1249, 0, 0, 0, + 397, 0, 1253, 0, 0, 1257, 0, 1258, 0, 0, + 1260, 0, 0, 0, 411, 0, 0, 52, 0, 0, + 0, 860, 416, 0, 0, 1269, 0, 0, 0, 0, + 0, 0, 424, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1278, 431, 1280, 1281, 1282, 1283, 0, 0, + 0, 0, 0, 0, 202, 450, 0, 0, 0, 0, + 460, 1291, 0, 1292, 0, 0, 0, 164, 0, 0, + 0, 0, 0, 468, 0, 0, 0, 0, 0, 478, + 0, 482, 0, 0, 0, 0, 1312, 0, 0, 0, + 0, 0, 0, 0, 0, 1317, 1318, 510, 0, 0, + 1, 2, 196, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, -279, 0, 25, 26, 27, 28, + 0, 0, 29, 0, 30, 0, 0, 0, 570, 0, + 0, 0, 0, 0, 0, 0, 1352, 1353, 0, 0, + 0, 0, 1357, 1358, 0, 0, 0, 33, 0, 0, + 0, 0, 0, 1368, 35, 36, 0, 618, -279, 0, + 0, 619, 620, 0, 621, 0, 0, 0, 0, 0, + 631, 632, 0, 633, 634, 0, 635, 0, 636, 0, + 0, 0, 1012, 0, 0, 8, 9, 10, 11, 12, + 41, 0, 0, 0, 0, 649, 0, 0, 106, 0, + 0, 0, 0, 651, 1399, 0, 0, 0, 0, 0, + 0, 269, 30, 270, 0, 0, 1403, 0, 0, 0, + 1406, 1407, 1408, 0, 0, 0, 0, 664, 0, 0, + 0, 0, 1412, 0, 271, 33, 0, 0, 671, 0, + 272, 1423, 0, 0, 273, 0, 0, 274, 275, 276, + 277, 38, 39, 0, 278, 279, 0, 1434, 0, 0, + 0, 707, 280, 0, 0, 0, 0, 710, 0, 0, + 0, 0, 450, 0, 0, 0, 281, 0, 359, 0, + 0, 0, 0, 202, 0, 283, 888, 285, 286, 287, + 288, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 744, 1475, + 1476, 0, 0, 0, 0, 0, 0, 344, 0, 0, + 0, 0, 1481, 760, 0, 0, 0, 0, 0, 1481, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, -279, 393, 25, + 26, 27, 0, 0, 0, 393, 1511, 30, 0, 786, + 0, 0, 0, 0, 0, 0, 0, 0, 796, 0, + 797, 0, 0, 0, 0, 0, 802, 0, 0, 0, + 33, 0, 0, 0, 1534, 0, 0, 35, 36, 821, + 0, -279, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1547, + 0, 0, 0, 0, 1549, 0, 0, 0, 0, 0, + 0, 1023, 0, 565, 393, 0, 0, 0, 862, 0, + 0, 106, 0, 0, 0, 0, 0, 0, 0, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 0, 897, 25, 26, 27, 28, 0, + 0, 29, 0, 30, 31, 0, 0, 0, 393, 0, + 0, 0, 0, 0, 0, 0, 393, 566, 0, 393, + 569, 0, 344, 32, 0, 0, 33, 596, 0, 0, + 0, 34, 0, 35, 36, 37, 0, 0, 0, 0, + 0, 0, 38, 39, 0, 0, 614, 0, 0, 344, + 0, 239, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 945, 946, 0, 0, 0, 0, 40, 0, 41, + 0, 0, 0, 960, 0, 393, 0, 42, 0, 393, + 0, 0, 1165, 0, 0, 8, 9, 10, 11, 12, + 977, 0, 978, 0, 0, 0, 982, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 344, + 0, 269, 30, 270, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 0, 393, 0, 271, 33, 0, 0, 0, 0, + 272, 30, 0, 0, 273, 0, 0, 274, 275, 276, + 277, 38, 39, 0, 278, 279, 0, 0, 0, 0, + 0, 1018, 280, 393, 33, 0, 344, 0, 1019, 0, + 0, 0, 0, 0, 0, 0, 281, 0, 359, 0, + 0, 1021, 0, 1022, 0, 283, 1166, 285, 286, 287, + 288, 0, 0, 0, 0, 0, 0, 0, 1035, 0, + 0, 0, 0, 0, 1039, 393, 0, 0, 344, 0, + 0, 0, 0, 0, 0, 0, 1075, 0, 0, 1076, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 786, 0, 0, + 0, 0, 0, 1086, 0, 0, 0, 0, 0, 0, + 0, 0, 393, 393, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 308, 0, 344, 0, + 344, 0, 0, 0, 0, 326, 0, 0, 808, 0, + 0, 596, 0, 596, 596, 0, 0, 362, 0, 0, + 596, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 840, 344, 0, 0, 0, 0, 344, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 344, 344, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1145, 0, + 0, 344, 0, 0, 1151, 1152, 393, 883, 0, 0, + 393, 886, 0, 0, 0, 0, 0, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 393, 0, 25, 26, 27, 344, + 393, 0, 393, 0, 30, 0, 393, 0, 464, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1210, 0, 0, 0, 0, 0, 1214, 33, 0, 0, + 0, 0, 0, 0, 197, 198, 0, 0, 344, 596, + 0, 0, 0, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + -279, 1233, 25, 26, 27, 0, 1235, 0, 0, 0, + 30, 0, 344, 0, 1239, 0, 393, 393, 259, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 33, 0, 0, 0, 0, 34, 0, + 805, 36, 37, 1262, -279, 0, 0, 326, 0, 38, + 39, 0, 0, 0, 0, 0, 362, 0, 393, 0, + 1273, 0, 0, 1274, 0, 1275, 0, 0, 0, 0, + 344, 0, 0, 0, 1023, 0, 565, 0, 0, 596, + 0, 596, 1285, 1286, 608, 0, 0, 0, 0, 0, + 596, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1299, 0, 0, 308, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 808, 0, 0, 0, 0, 0, 308, 0, 0, + 0, 0, 0, 0, 0, 1323, 0, 0, 0, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 709, 0, 25, 26, + 27, 0, 0, 0, 0, 344, 30, 432, 0, 0, + 393, 393, 0, 0, 0, 0, 0, 0, 393, 0, + 0, 0, 0, 393, 0, 0, 0, 0, 0, 33, + 0, 393, 0, 0, 741, 0, 35, 36, 0, 0, + 0, 0, 0, 0, 596, 596, 754, 0, 0, 0, + 0, 0, 0, 741, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 763, 764, 344, 0, + 0, 0, 433, 0, 1393, 393, 1394, 0, 0, 0, + 106, 0, 808, 0, 0, 0, 0, 1401, 785, 1402, + 0, 0, 0, 0, 393, 1140, 0, 0, 794, 0, + 1143, 0, 344, 0, 0, 269, 754, 270, 0, 1411, + 0, 0, 0, 393, 1157, 0, 596, 596, 1162, 0, + 0, 0, 0, 0, 0, 1429, 0, 0, 271, 344, + 344, 344, 0, 0, 272, 0, 0, 1435, 273, 0, + 1239, 274, 275, 276, 277, 38, 39, 0, 278, 279, + 0, 0, 0, 0, 0, 0, 280, 861, 0, 0, + 0, 0, 1456, 0, 362, 0, 0, 0, 0, 0, + 281, 1463, 359, 0, 1465, 1467, 0, 0, 0, 283, + 361, 285, 286, 287, 288, 326, 1222, 0, 0, 0, + 0, 393, 0, 1208, 344, 808, 393, 1232, 0, 490, + 494, 490, 497, 0, 0, 0, 0, 326, 596, 500, + 501, 0, 1494, 0, 490, 490, 1239, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 490, 0, 1506, 0, + 808, 0, 0, 269, 0, 270, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 344, 0, 490, 271, 0, 1143, 344, + 344, 0, 622, 0, 133, 134, 273, 0, 0, 274, + 275, 276, 277, 38, 39, 0, 278, 279, 0, 0, + 754, 0, 966, 0, 280, 0, 0, 0, 971, 0, + 0, 0, 490, 0, 0, 0, 981, 0, 281, 0, + 623, 0, 624, 360, 0, 0, 0, 283, 361, 285, + 286, 287, 288, 0, 0, 0, 0, 0, 344, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1143, 326, 0, 0, 995, 996, 326, 0, + 0, 0, 0, 344, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 326, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 0, 0, 25, 26, 27, + 471, 472, 473, 0, 269, 30, 270, 0, 0, 0, + 0, 0, 0, 344, 344, 0, 0, 0, 1033, 0, + 0, 0, 362, 0, 0, 0, 0, 271, 33, 0, + 0, 0, 0, 272, 0, 35, 36, 273, 0, 0, + 274, 275, 276, 277, 38, 39, 0, 278, 279, 0, + 1143, 0, 0, 326, 0, 280, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 281, + 0, 282, 0, 0, 0, 0, 0, 0, 283, 284, + 285, 286, 287, 288, 490, 490, 490, 490, 490, 490, + 490, 490, 490, 490, 490, 490, 490, 490, 490, 490, + 490, 490, 0, 308, 269, 0, 270, 0, 0, 0, + 0, 0, 808, 0, 0, 0, 1120, 1121, 0, 0, + 0, 0, 0, 490, 362, 0, 0, 271, 0, 0, + 0, 971, 0, 272, 1131, 0, 741, 273, 0, 344, + 274, 275, 276, 277, 38, 39, 0, 278, 279, 0, + 0, 0, 0, 1149, 0, 280, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 281, + 1168, 359, 0, 0, 0, 0, 752, 0, 283, 361, + 285, 286, 287, 288, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 362, 0, 1187, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1209, 0, 0, 0, 269, 0, 270, 0, 0, 393, + 0, 0, 0, 0, 490, 0, 0, 0, 0, 1218, + 0, 0, 0, 0, 0, 0, 0, 271, 0, 0, + 393, 393, 754, 272, 0, 0, 490, 273, 0, 0, + 274, 275, 276, 277, 38, 39, 0, 278, 279, 490, + 0, 393, 0, 0, 0, 280, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 281, + 971, 359, 0, 0, 968, 0, 0, 0, 283, 361, + 285, 286, 287, 288, 0, 0, 0, 0, 0, 0, + 0, 861, 490, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1276, + 0, 1277, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 490, 453, 2, 196, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 0, + 0, 25, 26, 27, 0, 0, 754, 0, 0, 30, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 308, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 33, 0, 0, 0, 0, 0, 0, 35, + 36, 0, 0, 0, 971, 0, 0, 0, 1, 2, + 196, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 0, 0, 25, 26, 27, 28, -3, 490, + 29, 269, 30, 1042, 1043, 0, 1044, 0, 0, 1045, + 1046, 1047, 1048, 1049, 1050, 1051, 1052, 0, 1053, 0, + 0, 1054, 32, 0, 271, 33, 0, 0, 0, 0, + 622, 0, 35, 36, 273, 0, 0, 274, 275, 276, + 277, 38, 39, 0, 278, 279, 0, 0, 0, 0, + 0, 0, 280, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 281, 0, 1055, 0, + 0, 163, 0, 0, 0, 283, 284, 285, 286, 287, + 288, 0, 0, 0, 0, 0, 0, 0, 0, -126, + 0, 0, 0, 0, 0, 490, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 490, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1442, 0, 0, 0, + 0, 0, 1, 2, 196, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 0, 0, 25, 26, + 27, 28, 0, 490, 29, 269, 30, 270, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 271, 33, + 0, 0, 0, 0, 272, 0, 35, 36, 273, 0, + 1498, 274, 275, 276, 277, 38, 39, 0, 278, 279, + 0, 0, 0, 0, 0, 0, 280, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 281, 0, 1055, 0, 0, 0, 0, 490, 0, 283, + 284, 285, 286, 287, 288, 0, 308, 0, 0, 0, + 0, 0, 0, -126, 0, 0, 1, 2, 196, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 0, 0, 25, 26, 27, 28, 0, 490, 29, 269, + 30, 270, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 490, 490, 0, 0, 0, 0, 0, 0, + 0, 0, 271, 33, 0, 0, 0, 0, 272, 0, + 35, 36, 273, 0, 0, 274, 275, 276, 277, 38, + 39, 0, 278, 279, 0, 0, 0, 0, 0, 0, + 280, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 281, 0, 41, 0, 0, 0, + 0, 0, 0, 283, 284, 285, 286, 287, 288, 2, + 196, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 0, 0, 25, 26, 27, 0, 0, 0, + 0, 269, 30, 270, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 271, 33, 0, 0, 0, 0, + 272, 0, 35, 36, 273, 0, 0, 274, 275, 276, + 277, 38, 39, 0, 278, 279, 0, 0, 0, 0, + 0, 0, 280, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 281, 0, 323, -3, + 0, 0, 0, 752, 0, 283, 324, 285, 286, 287, + 288, 0, 2, 196, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 0, 0, 25, 26, 27, + 0, 0, 0, 0, 269, 30, 270, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 490, 271, 33, 0, + 0, 0, 0, 272, 0, 35, 36, 273, 0, 0, + 274, 275, 276, 277, 38, 39, 0, 278, 279, 0, + 0, 0, 0, 0, 0, 280, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 281, + 0, 908, -3, 0, 0, 0, 752, 0, 283, 324, + 285, 286, 287, 288, 0, 0, 0, 0, 0, 490, + 490, 2, 196, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 0, 0, 25, 26, 27, 0, + 0, 0, 0, 269, 30, 270, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 271, 33, 0, 0, + 0, 0, 272, 0, 35, 36, 273, 0, 0, 274, + 275, 276, 277, 38, 39, 0, 278, 279, 0, 0, + 0, 0, 0, 0, 280, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 281, 0, + 908, -3, 0, 0, 0, 752, 0, 283, 572, 285, + 286, 287, 288, 2, 196, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 0, 0, 25, 26, + 27, 0, 0, 0, 0, 269, 30, 270, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 271, 33, + 0, 0, 0, 0, 272, 0, 35, 36, 273, 0, + 0, 274, 275, 276, 277, 38, 39, 0, 278, 279, + 0, 0, 0, 0, 0, 0, 280, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 281, 0, 323, -3, 0, 0, 0, 0, 0, 283, + 324, 285, 286, 287, 288, 2, 196, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 0, 0, + 25, 26, 27, 0, 0, 0, 0, 269, 30, 270, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 271, 33, 0, 0, 0, 0, 272, 0, 35, 36, + 273, 0, 0, 274, 275, 276, 277, 38, 39, 0, + 278, 279, 0, 0, 0, 0, 0, 0, 280, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 281, 0, 908, -3, 0, 0, 0, 0, + 0, 283, 324, 285, 286, 287, 288, 2, 196, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 0, 0, 25, 26, 27, 0, 0, 0, 0, 269, + 30, 270, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 271, 33, 0, 0, 0, 0, 272, 0, + 197, 198, 273, 0, 0, 274, 275, 276, 277, 38, + 39, 0, 278, 279, 0, 0, 0, 0, 0, 0, + 280, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 281, 0, 993, 0, 0, 0, + 0, 0, 0, 283, 994, 285, 286, 287, 288, 2, + 196, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 0, 0, 25, 26, 27, 0, 0, 0, + 0, 269, 30, 270, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 271, 33, 0, 0, 0, 0, + 272, 0, 197, 198, 273, 0, 0, 274, 275, 276, + 277, 38, 39, 0, 278, 279, 0, 0, 0, 0, + 0, 0, 280, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 281, 0, 359, 0, + 0, 0, 0, 0, 0, 283, 361, 285, 286, 287, + 288, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 0, 0, 25, 26, 27, + 28, 0, 0, 29, 0, 30, 31, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 32, 0, 0, 33, 0, + 0, 0, 0, 34, 0, 35, 36, 37, 0, 0, + 0, 0, 0, 0, 38, 39, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, + 0, 41, 0, 0, 0, -503, 0, 0, 0, 42, + 195, 2, 196, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 0, 0, 25, 26, 27, 0, + 0, 0, 0, 0, 30, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 33, 0, 0, + 0, 0, 34, 0, 197, 198, 37, 0, 0, 0, + 0, 0, 0, 38, 39, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 40, 0, + 199, 0, 0, 0, 0, 0, 0, 0, 200, 1, + 2, 196, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 0, 0, 25, 26, 27, 28, 0, + 0, 29, 0, 30, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 33, 0, 0, 0, + 0, 0, 0, 35, 36, 0, 195, 2, 196, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 0, 0, 25, 26, 27, 0, 0, 0, 0, 41, + 30, 0, 0, 0, 0, 0, 0, 106, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 33, 0, 0, 0, 0, 0, 0, + 197, 198, 2, 196, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 0, 0, 25, 26, 27, + 0, 0, 0, 0, 0, 30, 199, 0, 0, 0, + 0, 0, 0, 0, 259, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 33, 0, + 0, 0, 0, 34, 0, 197, 198, 37, 0, 0, + 0, 0, 0, 0, 38, 39, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, + 0, 199, 0, 0, 0, 0, 0, 0, 0, 200, + 2, 196, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 0, 0, 25, 26, 27, 0, 0, + 0, 0, 0, 30, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 33, 0, 0, 0, + 0, 0, 0, 35, 36, 2, 196, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 0, 0, + 25, 26, 27, 0, 0, 0, 0, 0, 30, 659, + -3, 0, 0, 0, 0, 0, 0, 608, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 33, 0, 0, 0, 0, 0, 0, 35, 36, + 0, 0, 2, 196, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 0, 0, 25, 26, 27, + 0, 0, 0, -386, 659, 30, 0, 0, 0, 0, + 0, 0, 608, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 33, 0, + 0, 0, 0, 0, 0, 35, 36, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1365, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 659, 0, 0, 0, 0, 0, 0, 0, 608, + 2, 196, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 0, 0, 25, 26, 27, 0, 0, + 0, 0, 0, 30, 0, 0, 0, 0, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 0, 33, 25, 26, 27, + 0, 0, 0, 35, 36, 30, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1367, 0, 0, 33, 0, + 0, 0, 0, 34, 0, 805, 36, 37, 0, 659, + 0, 0, 0, 0, 38, 39, 0, 608, 2, 196, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 565, 0, 25, 26, 27, 0, 0, 0, 106, + 0, 30, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 33, 0, 0, 0, 0, 0, + 0, 197, 198, 2, 196, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 0, 0, 25, 26, + 27, 0, 0, 0, 0, 0, 30, 258, 0, 0, + 0, 0, 0, 0, 0, 603, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 33, + 0, 0, 0, 0, 0, 0, 35, 36, 2, 196, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 0, 0, 25, 26, 27, 0, 0, 0, 0, + 0, 30, 571, 0, 0, 0, 0, 0, 0, 0, + 608, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 33, 0, 0, 0, 0, 0, + 0, 35, 36, 2, 196, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 0, 0, 25, 26, + 27, 0, 0, 0, 0, 0, 30, 659, 0, 0, + 0, 0, 0, 0, 0, 608, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 33, + 0, 0, 0, 0, 0, 0, 197, 198, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 0, 0, 25, 26, 27, + 0, 0, 0, 0, 269, 30, 270, 0, 0, 0, + 0, 0, 199, 0, 0, 0, 0, 0, 0, 0, + 259, 0, 0, 0, 0, 0, 0, 271, 33, 0, + 0, 0, 0, 272, 0, 35, 36, 273, 0, 0, + 274, 275, 276, 277, 38, 39, 0, 278, 279, 0, + 0, 0, 0, 0, 0, 280, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 281, + 0, 503, 0, 0, 163, 0, 0, 0, 283, 284, + 285, 286, 287, 288, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 0, 0, 25, 26, 27, 0, 0, 0, 0, + 269, 30, 270, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 271, 33, 0, 0, 0, 0, 272, + 0, 35, 36, 273, 0, 0, 274, 275, 276, 277, + 38, 39, 0, 278, 279, 0, 0, 0, 0, 0, + 0, 280, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 281, 0, 571, -3, 0, + 0, 0, 0, 0, 283, 572, 285, 286, 287, 288, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 0, 0, 25, + 26, 27, 0, 0, 0, 0, 269, 30, 270, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 271, + 33, 0, 0, 0, 0, 622, 0, 35, 36, 273, + 0, 0, 274, 275, 276, 277, 38, 39, 0, 278, + 279, 0, 0, 0, 0, 0, 0, 280, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 281, -35, 738, 0, 0, 0, 0, 0, 0, + 283, 284, 285, 286, 287, 288, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 0, 0, 25, 26, 27, 0, 0, + 0, 0, 269, 30, 270, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 271, 33, 0, 0, 0, + 0, 272, 0, 35, 36, 273, 0, 0, 274, 275, + 276, 277, 38, 39, 0, 278, 279, 0, 0, 0, + 0, 0, 0, 280, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 281, 0, 282, + 0, 0, 0, 0, 0, 0, 283, 284, 285, 286, + 287, 288, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 0, + 0, 25, 26, 27, 0, 0, 0, 0, 269, 30, + 270, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 271, 33, 0, 0, 0, 0, 272, 0, 35, + 36, 273, 0, 0, 274, 275, 276, 277, 38, 39, + 0, 278, 279, 0, 0, 0, 0, 0, 0, 280, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 281, 0, 150, 0, 0, 0, 0, + 0, 0, 283, 284, 285, 286, 287, 288, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 0, 0, 25, 26, 27, + 0, 0, 0, 0, 269, 30, 270, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 271, 33, 0, + 0, 0, 0, 272, 0, 35, 36, 273, 0, 0, + 274, 275, 276, 277, 38, 39, 0, 278, 279, 0, + 0, 0, 0, 0, 0, 280, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 281, + 0, 571, 0, 0, 0, 0, 0, 0, 283, 572, + 285, 286, 287, 288, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 0, 0, 25, 26, 27, 0, 0, 0, 0, + 269, 30, 270, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 271, 33, 0, 0, 0, 0, 272, + 0, 35, 36, 273, 0, 0, 274, 275, 276, 277, + 38, 39, 0, 278, 279, 0, 0, 0, 0, 0, + 0, 280, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 281, 0, 359, 0, 0, + 0, 0, 0, 0, 283, 361, 285, 286, 287, 288, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, -279, 0, 25, + 26, 27, 0, 0, 0, 0, 0, 30, 0, 0, + 0, 0, 0, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 33, 0, 25, 26, 27, 34, 0, 805, 36, 37, + 30, -279, 0, 0, 0, 0, 38, 39, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 33, 0, 0, 0, 0, 34, 0, + 35, 36, 37, 565, 0, 0, 0, 0, 0, 38, + 39, 106, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 0, + 0, 25, 26, 27, 40, 0, 41, 0, 0, 30, + 0, 0, 0, 0, 42, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 33, 0, 0, 0, 0, 34, 0, 197, + 198, 37, 0, 0, 0, 0, 0, 0, 38, 39, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 0, 0, 25, + 26, 27, 0, 40, 0, 258, 0, 30, 0, 0, + 0, 0, 0, 200, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 0, 34, 0, 805, 36, 37, + 0, 0, 0, 0, 0, 0, 38, 39, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, -279, 0, 25, 26, 27, + 0, 1023, 0, 565, 0, 30, 0, 0, 0, 0, + 0, 608, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 33, 0, + 0, 0, 0, 0, 0, 35, 36, 0, 0, -279, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 0, 0, 25, + 26, 27, 0, 0, 0, 0, 0, 30, 432, 1023, + 0, 565, 0, 0, 0, 0, 0, 0, 0, 608, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 0, 0, 0, 35, 36, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 0, 0, 25, 26, + 27, 0, 0, 0, 0, 0, 30, 432, 0, 0, + 0, 0, 0, 433, 0, 0, 0, 685, 0, 0, + 0, 106, 0, 0, 0, 0, 0, 0, 0, 33, + 0, 0, 0, 0, 0, 0, 35, 36, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, -279, 0, 25, 26, 27, + 0, 0, 0, 0, 0, 30, 0, 0, 0, 0, + 0, 0, 433, 0, 0, 0, 924, 0, 0, 0, + 106, 0, 0, 0, 0, 0, 0, 0, 33, 0, + 0, 0, 0, 0, 0, 35, 36, 0, 0, -279, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 0, 0, 25, + 26, 27, 0, 0, 0, 0, 0, 30, 432, 0, + 0, 565, 0, 0, 0, 0, 0, 0, 0, 106, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 0, 0, 0, 35, 36, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 0, 0, 25, 26, + 27, 0, 0, 0, 0, 0, 30, 432, 0, 0, + 0, 0, 0, 433, 0, 0, 0, 1389, 0, 0, + 0, 106, 0, 0, 0, 0, 0, 0, 0, 33, + 0, 0, 0, 0, 0, 0, 35, 36, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 0, 0, 25, 26, 27, + 0, 0, 0, 0, 0, 30, 432, 0, 0, 0, + 0, 0, 433, 0, 0, 0, 1433, 0, 0, 0, + 106, 0, 0, 0, 0, 0, 0, 0, 33, 0, + 0, 0, 0, 0, 0, 35, 36, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 0, 0, 25, 26, 27, 0, + 0, 0, 0, 0, 30, 432, 0, 0, 0, 0, + 0, 433, 0, 0, 0, 1495, 0, 0, 0, 106, + 0, 0, 0, 0, 0, 0, 0, 33, 0, 0, + 0, 0, 0, 0, 35, 36, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 0, 0, 25, 26, 27, 0, 0, + 0, 0, 0, 30, 0, 0, 0, 0, 0, 0, + 433, 0, 0, 0, 1519, 0, 0, 0, 106, 0, + 0, 0, 0, 0, 0, 0, 33, 0, 0, 0, + 0, 0, 0, 35, 36, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 0, 0, 25, 26, 27, 0, 0, 0, + 0, 0, 30, 0, 0, 0, 0, 1023, 0, 565, + 0, 0, 0, 0, 0, 0, 0, 106, 0, 0, + 0, 0, 0, 0, 0, 33, 0, 0, 0, 0, + 0, 0, 35, 36, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 0, 0, 25, 26, 27, 0, 0, 0, 0, + 0, 30, 0, 0, 0, 0, 1023, 0, 565, 0, + 0, 0, 0, 0, 0, 0, 608, 0, 0, 0, + 0, 0, 0, 0, 33, 0, 0, 0, 0, 0, + 0, 35, 36, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 0, 0, 25, 26, 27, 0, 0, 0, 0, 0, + 30, 0, 0, 0, 0, 0, 0, 245, 0, 0, + 0, 0, 0, 0, 0, 106, 0, 0, 0, 0, + 0, 0, 0, 33, 0, 0, 0, 0, 0, 0, + 35, 36, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 0, + 0, 25, 26, 27, 0, 0, 0, 0, 0, 30, + 0, 0, 0, 0, 0, 0, 150, 0, 0, 0, + 0, 0, 0, 0, 106, 0, 0, 0, 0, 0, + 0, 0, 33, 0, 0, 0, 0, 0, 0, 197, + 198, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 0, 0, + 25, 26, 27, 0, 0, 0, 0, 0, 30, 0, + 0, 0, 0, 0, 0, 258, 0, 0, 0, 0, + 0, 0, 0, 259, 0, 0, 0, 0, 0, 0, + 0, 33, 0, 0, 0, 0, 0, 0, 35, 36, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 0, 0, 25, + 26, 27, 0, 0, 0, 0, 0, 30, 0, 0, + 0, 0, 0, 0, 245, 0, 0, 0, 0, 0, + 0, 0, 608, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 0, 0, 0, 35, 36, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 0, 0, 25, 26, + 27, 0, 0, 0, 0, 0, 30, 0, 0, 0, + 0, 0, 0, 565, 0, 0, 0, 0, 0, 0, + 0, 608, 0, 0, 0, 0, 0, 0, 0, 33, + 0, 0, 0, 0, 0, 0, 35, 36, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 0, 0, 25, 26, 27, + 0, 0, 0, 0, 0, 30, 0, 0, 0, 0, + 0, 0, 433, 0, 0, 0, 0, 0, 0, 0, + 106, 0, 0, 0, 0, 0, 0, 0, 33, 0, + 0, 0, 0, 0, 0, 197, 198, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 0, 0, 25, 26, 27, 0, + 0, 0, 0, 0, 30, 0, 0, 0, 0, 0, + 0, 258, 0, 0, 0, 0, 0, 0, 0, 603, + 0, 0, 0, 0, 0, 0, 0, 33, 0, 0, + 0, 0, 0, 0, 35, 36, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 0, 0, 25, 26, 27, 0, 0, + 0, 0, 0, 30, 0, 0, 0, 0, 0, 0, + 571, 0, 0, 0, 0, 0, 0, 0, 608, 0, + 0, 0, 0, 0, 0, 0, 33, 0, 0, 0, + 0, 0, 0, 35, 36, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 0, 0, 25, 26, 27, 0, 0, 0, + 0, 0, 30, 0, 0, 0, 0, 0, 0, 41, + 0, 0, 0, 0, 0, 0, 0, 106, 0, 0, + 0, 0, 0, 0, 0, 33, 0, 0, 0, 0, + 0, 0, 35, 36, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 0, 0, 25, 26, 27, 0, 0, 0, 0, + 0, 30, 0, 0, 0, 0, 0, 0, 565, 0, + 0, 0, 0, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 33, 0, 0, 0, 0, 0, + 0, 197, 198, 2, 196, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 0, 0, 25, 26, + 27, 0, 0, 0, 0, 0, 30, 0, 0, 0, + 0, 269, 0, 270, 1043, 603, 1044, 0, 0, 1045, + 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1527, 1053, 33, + 0, 1054, 32, 0, 271, 0, 35, 36, 0, 0, + 622, 0, 0, 0, 273, 0, 0, 274, 275, 276, + 277, 38, 39, 0, 278, 279, 0, 0, 0, 0, + 0, 0, 280, 0, 0, 0, 0, 0, 0, 0, + 0, -399, 0, 0, 0, 0, 281, 0, 359, 0, + 0, 163, 0, 0, 0, 283, 361, 285, 286, 287, + 288, 0, 269, 0, 270, 1043, 0, 1044, 0, -126, + 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 0, 1053, + 0, 0, 1054, 32, 0, 271, 0, 0, 0, 0, + 0, 622, 0, 0, 0, 273, 0, 0, 274, 275, + 276, 277, 38, 39, 0, 278, 279, 0, 0, 0, + 0, 0, 0, 280, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 281, 0, 359, + 0, 0, 163, 0, 0, 0, 283, 361, 285, 286, + 287, 288, 0, 0, 0, 0, 0, 0, 0, 0, + -126, 2, 196, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 0, 0, 25, 26, 27, 0, + 269, 0, 270, 1043, 30, 1044, 1415, 1416, 1045, 1046, + 1047, 1048, 1049, 1050, 1051, 1052, 1527, 1053, 0, 0, + 1054, 32, 0, 271, 0, 0, 0, 33, 0, 622, + 0, 0, 0, 273, 35, 36, 274, 275, 276, 277, + 38, 39, 0, 278, 279, 0, 0, 0, 0, 0, + 0, 280, 0, 0, 0, 0, 1324, 0, 0, 0, + 0, 0, 0, 0, 0, 281, 0, 359, 0, 0, + 163, 0, 0, 0, 283, 361, 285, 286, 287, 288, + 269, 0, 270, 1043, 0, 1044, 1415, 1416, 1045, 1046, + 1047, 1048, 1049, 1050, 1051, 1052, 0, 1053, 0, 0, + 1054, 32, 0, 271, 0, 0, 0, 0, 0, 622, + 0, 0, 0, 273, 0, 0, 274, 275, 276, 277, + 38, 39, 0, 278, 279, 0, 0, 0, 0, 0, + 0, 280, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 281, 0, 359, 0, 0, + 163, 0, 0, 0, 283, 361, 285, 286, 287, 288, + 269, 0, 270, 1043, 0, 1044, 0, 0, 1045, 1046, + 1047, 1048, 1049, 1050, 1051, 1052, 0, 1053, 0, 0, + 1054, 32, 0, 271, 0, 0, 0, 0, 0, 622, + 0, 0, 0, 273, 0, 0, 274, 275, 276, 277, + 38, 39, 0, 278, 279, 0, 0, 0, 0, 0, + 0, 280, 0, 0, 0, 0, 0, 269, 0, 270, + 0, 0, 0, 0, 0, 281, 0, 359, 0, 0, + 163, 0, 0, 0, 283, 361, 285, 286, 287, 288, + 271, 0, 0, 0, 0, 0, 272, 0, 0, 0, + 273, 0, 0, 274, 275, 276, 277, 38, 39, 0, + 278, 279, 0, 0, 0, 0, 0, 0, 280, 0, + 0, 0, 0, 0, 269, 0, 270, 0, 0, 0, + 0, 0, 281, 0, 359, 0, 0, 0, 0, 0, + 0, 283, 361, 285, 286, 287, 288, 271, 0, 0, + 0, 0, 0, 272, 0, 0, 0, 273, 0, 0, + 274, 275, 276, 277, 38, 39, 0, 278, 279, 0, + 0, 0, 0, 0, 0, 280, 0, 0, 0, 0, + 0, 269, 0, 270, 0, 0, 0, 0, 0, 281, + 0, 359, 0, 0, 0, 0, 0, 0, 283, 708, + 285, 286, 287, 288, 271, 0, 0, 0, 0, 0, + 622, 0, 0, 0, 273, 0, 0, 274, 275, 276, + 277, 38, 39, 0, 278, 279, 0, 0, 0, 0, + 0, 0, 280, 0, 0, 0, 0, 0, 269, 0, + 270, 0, 0, 0, 0, 0, 281, 0, 757, 0, + 0, 0, 0, 0, 0, 283, 361, 285, 286, 287, + 288, 271, 0, 0, 0, 0, 0, 272, 0, 0, + 0, 273, 0, 0, 274, 275, 276, 277, 38, 39, + 0, 278, 279, 0, 0, 0, 0, 0, 0, 280, + 0, 0, 0, 0, 0, 269, 0, 270, 0, 0, + 0, 0, 0, 281, 0, 359, 0, 0, 0, 0, + 0, 0, 283, 888, 285, 286, 287, 288, 271, 0, + 0, 0, 0, 0, 272, 0, 0, 0, 273, 0, + 0, 274, 275, 276, 277, 38, 39, 0, 278, 279, + 0, 0, 0, 0, 0, 0, 280, 0, 0, 0, + 0, 0, 269, 0, 270, 0, 0, 0, 0, 0, + 281, 0, 0, 0, 0, 0, 0, 0, 0, 283, + 361, 285, 286, 287, 288, 271, 0, 0, 0, 0, + 0, 272, 0, 0, 0, 273, 0, 0, 274, 275, + 276, 277, 38, 39, 0, 278, 279, 0, 0, 0, + 0, 0, 0, 280, 0, 0, 0, 0, 0, 269, + 0, 270, 0, 0, 0, 0, 0, 493, 0, 0, + 0, 0, 0, 0, 0, 0, 283, 361, 285, 286, + 287, 288, 271, 0, 0, 0, 0, 0, 272, 0, + 0, 0, 273, 0, 0, 274, 275, 276, 277, 38, + 39, 0, 278, 279, 0, 0, 0, 0, 0, 0, + 280, 0, 0, 0, 0, 0, 269, 0, 270, 0, + 0, 0, 0, 0, 496, 0, 0, 0, 0, 0, + 0, 0, 0, 283, 361, 285, 286, 287, 288, 271, + 0, 0, 0, 0, 0, 272, 0, 0, 0, 273, + 0, 0, 274, 275, 276, 277, 38, 39, 0, 278, + 279, 0, 0, 0, 0, 0, 0, 280, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 499, 0, 0, 0, 0, 0, 0, 0, 0, + 283, 361, 285, 286, 287, 288, 2, 196, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 30, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 33, 0, 0, 0, 0, 34, 0, 166, + 167, 37, 0, 0, 0, 0, 0, 0, 38, 39, + 195, 2, 196, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 0, 0, 25, 26, 27, 0, + 0, 0, 0, 0, 30, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 33, 0, 0, + 0, 0, 0, 0, 197, 198, 453, 2, 196, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 0, 0, 25, 26, 27, 0, 0, 0, 0, 0, + 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 33, 0, 0, 0, 0, 0, 0, + 35, 36, 2, 196, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 0, 0, 25, 26, 27, + 0, 0, 0, 0, 0, 30, 0, 0, 0, 0, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 0, 33, 25, + 26, 27, 471, 472, 473, 197, 198, 30, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 0, 0, 25, 26, 27, + 33, 0, 0, 0, 0, 30, 0, 35, 36, 0, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 0, 33, 25, + 26, 27, 0, 105, 0, 35, 36, 30, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 0, 0, 25, 26, 27, + 33, 0, 0, 0, 0, 30, 0, 35, 36, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 33, 0, + 0, 0, 0, 0, 0, 197, 198 +}; + +#define yypact_value_is_default(yystate) \ + ((yystate) == (-1291)) + +#define yytable_value_is_error(yytable_value) \ + YYID (0) + +static const yytype_int16 yycheck[] = +{ + 1, 1, 0, 40, 0, 40, 40, 176, 110, 32, + 176, 410, 209, 177, 100, 176, 555, 441, 0, 1, + 161, 176, 517, 176, 431, 267, 672, 603, 554, 651, + 329, 672, 431, 31, 672, 31, 176, 619, 176, 324, + 975, 344, 40, 435, 42, 348, 42, 554, 583, 31, + 627, 633, 585, 583, 52, 583, 585, 0, 618, 619, + 58, 586, 58, 61, 64, 61, 64, 592, 64, 583, + 0, 478, 268, 633, 434, 482, 177, 554, 1022, 1334, + 37, 751, 64, 0, 253, 982, 873, 253, 31, 191, + 254, 40, 253, 101, 476, 40, 104, 583, 253, 40, + 253, 31, 748, 101, 0, 0, 104, 748, 1021, 1022, + 748, 450, 110, 253, 31, 253, 31, 873, 583, 65, + 697, 405, 406, 0, 1, 1415, 27, 0, 710, 583, + 65, 1042, 88, 1419, 218, 31, 31, 75, 1035, 176, + 178, 176, 176, 141, 61, 141, 103, 507, 101, 102, + 710, 235, 37, 254, 31, 153, 65, 153, 31, 37, + 42, 43, 42, 65, 786, 111, 122, 40, 103, 42, + 71, 194, 42, 43, 796, 474, 397, 65, 176, 177, + 1435, 177, 37, 468, 61, 58, 123, 64, 61, 1479, + 812, 64, 389, 191, 103, 416, 480, 733, 57, 102, + 208, 103, 200, 424, 200, 587, 109, 65, 37, 591, + 208, 249, 250, 211, 498, 211, 253, 1503, 253, 253, + 123, 385, 1508, 101, 106, 103, 106, 176, 42, 43, + 612, 176, 718, 65, 616, 176, 124, 107, 1524, 240, + 244, 239, 101, 239, 1508, 1531, 101, 101, 103, 29, + 75, 790, 260, 718, 102, 253, 254, 239, 254, 267, + 140, 109, 260, 101, 718, 50, 124, 1531, 141, 267, + 434, 103, 101, 375, 103, 102, 811, 102, 562, 280, + 153, 811, 109, 811, 385, 123, 1042, 572, 813, 822, + 37, 1235, 106, 822, 211, 37, 239, 811, 78, 79, + 692, 403, 466, 176, 177, 78, 408, 92, 268, 239, + 89, 614, 651, 1248, 984, 113, 114, 315, 603, 315, + 200, 102, 239, 608, 239, 811, 101, 200, 109, 89, + 328, 329, 105, 434, 211, 101, 115, 345, 211, 0, + 1, 349, 1286, 239, 239, 106, 811, 345, 244, 244, + 65, 349, 67, 68, 101, 115, 103, 811, 108, 101, + 108, 103, 239, 3, 903, 466, 239, 666, 108, 1508, + 31, 65, 1285, 1286, 124, 69, 902, 375, 108, 259, + 253, 42, 76, 77, 124, 1524, 671, 385, 1299, 385, + 108, 106, 1531, 397, 124, 902, 1018, 1019, 108, 184, + 61, 936, 3, 64, 284, 403, 936, 101, 937, 103, + 408, 104, 416, 330, 124, 108, 902, 111, 994, 108, + 424, 206, 936, 108, 108, 902, 65, 1214, 67, 68, + 65, 216, 67, 68, 104, 124, 434, 902, 108, 124, + 124, 1023, 315, 664, 324, 106, 101, 786, 902, 108, + 111, 231, 453, 1075, 1076, 102, 329, 796, 1214, 744, + 458, 108, 844, 1023, 103, 124, 101, 1411, 466, 0, + 466, 106, 470, 812, 470, 111, 474, 673, 104, 140, + 116, 117, 108, 1008, 1009, 980, 0, 628, 470, 102, + 732, 61, 153, 108, 580, 108, 281, 498, 1411, 695, + 123, 397, 397, 672, 1401, 1402, 672, 101, 1482, 124, + 674, 672, 385, 514, 1488, 1051, 517, 672, 519, 672, + 416, 416, 121, 822, 123, 405, 406, 470, 424, 424, + 410, 1505, 672, 635, 672, 101, 1510, 103, 945, 200, + 470, 111, 459, 1299, 1083, 1456, 1123, 101, 947, 103, + 211, 431, 1463, 470, 104, 915, 101, 111, 108, 101, + 942, 434, 65, 923, 67, 68, 567, 101, 229, 1151, + 1152, 1100, 468, 674, 470, 470, 101, 65, 239, 67, + 360, 69, 580, 153, 101, 583, 103, 585, 76, 77, + 251, 1151, 1152, 470, 111, 1506, 604, 470, 259, 637, + 480, 474, 65, 106, 67, 68, 604, 967, 102, 108, + 65, 104, 620, 102, 69, 108, 101, 72, 498, 74, + 281, 3, 620, 284, 632, 124, 81, 570, 10, 11, + 12, 13, 14, 634, 632, 636, 421, 635, 101, 101, + 1262, 211, 941, 106, 4, 5, 6, 7, 8, 9, + 108, 1273, 1274, 1275, 102, 37, 108, 1, 102, 439, + 664, 102, 859, 324, 444, 102, 124, 104, 666, 330, + 455, 108, 124, 101, 672, 103, 674, 247, 60, 1018, + 1019, 251, 562, 880, 81, 82, 123, 124, 605, 992, + 108, 281, 572, 102, 83, 84, 102, 477, 42, 479, + 1456, 1323, 108, 707, 705, 101, 124, 1463, 493, 994, + 583, 496, 585, 673, 499, 101, 65, 108, 67, 68, + 718, 719, 808, 603, 732, 866, 102, 107, 608, 118, + 119, 3, 108, 124, 732, 695, 1075, 1076, 10, 11, + 12, 13, 14, 65, 405, 406, 101, 69, 203, 410, + 1506, 915, 101, 124, 76, 77, 100, 106, 57, 923, + 330, 101, 106, 1299, 124, 37, 102, 853, 664, 664, + 431, 432, 108, 101, 435, 671, 101, 101, 103, 101, + 441, 698, 85, 86, 1083, 103, 111, 105, 60, 111, + 124, 109, 103, 666, 105, 712, 140, 493, 109, 672, + 496, 674, 1226, 499, 102, 106, 101, 468, 103, 470, + 108, 707, 707, 811, 915, 405, 406, 65, 101, 480, + 103, 69, 923, 783, 822, 102, 1225, 106, 76, 77, + 124, 108, 493, 42, 124, 496, 102, 498, 499, 409, + 1143, 1377, 108, 65, 624, 718, 719, 1150, 744, 58, + 106, 195, 61, 101, 101, 64, 200, 75, 102, 802, + 1145, 468, 102, 111, 108, 650, 1512, 102, 108, 102, + 112, 1512, 873, 108, 1512, 108, 661, 332, 102, 334, + 665, 102, 120, 800, 108, 229, 102, 108, 974, 459, + 121, 873, 108, 101, 1233, 103, 1037, 1321, 108, 109, + 898, 562, 862, 493, 902, 903, 496, 687, 87, 499, + 102, 572, 123, 693, 575, 259, 108, 915, 262, 103, + 1116, 1224, 104, 1262, 1460, 923, 1462, 102, 1320, 101, + 873, 103, 141, 108, 1273, 1274, 1275, 281, 811, 102, + 284, 102, 603, 941, 153, 108, 946, 608, 102, 822, + 1235, 65, 102, 67, 897, 69, 873, 65, 108, 67, + 68, 551, 76, 77, 946, 420, 102, 101, 177, 103, + 65, 1507, 67, 68, 69, 102, 977, 873, 873, 980, + 324, 982, 102, 103, 1323, 1181, 1182, 101, 101, 1012, + 103, 200, 54, 55, 992, 102, 873, 111, 1390, 102, + 344, 1087, 211, 101, 348, 575, 1108, 1431, 108, 109, + 671, 618, 619, 4, 5, 6, 7, 8, 9, 1322, + 540, 541, 542, 543, 984, 101, 633, 103, 103, 902, + 903, 692, 42, 43, 1035, 605, 1122, 101, 102, 103, + 610, 32, 915, 108, 1045, 1469, 123, 1048, 1049, 1050, + 923, 712, 101, 102, 103, 10, 11, 12, 13, 14, + 1042, 405, 406, 677, 671, 679, 410, 947, 941, 946, + 106, 78, 79, 80, 101, 450, 1468, 536, 537, 1039, + 997, 102, 37, 744, 102, 1083, 866, 431, 432, 538, + 539, 435, 872, 104, 101, 104, 103, 441, 105, 1042, + 101, 102, 103, 710, 1496, 60, 315, 104, 108, 453, + 1108, 101, 102, 103, 994, 900, 109, 1254, 1255, 1256, + 109, 1520, 544, 545, 28, 1042, 75, 102, 698, 102, + 104, 1491, 108, 102, 478, 107, 480, 744, 482, 800, + 108, 107, 712, 1086, 109, 107, 1042, 1042, 101, 493, + 102, 75, 496, 124, 498, 499, 1116, 10, 11, 12, + 13, 14, 102, 102, 109, 1042, 102, 102, 52, 102, + 3, 108, 104, 1533, 102, 102, 385, 10, 11, 12, + 13, 14, 102, 270, 37, 104, 101, 65, 968, 67, + 101, 69, 102, 1193, 102, 102, 283, 284, 76, 77, + 102, 102, 102, 102, 37, 102, 102, 60, 295, 104, + 1083, 1193, 873, 1214, 107, 28, 104, 101, 562, 1415, + 104, 1181, 1182, 101, 104, 103, 1224, 60, 572, 123, + 800, 109, 1214, 111, 102, 102, 580, 324, 102, 1239, + 10, 11, 12, 13, 14, 102, 102, 107, 101, 1145, + 103, 102, 102, 1254, 1255, 1256, 108, 1239, 111, 603, + 104, 104, 102, 108, 608, 102, 101, 37, 1053, 108, + 614, 1214, 106, 104, 361, 1192, 651, 65, 873, 67, + 108, 69, 1478, 1479, 104, 946, 947, 104, 76, 77, + 60, 1071, 1394, 102, 104, 65, 102, 1214, 1384, 69, + 108, 108, 102, 104, 1084, 1085, 76, 77, 101, 101, + 101, 101, 1313, 101, 101, 1192, 1193, 1299, 1214, 1214, + 109, 124, 107, 111, 208, 102, 102, 121, 102, 104, + 42, 101, 45, 994, 1334, 107, 107, 1214, 106, 1235, + 124, 111, 108, 1512, 104, 1225, 1512, 108, 692, 1513, + 104, 1512, 1334, 102, 102, 102, 1299, 1512, 104, 1512, + 104, 104, 1239, 4, 5, 6, 7, 8, 9, 1533, + 1371, 104, 1512, 1374, 1512, 102, 260, 1294, 722, 104, + 104, 1042, 1299, 267, 124, 1393, 1384, 124, 124, 1491, + 124, 106, 124, 104, 106, 1393, 1394, 102, 107, 102, + 1401, 1402, 104, 1299, 1299, 104, 107, 104, 1188, 104, + 104, 786, 1513, 104, 1021, 104, 1023, 1294, 1419, 104, + 102, 796, 1299, 1424, 102, 104, 55, 997, 140, 104, + 101, 101, 1533, 54, 106, 1435, 104, 812, 102, 102, + 124, 0, 1, 75, 328, 102, 533, 534, 535, 1450, + 1045, 109, 102, 1435, 101, 1415, 104, 1334, 65, 104, + 67, 345, 69, 102, 808, 349, 104, 102, 104, 76, + 77, 89, 31, 32, 1456, 1512, 107, 1512, 1512, 102, + 102, 1463, 102, 42, 1145, 572, 102, 40, 200, 108, + 124, 1492, 109, 1491, 101, 89, 103, 124, 102, 102, + 106, 75, 1503, 102, 111, 64, 104, 1508, 109, 853, + 124, 124, 107, 1456, 1512, 1513, 104, 1513, 1478, 1479, + 1463, 1522, 1307, 1524, 1506, 101, 107, 1528, 124, 107, + 1531, 1192, 1193, 102, 124, 1533, 1537, 1533, 1145, 1456, + 1541, 100, 102, 647, 1151, 1152, 1463, 259, 546, 548, + 1124, 547, 1214, 1214, 549, 1479, 550, 1379, 1435, 1308, + 1456, 1456, 1541, 1506, 1225, 1226, 1494, 1463, 1463, 281, + 1118, 1463, 284, 65, 1235, 67, 68, 69, 1239, 1456, + 1119, 1071, 141, 0, 76, 77, 1463, 679, 923, 1506, + 149, 432, 925, 866, 432, 444, 10, 11, 12, 13, + 14, 945, 946, 947, 1194, 1195, 567, 1197, 1388, 101, + 1506, 1506, 968, 1203, 31, 629, 1206, 722, 177, 1214, + 943, 708, 1192, 37, 470, -1, 732, 1239, -1, 1506, + 974, -1, 191, 1294, -1, 194, 195, -1, 1299, 1512, + 1520, 200, -1, 1018, 1019, 65, 60, 64, 992, 69, + 994, 65, -1, 67, -1, 69, 76, 77, -1, 1320, + 1321, 220, 76, 77, 751, 224, -1, 226, -1, -1, + -1, -1, -1, 1334, 233, -1, -1, -1, 1285, 1464, + 239, 101, 180, 103, -1, 244, -1, 101, -1, 187, + -1, 111, -1, 405, 406, 254, 580, 111, 410, -1, + 1075, 1076, -1, 262, -1, -1, 61, -1, 1493, -1, + -1, 65, -1, 67, 68, 69, 71, -1, 1313, 431, + 604, -1, 76, 77, 1294, -1, -1, -1, -1, 1390, + -1, -1, 149, -1, -1, -1, 620, -1, -1, -1, + -1, -1, -1, 1087, -1, -1, -1, 1532, 632, -1, + 10, 11, 12, 13, 14, -1, 111, -1, 256, 1544, + -1, -1, -1, -1, -1, 324, -1, -1, 480, -1, + 1431, -1, 331, -1, 1435, -1, 1371, 37, 1122, 1374, + -1, 493, -1, 1373, 496, 344, 498, 499, -1, 348, + -1, -1, 351, -1, -1, 1456, -1, -1, 153, 1143, + 60, 888, 1463, 220, 1465, 65, 1150, 1468, 1469, 69, + -1, -1, 310, -1, -1, -1, 76, 77, -1, -1, + 318, -1, 239, 321, 1419, -1, -1, 244, 65, 1424, + 67, -1, 69, 1494, -1, 1496, -1, -1, 397, 76, + 77, 101, -1, 103, -1, 1506, -1, -1, 732, -1, + 562, 111, 411, -1, -1, 1450, 211, 416, 1233, 1520, + -1, -1, -1, -1, 101, 424, 103, -1, -1, -1, + -1, -1, -1, -1, 111, -1, -1, -1, -1, 377, + 1224, 1225, 1226, 381, -1, -1, -1, 1262, -1, -1, + -1, 450, 247, -1, 453, 1239, 251, -1, 1273, 1274, + 1275, -1, 10, 11, 12, 13, 14, 994, -1, 468, + -1, 470, 267, -1, 331, -1, -1, -1, -1, 478, + 65, -1, 67, 482, 69, -1, -1, 1522, -1, 37, + -1, 76, 77, 1528, 351, -1, 10, 11, 12, 13, + 14, -1, 1537, -1, -1, -1, 1541, -1, 1323, -1, + -1, 510, 60, -1, -1, 1042, 101, 65, 103, 67, + -1, 69, -1, 37, -1, -1, 111, 465, 76, 77, + 65, -1, 67, 68, 69, 330, 1320, 1321, 1322, -1, + 397, 76, 77, -1, -1, -1, 60, -1, -1, -1, + 1334, -1, -1, 101, 411, 103, 555, -1, -1, 416, + -1, -1, -1, 111, -1, -1, 101, 424, 25, 26, + 27, 570, -1, 572, 898, -1, -1, -1, -1, -1, + -1, 580, -1, -1, -1, -1, 585, 101, -1, 103, + -1, -1, -1, 450, -1, -1, -1, 111, -1, -1, + 1384, -1, -1, -1, 603, -1, 1390, -1, -1, 608, + -1, 468, -1, 470, 409, 614, 554, 555, -1, 618, + 619, -1, -1, 10, 11, 12, 13, 14, -1, -1, + -1, 426, -1, -1, 633, -1, 93, -1, 95, 1166, + -1, -1, -1, -1, -1, -1, -1, 1431, -1, -1, + 37, 1435, 651, 510, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 459, 664, -1, -1, 992, -1, + -1, -1, 671, 60, -1, 674, -1, -1, 65, -1, + 67, 1465, 69, -1, 1468, 1469, -1, 123, -1, 76, + 77, -1, 10, 11, 12, 13, 14, -1, -1, -1, + 638, -1, -1, -1, 642, -1, -1, -1, 707, -1, + 1494, 710, 1496, 570, 101, -1, 173, -1, -1, 37, + 719, -1, -1, 722, 111, 182, 183, -1, 666, -1, + 187, -1, 189, 190, -1, -1, 1520, -1, -1, -1, + 678, -1, 60, -1, -1, 744, -1, 65, -1, 67, + 749, 69, -1, -1, -1, -1, -1, -1, 76, 77, + -1, 618, 619, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 0, -1, -1, 633, -1, -1, -1, + 575, -1, -1, 101, -1, 103, -1, 786, -1, -1, + -1, -1, -1, 111, 651, 947, -1, 796, -1, -1, + -1, -1, 801, 802, 31, -1, -1, 664, -1, 808, + 605, -1, -1, 812, 671, 610, -1, -1, -1, -1, + -1, -1, 821, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 64, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 707, -1, 790, 710, 853, -1, -1, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 873, -1, 29, 30, 31, -1, + -1, -1, -1, -1, 37, -1, -1, 744, -1, -1, + -1, -1, -1, 10, 11, 12, 13, 14, 897, -1, + 1224, -1, -1, 698, 903, -1, -1, 60, -1, -1, + -1, -1, 65, -1, 67, 68, 69, 712, -1, -1, + 37, -1, 149, 76, 77, -1, -1, -1, -1, 786, + -1, -1, -1, -1, -1, -1, -1, 732, 937, 796, + -1, -1, -1, 60, 801, 802, 945, 946, 101, -1, + 103, -1, -1, -1, -1, 812, -1, -1, 111, -1, + -1, 960, -1, -1, 902, 903, -1, -1, -1, -1, + -1, -1, 910, -1, -1, 974, -1, 0, -1, 10, + 11, 12, 13, 14, 101, -1, 103, -1, -1, -1, + -1, -1, -1, 992, 111, 994, -1, -1, -1, 10, + 11, 12, 13, 14, -1, 800, 37, -1, 31, -1, + -1, -1, 239, 1012, -1, -1, 873, 244, -1, 1018, + 1019, -1, 1021, 1022, 1023, -1, 37, -1, -1, 60, + -1, -1, -1, -1, 65, -1, 67, -1, 69, -1, + 897, 64, -1, 1042, -1, 76, 77, -1, 986, 60, + -1, -1, -1, -1, 65, -1, -1, -1, 69, -1, + 1384, -1, -1, -1, -1, 76, 77, 1005, -1, 1393, + 101, -1, 103, 1225, -1, -1, 1075, 1076, -1, -1, + 111, -1, -1, -1, -1, -1, -1, 1086, 1087, -1, + 101, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 111, 558, 559, 960, 331, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 1122, 351, -1, 149, -1, -1, 586, + -1, -1, 589, 590, -1, 592, -1, 594, 595, -1, + -1, -1, 599, 600, 1143, 1083, 1145, -1, -1, -1, + 1088, 1150, 1151, 1152, -1, -1, -1, -1, -1, -1, + -1, 1018, 1019, -1, 1021, 1022, 1023, -1, -1, -1, + 397, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 411, 1042, -1, -1, -1, 416, + -1, -1, -1, -1, 1193, -1, -1, 424, -1, -1, + -1, -1, 997, -1, -1, -1, -1, -1, -1, -1, + -1, 1210, -1, -1, -1, 1214, 239, -1, 1075, 1076, + -1, 244, -1, 450, -1, 1224, 683, 684, -1, 1086, + -1, -1, 689, -1, 1233, -1, 1235, -1, -1, -1, + 1239, 468, -1, 470, -1, -1, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 1262, -1, 29, 30, 31, -1, -1, + -1, -1, -1, 37, 1273, 1274, 1275, -1, -1, -1, + -1, -1, -1, 510, -1, -1, 1285, 1286, 1145, -1, + -1, -1, -1, -1, 1151, 1152, 60, -1, -1, -1, + 1299, 65, -1, 67, 68, -1, -1, -1, 331, -1, + -1, -1, -1, 1465, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 1322, 1323, -1, -1, -1, 351, -1, + -1, -1, -1, -1, -1, 1334, 1193, -1, -1, 103, + -1, -1, 1494, 570, -1, -1, -1, 111, -1, -1, + -1, -1, -1, 1210, -1, -1, -1, 1214, -1, 0, + -1, -1, -1, -1, -1, -1, -1, -1, 1520, -1, + -1, -1, -1, -1, 397, -1, 1233, -1, 1235, -1, + -1, -1, -1, -1, -1, 1384, -1, -1, 411, -1, + 31, 618, 619, 416, -1, -1, -1, 1192, -1, -1, + -1, 424, -1, -1, -1, 1262, 633, -1, -1, -1, + -1, -1, 1411, -1, -1, -1, 1273, 1274, 1275, -1, + -1, -1, -1, 64, 651, -1, -1, 450, 1285, 1286, + -1, -1, -1, -1, -1, -1, 1435, 664, -1, -1, + -1, -1, 1299, -1, 671, 468, -1, 470, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 1456, -1, -1, + -1, -1, -1, -1, 1463, -1, 1323, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 707, -1, -1, 710, -1, -1, -1, 510, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 1294, + -1, 0, 1, -1, -1, -1, -1, 1506, 149, -1, + -1, -1, -1, -1, 1513, -1, -1, 744, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 31, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 25, 26, 27, -1, 570, -1, -1, + -1, -1, -1, -1, 1411, -1, -1, -1, -1, 786, + -1, -1, 61, -1, -1, 64, -1, -1, -1, 796, + -1, -1, -1, -1, 801, 802, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 812, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 618, 619, -1, 239, 1456, + -1, -1, -1, 244, -1, -1, 1463, -1, -1, -1, + 633, 93, -1, 95, -1, -1, -1, -1, -1, -1, + 1077, -1, -1, -1, -1, -1, -1, -1, 651, -1, + -1, -1, -1, -1, -1, -1, -1, 119, -1, -1, + -1, 664, -1, -1, -1, -1, 873, -1, 671, 1506, + 149, -1, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + 897, -1, -1, -1, -1, -1, -1, -1, -1, 37, + -1, -1, -1, -1, 707, -1, -1, 710, -1, -1, + 331, 173, -1, -1, -1, -1, -1, -1, 180, -1, + 182, 183, 60, -1, -1, 187, -1, 189, 190, -1, + 351, -1, 211, 71, -1, -1, -1, -1, -1, -1, + -1, 744, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 960, -1, -1, -1, -1, -1, -1, + 239, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 1211, -1, 397, -1, -1, -1, + -1, -1, -1, 786, -1, -1, -1, -1, -1, -1, + 411, -1, -1, 796, 256, 416, -1, -1, 801, 802, + -1, -1, -1, 424, -1, -1, -1, -1, -1, 812, + -1, 1018, 1019, -1, 1021, 1022, 1023, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 450, + -1, 61, -1, -1, -1, 1042, -1, -1, -1, -1, + -1, 71, -1, 73, -1, 75, -1, 468, -1, 470, + -1, -1, 82, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 1075, 1076, + 873, -1, 351, -1, -1, -1, -1, -1, -1, 1086, + -1, 111, -1, 113, 114, 115, -1, -1, -1, 510, + -1, -1, -1, -1, 897, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 139, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 153, -1, -1, -1, -1, -1, -1, + -1, -1, 411, -1, 48, -1, 50, -1, 1145, 53, + 54, 55, -1, 57, 1151, 1152, -1, -1, -1, 570, + -1, -1, -1, -1, -1, -1, -1, 960, 72, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 83, + 84, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 211, -1, 213, 214, 215, 1193, -1, -1, -1, + -1, 470, -1, -1, -1, -1, -1, 618, 619, -1, + -1, -1, -1, 1210, -1, -1, -1, 1214, -1, -1, + -1, -1, 633, -1, -1, 1018, 1019, 247, 1021, 1022, + 1023, 251, -1, -1, -1, -1, 1233, -1, 1235, -1, + 651, 510, -1, -1, -1, 149, -1, 267, -1, 1042, + -1, -1, -1, 664, -1, -1, -1, -1, -1, -1, + 671, -1, -1, -1, -1, 1262, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 1273, 1274, 1275, -1, + -1, -1, 1075, 1076, -1, -1, -1, -1, 1285, 1286, + -1, -1, -1, 1086, -1, 315, 707, -1, -1, 710, + -1, 570, 1299, -1, -1, -1, 558, 559, -1, -1, + 330, -1, -1, -1, -1, 335, 336, -1, -1, -1, + -1, -1, -1, 343, -1, -1, 1323, -1, -1, -1, + -1, -1, -1, 744, 586, -1, -1, 589, 590, -1, + 592, -1, 594, 595, -1, -1, -1, 599, 600, 618, + 619, -1, 1145, -1, -1, -1, -1, -1, 1151, 1152, + -1, -1, -1, -1, 633, 385, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 786, -1, -1, -1, -1, + -1, -1, -1, 403, -1, 796, -1, -1, -1, 409, + 801, 802, -1, -1, -1, -1, -1, -1, -1, -1, + 1193, 812, -1, -1, -1, -1, 426, -1, -1, 429, + 430, -1, -1, -1, 1411, -1, -1, 1210, -1, -1, + 324, 1214, 326, -1, -1, 445, 678, -1, -1, -1, + -1, 683, 684, 337, 338, -1, -1, 689, -1, 459, + 1233, 710, 1235, -1, -1, -1, 466, 351, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 1456, + -1, 36, 873, 38, -1, -1, 1463, -1, -1, 1262, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 1273, 1274, 1275, -1, 59, -1, 897, -1, -1, -1, + 65, -1, 1285, 1286, 69, -1, -1, 72, 73, 74, + 75, 76, 77, -1, 79, 80, 1299, 411, -1, 1506, + -1, -1, 87, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 101, -1, 103, -1, + 1323, 106, -1, 802, -1, 110, 111, 112, 113, 114, + 115, -1, -1, -1, -1, -1, -1, -1, -1, 960, + -1, -1, -1, -1, -1, 575, -1, 0, -1, -1, + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, -1, 605, 29, 30, 31, 32, + 610, -1, 35, -1, 37, 38, -1, -1, -1, -1, + -1, -1, -1, -1, 873, -1, 510, 1018, 1019, -1, + 1021, 1022, 1023, -1, 57, -1, -1, 60, 1411, -1, + -1, -1, 65, -1, 67, 68, 69, -1, 897, -1, + -1, 1042, -1, 76, 77, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, -1, -1, -1, -1, -1, 101, -1, + 103, -1, 37, 1456, 1075, 1076, 570, -1, 111, -1, + 1463, -1, -1, -1, -1, 1086, -1, 946, 698, -1, + -1, -1, 36, -1, 38, 60, -1, -1, -1, -1, + -1, 960, 712, -1, -1, -1, 71, -1, -1, -1, + -1, -1, -1, -1, -1, 59, -1, -1, -1, -1, + -1, 65, 732, 1506, -1, 69, -1, 621, 72, 73, + 74, 75, 76, 77, -1, 79, 80, -1, -1, -1, + -1, -1, -1, 87, 1145, -1, -1, -1, -1, -1, + 1151, 1152, -1, -1, -1, 649, -1, 101, -1, 103, + -1, -1, 1021, 1022, 1023, 109, 110, 111, 112, 113, + 114, 115, -1, 667, 668, -1, -1, 671, -1, -1, + 790, -1, -1, 1042, -1, -1, -1, -1, -1, -1, + 800, -1, 1193, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 699, -1, 701, -1, 1210, + -1, -1, 822, 1214, 708, 709, -1, -1, -1, 713, + -1, -1, -1, -1, -1, -1, -1, 1086, -1, -1, + -1, 725, 1233, -1, 1235, 1077, 730, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 744, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 754, 1262, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 1273, 1274, 1275, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 1285, 1286, -1, -1, -1, -1, + -1, -1, 1151, 1152, -1, -1, -1, -1, 1299, -1, + -1, -1, -1, -1, -1, 915, -1, -1, 802, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 1323, -1, -1, -1, -1, 821, -1, -1, + -1, 941, -1, 1192, 1193, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 1210, -1, -1, -1, 1214, -1, 967, -1, -1, + 854, -1, 856, 857, 858, -1, -1, 861, 862, 1211, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 1239, -1, 876, -1, -1, -1, -1, 997, -1, -1, + -1, -1, -1, -1, 888, -1, -1, 891, -1, -1, + -1, -1, -1, 897, 1014, -1, -1, -1, -1, -1, + 1411, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 1285, 1286, -1, -1, + -1, -1, -1, -1, -1, 1294, -1, -1, -1, -1, + 1299, 935, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 1456, -1, -1, -1, -1, + -1, -1, 1463, -1, -1, -1, 960, -1, -1, -1, + -1, -1, -1, 1083, -1, 1334, -1, -1, -1, 973, + -1, -1, -1, -1, 978, -1, 41, 981, -1, -1, + 1100, 985, -1, -1, -1, -1, 990, -1, -1, -1, + 994, 995, 996, -1, -1, 1506, -1, -1, -1, -1, + 1004, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 1014, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 86, -1, -1, -1, -1, -1, -1, -1, 1033, + 1034, 96, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 1411, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 1058, -1, -1, 1061, -1, -1, + -1, -1, -1, -1, -1, -1, 1435, -1, -1, -1, + -1, -1, 1192, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 1086, -1, -1, 150, -1, 1456, -1, -1, + -1, -1, -1, -1, 1463, -1, -1, -1, 163, -1, + -1, 1105, -1, -1, -1, -1, -1, 1111, 1112, -1, + -1, -1, -1, -1, -1, -1, 1120, -1, -1, -1, + 185, -1, 1126, -1, -1, 1129, -1, 1131, -1, -1, + 1134, -1, -1, -1, 199, -1, -1, 1506, -1, -1, + -1, 1145, 207, -1, -1, 1149, -1, -1, -1, -1, + -1, -1, 217, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 1166, 228, 1168, 1169, 1170, 1171, -1, -1, + -1, -1, -1, -1, 1294, 240, -1, -1, -1, -1, + 245, 1185, -1, 1187, -1, -1, -1, 1191, -1, -1, + -1, -1, -1, 258, -1, -1, -1, -1, -1, 264, + -1, 266, -1, -1, -1, -1, 1210, -1, -1, -1, + -1, -1, -1, -1, -1, 1219, 1220, 282, -1, -1, + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 27, -1, 29, 30, 31, 32, + -1, -1, 35, -1, 37, -1, -1, -1, 323, -1, + -1, -1, -1, -1, -1, -1, 1270, 1271, -1, -1, + -1, -1, 1276, 1277, -1, -1, -1, 60, -1, -1, + -1, -1, -1, 1287, 67, 68, -1, 352, 71, -1, + -1, 356, 357, -1, 359, -1, -1, -1, -1, -1, + 365, 366, -1, 368, 369, -1, 371, -1, 373, -1, + -1, -1, 7, -1, -1, 10, 11, 12, 13, 14, + 103, -1, -1, -1, -1, 390, -1, -1, 111, -1, + -1, -1, -1, 398, 1338, -1, -1, -1, -1, -1, + -1, 36, 37, 38, -1, -1, 1350, -1, -1, -1, + 1354, 1355, 1356, -1, -1, -1, -1, 422, -1, -1, + -1, -1, 1366, -1, 59, 60, -1, -1, 433, -1, + 65, 1375, -1, -1, 69, -1, -1, 72, 73, 74, + 75, 76, 77, -1, 79, 80, -1, 1391, -1, -1, + -1, 456, 87, -1, -1, -1, -1, 462, -1, -1, + -1, -1, 467, -1, -1, -1, 101, -1, 103, -1, + -1, -1, -1, 1533, -1, 110, 111, 112, 113, 114, + 115, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 503, 1443, + 1444, -1, -1, -1, -1, -1, -1, 149, -1, -1, + -1, -1, 1456, 518, -1, -1, -1, -1, -1, 1463, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 180, 29, + 30, 31, -1, -1, -1, 187, 1490, 37, -1, 554, + -1, -1, -1, -1, -1, -1, -1, -1, 563, -1, + 565, -1, -1, -1, -1, -1, 571, -1, -1, -1, + 60, -1, -1, -1, 1518, -1, -1, 67, 68, 584, + -1, 71, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 1543, + -1, -1, -1, -1, 1548, -1, -1, -1, -1, -1, + -1, 101, -1, 103, 256, -1, -1, -1, 623, -1, + -1, 111, -1, -1, -1, -1, -1, -1, -1, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, -1, 659, 29, 30, 31, 32, -1, + -1, 35, -1, 37, 38, -1, -1, -1, 310, -1, + -1, -1, -1, -1, -1, -1, 318, 319, -1, 321, + 322, -1, 324, 57, -1, -1, 60, 329, -1, -1, + -1, 65, -1, 67, 68, 69, -1, -1, -1, -1, + -1, -1, 76, 77, -1, -1, 348, -1, -1, 351, + -1, 716, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 726, 727, -1, -1, -1, -1, 101, -1, 103, + -1, -1, -1, 738, -1, 377, -1, 111, -1, 381, + -1, -1, 7, -1, -1, 10, 11, 12, 13, 14, + 755, -1, 757, -1, -1, -1, 761, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 411, + -1, 36, 37, 38, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, -1, 434, -1, 59, 60, -1, -1, -1, -1, + 65, 37, -1, -1, 69, -1, -1, 72, 73, 74, + 75, 76, 77, -1, 79, 80, -1, -1, -1, -1, + -1, 826, 87, 465, 60, -1, 468, -1, 833, -1, + -1, -1, -1, -1, -1, -1, 101, -1, 103, -1, + -1, 846, -1, 848, -1, 110, 111, 112, 113, 114, + 115, -1, -1, -1, -1, -1, -1, -1, 863, -1, + -1, -1, -1, -1, 869, 507, -1, -1, 510, -1, + -1, -1, -1, -1, -1, -1, 881, -1, -1, 884, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 902, -1, -1, + -1, -1, -1, 908, -1, -1, -1, -1, -1, -1, + -1, -1, 554, 555, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 140, -1, 570, -1, + 572, -1, -1, -1, -1, 149, -1, -1, 580, -1, + -1, 583, -1, 585, 586, -1, -1, 161, -1, -1, + 592, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 602, 603, -1, -1, -1, -1, 608, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 618, 619, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 993, -1, + -1, 633, -1, -1, 999, 1000, 638, 639, -1, -1, + 642, 643, -1, -1, -1, -1, -1, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 666, -1, 29, 30, 31, 671, + 672, -1, 674, -1, 37, -1, 678, -1, 252, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 1055, -1, -1, -1, -1, -1, 1061, 60, -1, -1, + -1, -1, -1, -1, 67, 68, -1, -1, 710, 711, + -1, -1, -1, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, 1096, 29, 30, 31, -1, 1101, -1, -1, -1, + 37, -1, 744, -1, 1109, -1, 748, 749, 111, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 60, -1, -1, -1, -1, 65, -1, + 67, 68, 69, 1138, 71, -1, -1, 351, -1, 76, + 77, -1, -1, -1, -1, -1, 360, -1, 790, -1, + 1155, -1, -1, 1158, -1, 1160, -1, -1, -1, -1, + 802, -1, -1, -1, 101, -1, 103, -1, -1, 811, + -1, 813, 1177, 1178, 111, -1, -1, -1, -1, -1, + 822, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 1198, -1, -1, 410, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 853, -1, -1, -1, -1, -1, 431, -1, -1, + -1, -1, -1, -1, -1, 1230, -1, -1, -1, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 460, -1, 29, 30, + 31, -1, -1, -1, -1, 897, 37, 38, -1, -1, + 902, 903, -1, -1, -1, -1, -1, -1, 910, -1, + -1, -1, -1, 915, -1, -1, -1, -1, -1, 60, + -1, 923, -1, -1, 498, -1, 67, 68, -1, -1, + -1, -1, -1, -1, 936, 937, 510, -1, -1, -1, + -1, -1, -1, 517, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 530, 531, 960, -1, + -1, -1, 103, -1, 1329, 967, 1331, -1, -1, -1, + 111, -1, 974, -1, -1, -1, -1, 1342, 552, 1344, + -1, -1, -1, -1, 986, 987, -1, -1, 562, -1, + 992, -1, 994, -1, -1, 36, 570, 38, -1, 1364, + -1, -1, -1, 1005, 1006, -1, 1008, 1009, 1010, -1, + -1, -1, -1, -1, -1, 1380, -1, -1, 59, 1021, + 1022, 1023, -1, -1, 65, -1, -1, 1392, 69, -1, + 1395, 72, 73, 74, 75, 76, 77, -1, 79, 80, + -1, -1, -1, -1, -1, -1, 87, 621, -1, -1, + -1, -1, 1417, -1, 628, -1, -1, -1, -1, -1, + 101, 1426, 103, -1, 1429, 1430, -1, -1, -1, 110, + 111, 112, 113, 114, 115, 649, 1078, -1, -1, -1, + -1, 1083, -1, 124, 1086, 1087, 1088, 1089, -1, 268, + 269, 270, 271, -1, -1, -1, -1, 671, 1100, 278, + 279, -1, 1467, -1, 283, 284, 1471, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 295, -1, 1483, -1, + 1122, -1, -1, 36, -1, 38, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 1145, -1, 324, 59, -1, 1150, 1151, + 1152, -1, 65, -1, 67, 68, 69, -1, -1, 72, + 73, 74, 75, 76, 77, -1, 79, 80, -1, -1, + 744, -1, 746, -1, 87, -1, -1, -1, 752, -1, + -1, -1, 361, -1, -1, -1, 760, -1, 101, -1, + 103, -1, 105, 106, -1, -1, -1, 110, 111, 112, + 113, 114, 115, -1, -1, -1, -1, -1, 1210, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 1224, 797, -1, -1, 800, 801, 802, -1, + -1, -1, -1, 1235, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 821, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, -1, -1, 29, 30, 31, + 32, 33, 34, -1, 36, 37, 38, -1, -1, -1, + -1, -1, -1, 1285, 1286, -1, -1, -1, 862, -1, + -1, -1, 866, -1, -1, -1, -1, 59, 60, -1, + -1, -1, -1, 65, -1, 67, 68, 69, -1, -1, + 72, 73, 74, 75, 76, 77, -1, 79, 80, -1, + 1322, -1, -1, 897, -1, 87, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 101, + -1, 103, -1, -1, -1, -1, -1, -1, 110, 111, + 112, 113, 114, 115, 533, 534, 535, 536, 537, 538, + 539, 540, 541, 542, 543, 544, 545, 546, 547, 548, + 549, 550, -1, 947, 36, -1, 38, -1, -1, -1, + -1, -1, 1384, -1, -1, -1, 960, 961, -1, -1, + -1, -1, -1, 572, 968, -1, -1, 59, -1, -1, + -1, 975, -1, 65, 978, -1, 980, 69, -1, 1411, + 72, 73, 74, 75, 76, 77, -1, 79, 80, -1, + -1, -1, -1, 997, -1, 87, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 101, + 1014, 103, -1, -1, -1, -1, 108, -1, 110, 111, + 112, 113, 114, 115, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 1037, -1, 1039, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 1054, -1, -1, -1, 36, -1, 38, -1, -1, 1491, + -1, -1, -1, -1, 673, -1, -1, -1, -1, 1073, + -1, -1, -1, -1, -1, -1, -1, 59, -1, -1, + 1512, 1513, 1086, 65, -1, -1, 695, 69, -1, -1, + 72, 73, 74, 75, 76, 77, -1, 79, 80, 708, + -1, 1533, -1, -1, -1, 87, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 101, + 1124, 103, -1, -1, 106, -1, -1, -1, 110, 111, + 112, 113, 114, 115, -1, -1, -1, -1, -1, -1, + -1, 1145, 751, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 1163, + -1, 1165, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 783, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, -1, + -1, 29, 30, 31, -1, -1, 1210, -1, -1, 37, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 1225, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 60, -1, -1, -1, -1, -1, -1, 67, + 68, -1, -1, -1, 1248, -1, -1, -1, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, -1, -1, 29, 30, 31, 32, 106, 888, + 35, 36, 37, 38, 39, -1, 41, -1, -1, 44, + 45, 46, 47, 48, 49, 50, 51, -1, 53, -1, + -1, 56, 57, -1, 59, 60, -1, -1, -1, -1, + 65, -1, 67, 68, 69, -1, -1, 72, 73, 74, + 75, 76, 77, -1, 79, 80, -1, -1, -1, -1, + -1, -1, 87, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 101, -1, 103, -1, + -1, 106, -1, -1, -1, 110, 111, 112, 113, 114, + 115, -1, -1, -1, -1, -1, -1, -1, -1, 124, + -1, -1, -1, -1, -1, 984, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 994, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 1400, -1, -1, -1, + -1, -1, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, -1, -1, 29, 30, + 31, 32, -1, 1042, 35, 36, 37, 38, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 59, 60, + -1, -1, -1, -1, 65, -1, 67, 68, 69, -1, + 1474, 72, 73, 74, 75, 76, 77, -1, 79, 80, + -1, -1, -1, -1, -1, -1, 87, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 101, -1, 103, -1, -1, -1, -1, 1116, -1, 110, + 111, 112, 113, 114, 115, -1, 1520, -1, -1, -1, + -1, -1, -1, 124, -1, -1, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + -1, -1, 29, 30, 31, 32, -1, 1166, 35, 36, + 37, 38, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 1181, 1182, -1, -1, -1, -1, -1, -1, + -1, -1, 59, 60, -1, -1, -1, -1, 65, -1, + 67, 68, 69, -1, -1, 72, 73, 74, 75, 76, + 77, -1, 79, 80, -1, -1, -1, -1, -1, -1, + 87, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 101, -1, 103, -1, -1, -1, + -1, -1, -1, 110, 111, 112, 113, 114, 115, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, -1, -1, 29, 30, 31, -1, -1, -1, + -1, 36, 37, 38, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 59, 60, -1, -1, -1, -1, + 65, -1, 67, 68, 69, -1, -1, 72, 73, 74, + 75, 76, 77, -1, 79, 80, -1, -1, -1, -1, + -1, -1, 87, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 101, -1, 103, 104, + -1, -1, -1, 108, -1, 110, 111, 112, 113, 114, + 115, -1, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, -1, -1, 29, 30, 31, + -1, -1, -1, -1, 36, 37, 38, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 1415, 59, 60, -1, + -1, -1, -1, 65, -1, 67, 68, 69, -1, -1, + 72, 73, 74, 75, 76, 77, -1, 79, 80, -1, + -1, -1, -1, -1, -1, 87, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 101, + -1, 103, 104, -1, -1, -1, 108, -1, 110, 111, + 112, 113, 114, 115, -1, -1, -1, -1, -1, 1478, + 1479, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, -1, -1, 29, 30, 31, -1, + -1, -1, -1, 36, 37, 38, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 59, 60, -1, -1, + -1, -1, 65, -1, 67, 68, 69, -1, -1, 72, + 73, 74, 75, 76, 77, -1, 79, 80, -1, -1, + -1, -1, -1, -1, 87, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 101, -1, + 103, 104, -1, -1, -1, 108, -1, 110, 111, 112, + 113, 114, 115, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, -1, -1, 29, 30, + 31, -1, -1, -1, -1, 36, 37, 38, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 59, 60, + -1, -1, -1, -1, 65, -1, 67, 68, 69, -1, + -1, 72, 73, 74, 75, 76, 77, -1, 79, 80, + -1, -1, -1, -1, -1, -1, 87, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 101, -1, 103, 104, -1, -1, -1, -1, -1, 110, + 111, 112, 113, 114, 115, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, -1, -1, + 29, 30, 31, -1, -1, -1, -1, 36, 37, 38, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 59, 60, -1, -1, -1, -1, 65, -1, 67, 68, + 69, -1, -1, 72, 73, 74, 75, 76, 77, -1, + 79, 80, -1, -1, -1, -1, -1, -1, 87, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 101, -1, 103, 104, -1, -1, -1, -1, + -1, 110, 111, 112, 113, 114, 115, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + -1, -1, 29, 30, 31, -1, -1, -1, -1, 36, + 37, 38, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 59, 60, -1, -1, -1, -1, 65, -1, + 67, 68, 69, -1, -1, 72, 73, 74, 75, 76, + 77, -1, 79, 80, -1, -1, -1, -1, -1, -1, + 87, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 101, -1, 103, -1, -1, -1, + -1, -1, -1, 110, 111, 112, 113, 114, 115, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, -1, -1, 29, 30, 31, -1, -1, -1, + -1, 36, 37, 38, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 59, 60, -1, -1, -1, -1, + 65, -1, 67, 68, 69, -1, -1, 72, 73, 74, + 75, 76, 77, -1, 79, 80, -1, -1, -1, -1, + -1, -1, 87, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 101, -1, 103, -1, + -1, -1, -1, -1, -1, 110, 111, 112, 113, 114, + 115, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, -1, -1, 29, 30, 31, + 32, -1, -1, 35, -1, 37, 38, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 57, -1, -1, 60, -1, + -1, -1, -1, 65, -1, 67, 68, 69, -1, -1, + -1, -1, -1, -1, 76, 77, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 101, + -1, 103, -1, -1, -1, 107, -1, -1, -1, 111, + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, -1, -1, 29, 30, 31, -1, + -1, -1, -1, -1, 37, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 60, -1, -1, + -1, -1, 65, -1, 67, 68, 69, -1, -1, -1, + -1, -1, -1, 76, 77, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 101, -1, + 103, -1, -1, -1, -1, -1, -1, -1, 111, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, -1, -1, 29, 30, 31, 32, -1, + -1, 35, -1, 37, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 60, -1, -1, -1, + -1, -1, -1, 67, 68, -1, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + -1, -1, 29, 30, 31, -1, -1, -1, -1, 103, + 37, -1, -1, -1, -1, -1, -1, 111, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 60, -1, -1, -1, -1, -1, -1, + 67, 68, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, -1, -1, 29, 30, 31, + -1, -1, -1, -1, -1, 37, 103, -1, -1, -1, + -1, -1, -1, -1, 111, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 60, -1, + -1, -1, -1, 65, -1, 67, 68, 69, -1, -1, + -1, -1, -1, -1, 76, 77, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 101, + -1, 103, -1, -1, -1, -1, -1, -1, -1, 111, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, -1, -1, 29, 30, 31, -1, -1, + -1, -1, -1, 37, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 60, -1, -1, -1, + -1, -1, -1, 67, 68, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, -1, -1, + 29, 30, 31, -1, -1, -1, -1, -1, 37, 103, + 104, -1, -1, -1, -1, -1, -1, 111, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 60, -1, -1, -1, -1, -1, -1, 67, 68, + -1, -1, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, -1, -1, 29, 30, 31, + -1, -1, -1, 102, 103, 37, -1, -1, -1, -1, + -1, -1, 111, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 60, -1, + -1, -1, -1, -1, -1, 67, 68, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 89, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 103, -1, -1, -1, -1, -1, -1, -1, 111, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, -1, -1, 29, 30, 31, -1, -1, + -1, -1, -1, 37, -1, -1, -1, -1, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, -1, 60, 29, 30, 31, + -1, -1, -1, 67, 68, 37, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 89, -1, -1, 60, -1, + -1, -1, -1, 65, -1, 67, 68, 69, -1, 103, + -1, -1, -1, -1, 76, 77, -1, 111, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 103, -1, 29, 30, 31, -1, -1, -1, 111, + -1, 37, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 60, -1, -1, -1, -1, -1, + -1, 67, 68, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, -1, -1, 29, 30, + 31, -1, -1, -1, -1, -1, 37, 103, -1, -1, + -1, -1, -1, -1, -1, 111, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 60, + -1, -1, -1, -1, -1, -1, 67, 68, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, -1, -1, 29, 30, 31, -1, -1, -1, -1, + -1, 37, 103, -1, -1, -1, -1, -1, -1, -1, + 111, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 60, -1, -1, -1, -1, -1, + -1, 67, 68, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, -1, -1, 29, 30, + 31, -1, -1, -1, -1, -1, 37, 103, -1, -1, + -1, -1, -1, -1, -1, 111, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 60, + -1, -1, -1, -1, -1, -1, 67, 68, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, -1, -1, 29, 30, 31, + -1, -1, -1, -1, 36, 37, 38, -1, -1, -1, + -1, -1, 103, -1, -1, -1, -1, -1, -1, -1, + 111, -1, -1, -1, -1, -1, -1, 59, 60, -1, + -1, -1, -1, 65, -1, 67, 68, 69, -1, -1, + 72, 73, 74, 75, 76, 77, -1, 79, 80, -1, + -1, -1, -1, -1, -1, 87, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 101, + -1, 103, -1, -1, 106, -1, -1, -1, 110, 111, + 112, 113, 114, 115, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, -1, -1, 29, 30, 31, -1, -1, -1, -1, + 36, 37, 38, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 59, 60, -1, -1, -1, -1, 65, + -1, 67, 68, 69, -1, -1, 72, 73, 74, 75, + 76, 77, -1, 79, 80, -1, -1, -1, -1, -1, + -1, 87, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 101, -1, 103, 104, -1, + -1, -1, -1, -1, 110, 111, 112, 113, 114, 115, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, -1, -1, 29, + 30, 31, -1, -1, -1, -1, 36, 37, 38, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 59, + 60, -1, -1, -1, -1, 65, -1, 67, 68, 69, + -1, -1, 72, 73, 74, 75, 76, 77, -1, 79, + 80, -1, -1, -1, -1, -1, -1, 87, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 101, 102, 103, -1, -1, -1, -1, -1, -1, + 110, 111, 112, 113, 114, 115, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, -1, -1, 29, 30, 31, -1, -1, + -1, -1, 36, 37, 38, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 59, 60, -1, -1, -1, + -1, 65, -1, 67, 68, 69, -1, -1, 72, 73, + 74, 75, 76, 77, -1, 79, 80, -1, -1, -1, + -1, -1, -1, 87, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 101, -1, 103, + -1, -1, -1, -1, -1, -1, 110, 111, 112, 113, + 114, 115, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, -1, + -1, 29, 30, 31, -1, -1, -1, -1, 36, 37, + 38, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 59, 60, -1, -1, -1, -1, 65, -1, 67, + 68, 69, -1, -1, 72, 73, 74, 75, 76, 77, + -1, 79, 80, -1, -1, -1, -1, -1, -1, 87, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 101, -1, 103, -1, -1, -1, -1, + -1, -1, 110, 111, 112, 113, 114, 115, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, -1, -1, 29, 30, 31, + -1, -1, -1, -1, 36, 37, 38, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 59, 60, -1, + -1, -1, -1, 65, -1, 67, 68, 69, -1, -1, + 72, 73, 74, 75, 76, 77, -1, 79, 80, -1, + -1, -1, -1, -1, -1, 87, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 101, + -1, 103, -1, -1, -1, -1, -1, -1, 110, 111, + 112, 113, 114, 115, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, -1, -1, 29, 30, 31, -1, -1, -1, -1, + 36, 37, 38, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 59, 60, -1, -1, -1, -1, 65, + -1, 67, 68, 69, -1, -1, 72, 73, 74, 75, + 76, 77, -1, 79, 80, -1, -1, -1, -1, -1, + -1, 87, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 101, -1, 103, -1, -1, + -1, -1, -1, -1, 110, 111, 112, 113, 114, 115, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, -1, 29, + 30, 31, -1, -1, -1, -1, -1, 37, -1, -1, + -1, -1, -1, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 60, -1, 29, 30, 31, 65, -1, 67, 68, 69, + 37, 71, -1, -1, -1, -1, 76, 77, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 60, -1, -1, -1, -1, 65, -1, + 67, 68, 69, 103, -1, -1, -1, -1, -1, 76, + 77, 111, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, -1, + -1, 29, 30, 31, 101, -1, 103, -1, -1, 37, + -1, -1, -1, -1, 111, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 60, -1, -1, -1, -1, 65, -1, 67, + 68, 69, -1, -1, -1, -1, -1, -1, 76, 77, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, -1, -1, 29, + 30, 31, -1, 101, -1, 103, -1, 37, -1, -1, + -1, -1, -1, 111, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 60, -1, -1, -1, -1, 65, -1, 67, 68, 69, + -1, -1, -1, -1, -1, -1, 76, 77, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, -1, 29, 30, 31, + -1, 101, -1, 103, -1, 37, -1, -1, -1, -1, + -1, 111, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 60, -1, + -1, -1, -1, -1, -1, 67, 68, -1, -1, 71, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, -1, -1, 29, + 30, 31, -1, -1, -1, -1, -1, 37, 38, 101, + -1, 103, -1, -1, -1, -1, -1, -1, -1, 111, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 60, -1, -1, -1, -1, -1, -1, 67, 68, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, -1, -1, 29, 30, + 31, -1, -1, -1, -1, -1, 37, 38, -1, -1, + -1, -1, -1, 103, -1, -1, -1, 107, -1, -1, + -1, 111, -1, -1, -1, -1, -1, -1, -1, 60, + -1, -1, -1, -1, -1, -1, 67, 68, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, -1, 29, 30, 31, + -1, -1, -1, -1, -1, 37, -1, -1, -1, -1, + -1, -1, 103, -1, -1, -1, 107, -1, -1, -1, + 111, -1, -1, -1, -1, -1, -1, -1, 60, -1, + -1, -1, -1, -1, -1, 67, 68, -1, -1, 71, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, -1, -1, 29, + 30, 31, -1, -1, -1, -1, -1, 37, 38, -1, + -1, 103, -1, -1, -1, -1, -1, -1, -1, 111, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 60, -1, -1, -1, -1, -1, -1, 67, 68, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, -1, -1, 29, 30, + 31, -1, -1, -1, -1, -1, 37, 38, -1, -1, + -1, -1, -1, 103, -1, -1, -1, 107, -1, -1, + -1, 111, -1, -1, -1, -1, -1, -1, -1, 60, + -1, -1, -1, -1, -1, -1, 67, 68, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, -1, -1, 29, 30, 31, + -1, -1, -1, -1, -1, 37, 38, -1, -1, -1, + -1, -1, 103, -1, -1, -1, 107, -1, -1, -1, + 111, -1, -1, -1, -1, -1, -1, -1, 60, -1, + -1, -1, -1, -1, -1, 67, 68, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, -1, -1, 29, 30, 31, -1, + -1, -1, -1, -1, 37, 38, -1, -1, -1, -1, + -1, 103, -1, -1, -1, 107, -1, -1, -1, 111, + -1, -1, -1, -1, -1, -1, -1, 60, -1, -1, + -1, -1, -1, -1, 67, 68, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, -1, -1, 29, 30, 31, -1, -1, + -1, -1, -1, 37, -1, -1, -1, -1, -1, -1, + 103, -1, -1, -1, 107, -1, -1, -1, 111, -1, + -1, -1, -1, -1, -1, -1, 60, -1, -1, -1, + -1, -1, -1, 67, 68, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, -1, -1, 29, 30, 31, -1, -1, -1, + -1, -1, 37, -1, -1, -1, -1, 101, -1, 103, + -1, -1, -1, -1, -1, -1, -1, 111, -1, -1, + -1, -1, -1, -1, -1, 60, -1, -1, -1, -1, + -1, -1, 67, 68, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, -1, -1, 29, 30, 31, -1, -1, -1, -1, + -1, 37, -1, -1, -1, -1, 101, -1, 103, -1, + -1, -1, -1, -1, -1, -1, 111, -1, -1, -1, + -1, -1, -1, -1, 60, -1, -1, -1, -1, -1, + -1, 67, 68, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + -1, -1, 29, 30, 31, -1, -1, -1, -1, -1, + 37, -1, -1, -1, -1, -1, -1, 103, -1, -1, + -1, -1, -1, -1, -1, 111, -1, -1, -1, -1, + -1, -1, -1, 60, -1, -1, -1, -1, -1, -1, + 67, 68, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, -1, + -1, 29, 30, 31, -1, -1, -1, -1, -1, 37, + -1, -1, -1, -1, -1, -1, 103, -1, -1, -1, + -1, -1, -1, -1, 111, -1, -1, -1, -1, -1, + -1, -1, 60, -1, -1, -1, -1, -1, -1, 67, + 68, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, -1, -1, + 29, 30, 31, -1, -1, -1, -1, -1, 37, -1, + -1, -1, -1, -1, -1, 103, -1, -1, -1, -1, + -1, -1, -1, 111, -1, -1, -1, -1, -1, -1, + -1, 60, -1, -1, -1, -1, -1, -1, 67, 68, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, -1, -1, 29, + 30, 31, -1, -1, -1, -1, -1, 37, -1, -1, + -1, -1, -1, -1, 103, -1, -1, -1, -1, -1, + -1, -1, 111, -1, -1, -1, -1, -1, -1, -1, + 60, -1, -1, -1, -1, -1, -1, 67, 68, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, -1, -1, 29, 30, + 31, -1, -1, -1, -1, -1, 37, -1, -1, -1, + -1, -1, -1, 103, -1, -1, -1, -1, -1, -1, + -1, 111, -1, -1, -1, -1, -1, -1, -1, 60, + -1, -1, -1, -1, -1, -1, 67, 68, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, -1, -1, 29, 30, 31, + -1, -1, -1, -1, -1, 37, -1, -1, -1, -1, + -1, -1, 103, -1, -1, -1, -1, -1, -1, -1, + 111, -1, -1, -1, -1, -1, -1, -1, 60, -1, + -1, -1, -1, -1, -1, 67, 68, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, -1, -1, 29, 30, 31, -1, + -1, -1, -1, -1, 37, -1, -1, -1, -1, -1, + -1, 103, -1, -1, -1, -1, -1, -1, -1, 111, + -1, -1, -1, -1, -1, -1, -1, 60, -1, -1, + -1, -1, -1, -1, 67, 68, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, -1, -1, 29, 30, 31, -1, -1, + -1, -1, -1, 37, -1, -1, -1, -1, -1, -1, + 103, -1, -1, -1, -1, -1, -1, -1, 111, -1, + -1, -1, -1, -1, -1, -1, 60, -1, -1, -1, + -1, -1, -1, 67, 68, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, -1, -1, 29, 30, 31, -1, -1, -1, + -1, -1, 37, -1, -1, -1, -1, -1, -1, 103, + -1, -1, -1, -1, -1, -1, -1, 111, -1, -1, + -1, -1, -1, -1, -1, 60, -1, -1, -1, -1, + -1, -1, 67, 68, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, -1, -1, 29, 30, 31, -1, -1, -1, -1, + -1, 37, -1, -1, -1, -1, -1, -1, 103, -1, + -1, -1, -1, -1, -1, -1, 111, -1, -1, -1, + -1, -1, -1, -1, 60, -1, -1, -1, -1, -1, + -1, 67, 68, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, -1, -1, 29, 30, + 31, -1, -1, -1, -1, -1, 37, -1, -1, -1, + -1, 36, -1, 38, 39, 111, 41, -1, -1, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 60, + -1, 56, 57, -1, 59, -1, 67, 68, -1, -1, + 65, -1, -1, -1, 69, -1, -1, 72, 73, 74, + 75, 76, 77, -1, 79, 80, -1, -1, -1, -1, + -1, -1, 87, -1, -1, -1, -1, -1, -1, -1, + -1, 102, -1, -1, -1, -1, 101, -1, 103, -1, + -1, 106, -1, -1, -1, 110, 111, 112, 113, 114, + 115, -1, 36, -1, 38, 39, -1, 41, -1, 124, + 44, 45, 46, 47, 48, 49, 50, 51, -1, 53, + -1, -1, 56, 57, -1, 59, -1, -1, -1, -1, + -1, 65, -1, -1, -1, 69, -1, -1, 72, 73, + 74, 75, 76, 77, -1, 79, 80, -1, -1, -1, + -1, -1, -1, 87, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 101, -1, 103, + -1, -1, 106, -1, -1, -1, 110, 111, 112, 113, + 114, 115, -1, -1, -1, -1, -1, -1, -1, -1, + 124, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, -1, -1, 29, 30, 31, -1, + 36, -1, 38, 39, 37, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, -1, -1, + 56, 57, -1, 59, -1, -1, -1, 60, -1, 65, + -1, -1, -1, 69, 67, 68, 72, 73, 74, 75, + 76, 77, -1, 79, 80, -1, -1, -1, -1, -1, + -1, 87, -1, -1, -1, -1, 89, -1, -1, -1, + -1, -1, -1, -1, -1, 101, -1, 103, -1, -1, + 106, -1, -1, -1, 110, 111, 112, 113, 114, 115, + 36, -1, 38, 39, -1, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, -1, 53, -1, -1, + 56, 57, -1, 59, -1, -1, -1, -1, -1, 65, + -1, -1, -1, 69, -1, -1, 72, 73, 74, 75, + 76, 77, -1, 79, 80, -1, -1, -1, -1, -1, + -1, 87, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 101, -1, 103, -1, -1, + 106, -1, -1, -1, 110, 111, 112, 113, 114, 115, + 36, -1, 38, 39, -1, 41, -1, -1, 44, 45, + 46, 47, 48, 49, 50, 51, -1, 53, -1, -1, + 56, 57, -1, 59, -1, -1, -1, -1, -1, 65, + -1, -1, -1, 69, -1, -1, 72, 73, 74, 75, + 76, 77, -1, 79, 80, -1, -1, -1, -1, -1, + -1, 87, -1, -1, -1, -1, -1, 36, -1, 38, + -1, -1, -1, -1, -1, 101, -1, 103, -1, -1, + 106, -1, -1, -1, 110, 111, 112, 113, 114, 115, + 59, -1, -1, -1, -1, -1, 65, -1, -1, -1, + 69, -1, -1, 72, 73, 74, 75, 76, 77, -1, + 79, 80, -1, -1, -1, -1, -1, -1, 87, -1, + -1, -1, -1, -1, 36, -1, 38, -1, -1, -1, + -1, -1, 101, -1, 103, -1, -1, -1, -1, -1, + -1, 110, 111, 112, 113, 114, 115, 59, -1, -1, + -1, -1, -1, 65, -1, -1, -1, 69, -1, -1, + 72, 73, 74, 75, 76, 77, -1, 79, 80, -1, + -1, -1, -1, -1, -1, 87, -1, -1, -1, -1, + -1, 36, -1, 38, -1, -1, -1, -1, -1, 101, + -1, 103, -1, -1, -1, -1, -1, -1, 110, 111, + 112, 113, 114, 115, 59, -1, -1, -1, -1, -1, + 65, -1, -1, -1, 69, -1, -1, 72, 73, 74, + 75, 76, 77, -1, 79, 80, -1, -1, -1, -1, + -1, -1, 87, -1, -1, -1, -1, -1, 36, -1, + 38, -1, -1, -1, -1, -1, 101, -1, 103, -1, + -1, -1, -1, -1, -1, 110, 111, 112, 113, 114, + 115, 59, -1, -1, -1, -1, -1, 65, -1, -1, + -1, 69, -1, -1, 72, 73, 74, 75, 76, 77, + -1, 79, 80, -1, -1, -1, -1, -1, -1, 87, + -1, -1, -1, -1, -1, 36, -1, 38, -1, -1, + -1, -1, -1, 101, -1, 103, -1, -1, -1, -1, + -1, -1, 110, 111, 112, 113, 114, 115, 59, -1, + -1, -1, -1, -1, 65, -1, -1, -1, 69, -1, + -1, 72, 73, 74, 75, 76, 77, -1, 79, 80, + -1, -1, -1, -1, -1, -1, 87, -1, -1, -1, + -1, -1, 36, -1, 38, -1, -1, -1, -1, -1, + 101, -1, -1, -1, -1, -1, -1, -1, -1, 110, + 111, 112, 113, 114, 115, 59, -1, -1, -1, -1, + -1, 65, -1, -1, -1, 69, -1, -1, 72, 73, + 74, 75, 76, 77, -1, 79, 80, -1, -1, -1, + -1, -1, -1, 87, -1, -1, -1, -1, -1, 36, + -1, 38, -1, -1, -1, -1, -1, 101, -1, -1, + -1, -1, -1, -1, -1, -1, 110, 111, 112, 113, + 114, 115, 59, -1, -1, -1, -1, -1, 65, -1, + -1, -1, 69, -1, -1, 72, 73, 74, 75, 76, + 77, -1, 79, 80, -1, -1, -1, -1, -1, -1, + 87, -1, -1, -1, -1, -1, 36, -1, 38, -1, + -1, -1, -1, -1, 101, -1, -1, -1, -1, -1, + -1, -1, -1, 110, 111, 112, 113, 114, 115, 59, + -1, -1, -1, -1, -1, 65, -1, -1, -1, 69, + -1, -1, 72, 73, 74, 75, 76, 77, -1, 79, + 80, -1, -1, -1, -1, -1, -1, 87, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 101, -1, -1, -1, -1, -1, -1, -1, -1, + 110, 111, 112, 113, 114, 115, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 37, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 60, -1, -1, -1, -1, 65, -1, 67, + 68, 69, -1, -1, -1, -1, -1, -1, 76, 77, + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, -1, -1, 29, 30, 31, -1, + -1, -1, -1, -1, 37, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 60, -1, -1, + -1, -1, -1, -1, 67, 68, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + -1, -1, 29, 30, 31, -1, -1, -1, -1, -1, + 37, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 60, -1, -1, -1, -1, -1, -1, + 67, 68, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, -1, -1, 29, 30, 31, + -1, -1, -1, -1, -1, 37, -1, -1, -1, -1, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, -1, 60, 29, + 30, 31, 32, 33, 34, 67, 68, 37, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, -1, -1, 29, 30, 31, + 60, -1, -1, -1, -1, 37, -1, 67, 68, -1, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, -1, 60, 29, + 30, 31, -1, 65, -1, 67, 68, 37, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, -1, -1, 29, 30, 31, + 60, -1, -1, -1, -1, 37, -1, 67, 68, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 60, -1, + -1, -1, -1, -1, -1, 67, 68 +}; + +/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +static const yytype_uint16 yystos[] = +{ + 0, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 29, 30, 31, 32, 35, + 37, 38, 57, 60, 65, 67, 68, 69, 76, 77, + 101, 103, 111, 129, 132, 189, 201, 202, 203, 204, + 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 220, 221, 222, 223, 224, 225, + 226, 227, 229, 230, 231, 232, 233, 234, 235, 243, + 244, 270, 271, 279, 282, 288, 289, 291, 293, 294, + 300, 305, 309, 310, 311, 312, 313, 314, 315, 316, + 336, 353, 354, 355, 356, 65, 111, 131, 204, 206, + 214, 216, 226, 230, 232, 271, 75, 101, 298, 299, + 300, 298, 298, 65, 67, 68, 69, 130, 131, 260, + 261, 280, 281, 67, 68, 261, 101, 291, 215, 216, + 101, 111, 305, 310, 311, 312, 314, 315, 316, 126, + 103, 207, 214, 216, 309, 313, 352, 353, 356, 357, + 127, 123, 264, 106, 127, 164, 67, 68, 129, 259, + 127, 127, 127, 108, 127, 67, 101, 111, 295, 304, + 305, 306, 307, 308, 309, 313, 317, 318, 319, 320, + 321, 3, 27, 71, 228, 3, 5, 67, 68, 103, + 111, 206, 217, 221, 224, 233, 309, 313, 356, 204, + 206, 216, 226, 230, 232, 271, 309, 313, 32, 222, + 222, 217, 224, 127, 222, 217, 222, 217, 101, 106, + 261, 106, 261, 222, 217, 108, 127, 127, 0, 126, + 101, 164, 298, 298, 126, 103, 214, 216, 354, 259, + 259, 216, 123, 101, 111, 295, 305, 309, 103, 111, + 356, 292, 219, 300, 101, 276, 101, 101, 101, 36, + 38, 59, 65, 69, 72, 73, 74, 75, 79, 80, + 87, 101, 103, 110, 111, 112, 113, 114, 115, 128, + 132, 133, 134, 135, 140, 141, 142, 143, 144, 145, + 146, 147, 148, 149, 150, 151, 152, 153, 155, 157, + 214, 263, 278, 352, 357, 216, 102, 102, 102, 102, + 102, 102, 102, 103, 111, 127, 155, 206, 207, 213, + 216, 220, 221, 226, 229, 230, 232, 249, 250, 254, + 255, 256, 257, 271, 336, 348, 349, 350, 351, 356, + 357, 126, 101, 309, 313, 356, 101, 108, 124, 103, + 106, 111, 155, 265, 107, 126, 108, 124, 101, 108, + 124, 108, 124, 108, 124, 298, 124, 305, 306, 307, + 308, 318, 319, 320, 321, 216, 304, 317, 57, 297, + 103, 298, 335, 336, 298, 298, 164, 126, 101, 298, + 335, 298, 298, 216, 295, 101, 101, 215, 214, 216, + 101, 126, 214, 352, 357, 164, 126, 259, 264, 206, + 221, 309, 313, 164, 126, 280, 216, 226, 124, 216, + 216, 126, 38, 103, 214, 236, 237, 238, 239, 352, + 356, 106, 245, 261, 106, 216, 280, 124, 124, 291, + 126, 131, 258, 3, 127, 196, 197, 211, 213, 216, + 126, 297, 101, 297, 155, 305, 216, 101, 126, 259, + 106, 32, 33, 34, 214, 272, 273, 275, 126, 121, + 123, 277, 126, 217, 223, 224, 259, 301, 302, 303, + 140, 153, 154, 101, 140, 142, 101, 140, 101, 101, + 140, 140, 131, 103, 155, 160, 164, 214, 262, 352, + 126, 142, 142, 75, 78, 79, 80, 101, 103, 105, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, + 123, 159, 142, 111, 116, 117, 113, 114, 81, 82, + 83, 84, 118, 119, 85, 86, 112, 120, 121, 87, + 88, 122, 123, 359, 101, 111, 331, 332, 333, 334, + 335, 102, 108, 101, 335, 103, 336, 101, 335, 336, + 126, 103, 111, 127, 214, 216, 347, 348, 356, 357, + 104, 127, 67, 101, 103, 111, 305, 322, 323, 324, + 325, 326, 327, 328, 329, 330, 336, 337, 338, 339, + 340, 341, 342, 111, 356, 216, 127, 127, 111, 214, + 216, 349, 259, 214, 336, 349, 259, 127, 126, 126, + 126, 126, 65, 103, 105, 261, 265, 266, 267, 268, + 269, 126, 126, 126, 126, 126, 126, 295, 102, 102, + 102, 102, 102, 102, 102, 304, 317, 101, 264, 126, + 196, 126, 295, 160, 263, 160, 263, 295, 278, 103, + 127, 196, 297, 164, 126, 196, 214, 272, 278, 238, + 239, 126, 101, 109, 111, 240, 242, 304, 305, 317, + 335, 343, 344, 345, 346, 107, 237, 108, 124, 108, + 124, 261, 236, 108, 358, 123, 246, 245, 216, 251, + 252, 253, 256, 257, 102, 108, 164, 126, 111, 155, + 126, 213, 216, 250, 348, 356, 289, 290, 101, 111, + 322, 102, 108, 359, 261, 272, 101, 106, 261, 263, + 272, 102, 108, 101, 102, 109, 262, 262, 103, 131, + 137, 155, 263, 262, 126, 102, 108, 102, 101, 111, + 343, 102, 108, 127, 155, 103, 131, 103, 136, 137, + 126, 103, 131, 155, 155, 142, 142, 142, 143, 143, + 144, 144, 145, 145, 145, 145, 146, 146, 147, 148, + 149, 150, 151, 109, 160, 155, 126, 332, 333, 334, + 216, 331, 298, 298, 155, 263, 126, 126, 258, 127, + 216, 220, 126, 104, 356, 67, 129, 214, 336, 354, + 104, 101, 126, 305, 323, 324, 325, 328, 338, 339, + 340, 126, 216, 322, 326, 337, 101, 298, 341, 359, + 298, 298, 359, 101, 298, 341, 298, 298, 298, 298, + 336, 214, 347, 357, 259, 104, 108, 104, 108, 359, + 214, 349, 359, 104, 247, 248, 249, 250, 247, 259, + 127, 155, 126, 103, 261, 109, 108, 358, 265, 103, + 109, 269, 28, 198, 199, 259, 247, 131, 295, 131, + 297, 101, 335, 336, 101, 335, 336, 133, 111, 127, + 164, 251, 102, 102, 102, 102, 102, 126, 104, 164, + 196, 164, 101, 111, 127, 127, 124, 124, 103, 127, + 305, 344, 345, 346, 154, 216, 343, 241, 242, 241, + 298, 298, 261, 298, 107, 261, 107, 154, 358, 127, + 127, 131, 211, 127, 127, 247, 101, 111, 356, 127, + 107, 216, 273, 274, 127, 126, 126, 101, 127, 102, + 302, 160, 161, 124, 75, 190, 191, 192, 102, 102, + 126, 109, 102, 102, 102, 127, 155, 216, 106, 142, + 157, 155, 156, 158, 104, 108, 127, 126, 126, 102, + 108, 155, 126, 153, 109, 251, 102, 102, 102, 331, + 251, 102, 104, 103, 111, 155, 155, 216, 127, 101, + 101, 214, 354, 328, 251, 102, 102, 102, 102, 102, + 102, 102, 7, 127, 216, 322, 326, 337, 126, 126, + 359, 126, 126, 101, 127, 127, 127, 127, 264, 104, + 127, 153, 154, 155, 296, 126, 265, 267, 107, 126, + 200, 261, 38, 39, 41, 44, 45, 46, 47, 48, + 49, 50, 51, 53, 56, 103, 131, 161, 162, 163, + 164, 165, 166, 168, 169, 181, 183, 184, 189, 201, + 294, 28, 127, 123, 264, 126, 126, 102, 104, 127, + 127, 67, 164, 216, 102, 102, 126, 104, 102, 102, + 102, 343, 240, 246, 107, 102, 108, 104, 104, 127, + 216, 108, 359, 276, 102, 272, 204, 206, 214, 284, + 285, 286, 287, 278, 102, 102, 101, 102, 109, 108, + 155, 155, 104, 266, 108, 127, 158, 104, 131, 138, + 139, 155, 137, 127, 138, 153, 157, 127, 101, 335, + 336, 127, 214, 336, 349, 126, 127, 127, 127, 155, + 104, 126, 126, 102, 127, 101, 335, 336, 101, 341, + 101, 341, 336, 215, 104, 7, 111, 127, 155, 251, + 251, 250, 254, 254, 255, 247, 102, 108, 108, 102, + 104, 89, 115, 127, 127, 138, 265, 155, 108, 124, + 201, 205, 216, 220, 101, 101, 162, 101, 101, 124, + 131, 124, 131, 111, 131, 161, 101, 164, 124, 155, + 126, 109, 124, 127, 126, 127, 200, 102, 155, 251, + 251, 298, 336, 102, 104, 101, 106, 261, 261, 127, + 101, 335, 336, 126, 102, 126, 127, 295, 107, 126, + 127, 127, 102, 106, 154, 124, 190, 192, 108, 127, + 358, 156, 104, 127, 78, 105, 108, 127, 127, 104, + 127, 102, 126, 102, 214, 349, 104, 104, 104, 127, + 247, 247, 102, 126, 126, 126, 155, 155, 127, 104, + 127, 127, 127, 127, 102, 126, 126, 154, 154, 104, + 104, 127, 127, 261, 216, 160, 160, 45, 160, 126, + 124, 124, 160, 124, 124, 160, 54, 55, 185, 186, + 187, 124, 127, 298, 166, 107, 124, 127, 127, 278, + 236, 106, 104, 126, 89, 256, 257, 102, 285, 108, + 124, 108, 124, 107, 283, 102, 102, 109, 158, 104, + 107, 104, 103, 139, 103, 139, 139, 104, 104, 104, + 251, 104, 127, 127, 251, 251, 251, 127, 127, 104, + 104, 102, 102, 104, 108, 89, 250, 89, 127, 104, + 104, 102, 102, 101, 102, 161, 182, 201, 124, 102, + 101, 164, 187, 54, 104, 162, 102, 102, 102, 107, + 236, 251, 106, 126, 126, 284, 124, 75, 193, 127, + 109, 126, 126, 127, 102, 102, 127, 127, 127, 104, + 104, 126, 127, 104, 162, 42, 43, 106, 172, 173, + 174, 160, 162, 127, 102, 161, 106, 174, 89, 126, + 101, 106, 261, 107, 127, 126, 259, 295, 107, 102, + 108, 104, 155, 138, 138, 102, 102, 102, 102, 254, + 40, 154, 170, 171, 296, 109, 126, 162, 172, 102, + 124, 162, 124, 126, 102, 126, 89, 126, 236, 106, + 102, 284, 124, 75, 109, 127, 127, 162, 89, 108, + 109, 127, 194, 195, 201, 124, 161, 161, 194, 164, + 188, 214, 352, 102, 126, 107, 236, 107, 155, 104, + 104, 154, 170, 173, 175, 176, 126, 124, 173, 177, + 178, 127, 101, 111, 295, 343, 131, 164, 188, 107, + 101, 162, 167, 107, 173, 201, 161, 52, 167, 180, + 107, 173, 102, 216, 127, 278, 162, 167, 124, 179, + 180, 167, 180, 164, 102, 102, 179, 127, 164, 127 +}; + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY (-2) +#define YYEOF 0 + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab + + +/* Like YYERROR except do call yyerror. This remains here temporarily + to ease the transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. However, + YYFAIL appears to be in use. Nevertheless, it is formally deprecated + in Bison 2.4.2's NEWS entry, where a plan to phase it out is + discussed. */ + +#define YYFAIL goto yyerrlab +#if defined YYFAIL + /* This is here to suppress warnings from the GCC cpp's + -Wunused-macros. Normally we don't worry about that warning, but + some users do, and we want to make it easy for users to remove + YYFAIL uses, which will produce warnings from Bison 2.5. */ +#endif + +#define YYRECOVERING() (!!yyerrstatus) + +#define YYBACKUP(Token, Value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + YYPOPSTACK (1); \ + goto yybackup; \ + } \ + else \ + { \ + yyerror (YY_("syntax error: cannot back up")); \ + YYERROR; \ + } \ +while (YYID (0)) + + +#define YYTERROR 1 +#define YYERRCODE 256 + + +/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. + If N is 0, then set CURRENT to the empty location which ends + the previous symbol: RHS[0] (always defined). */ + +#define YYRHSLOC(Rhs, K) ((Rhs)[K]) +#ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + do \ + if (YYID (N)) \ + { \ + (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ + (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ + (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ + (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ + } \ + else \ + { \ + (Current).first_line = (Current).last_line = \ + YYRHSLOC (Rhs, 0).last_line; \ + (Current).first_column = (Current).last_column = \ + YYRHSLOC (Rhs, 0).last_column; \ + } \ + while (YYID (0)) +#endif + + +/* This macro is provided for backward compatibility. */ + +#ifndef YY_LOCATION_PRINT +# define YY_LOCATION_PRINT(File, Loc) ((void) 0) +#endif + + +/* YYLEX -- calling `yylex' with the right arguments. */ + +#ifdef YYLEX_PARAM +# define YYLEX yylex (YYLEX_PARAM) +#else +# define YYLEX yylex () +#endif + +/* Enable debugging if requested. */ +#if YYDEBUG + +# ifndef YYFPRINTF +# include /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (YYID (0)) + +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yy_symbol_print (stderr, \ + Type, Value); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (YYID (0)) + + +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +/*ARGSUSED*/ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) +#else +static void +yy_symbol_value_print (yyoutput, yytype, yyvaluep) + FILE *yyoutput; + int yytype; + YYSTYPE const * const yyvaluep; +#endif +{ + if (!yyvaluep) + return; +# ifdef YYPRINT + if (yytype < YYNTOKENS) + YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); +# else + YYUSE (yyoutput); +# endif + switch (yytype) + { + default: + break; + } +} + + +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) +#else +static void +yy_symbol_print (yyoutput, yytype, yyvaluep) + FILE *yyoutput; + int yytype; + YYSTYPE const * const yyvaluep; +#endif +{ + if (yytype < YYNTOKENS) + YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); + else + YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); + + yy_symbol_value_print (yyoutput, yytype, yyvaluep); + YYFPRINTF (yyoutput, ")"); +} + +/*------------------------------------------------------------------. +| yy_stack_print -- Print the state stack from its BOTTOM up to its | +| TOP (included). | +`------------------------------------------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) +#else +static void +yy_stack_print (yybottom, yytop) + yytype_int16 *yybottom; + yytype_int16 *yytop; +#endif +{ + YYFPRINTF (stderr, "Stack now"); + for (; yybottom <= yytop; yybottom++) + { + int yybot = *yybottom; + YYFPRINTF (stderr, " %d", yybot); + } + YYFPRINTF (stderr, "\n"); +} + +# define YY_STACK_PRINT(Bottom, Top) \ +do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ +} while (YYID (0)) + + +/*------------------------------------------------. +| Report that the YYRULE is going to be reduced. | +`------------------------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_reduce_print (YYSTYPE *yyvsp, int yyrule) +#else +static void +yy_reduce_print (yyvsp, yyrule) + YYSTYPE *yyvsp; + int yyrule; +#endif +{ + int yynrhs = yyr2[yyrule]; + int yyi; + unsigned long int yylno = yyrline[yyrule]; + YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", + yyrule - 1, yylno); + /* The symbols being reduced. */ + for (yyi = 0; yyi < yynrhs; yyi++) + { + YYFPRINTF (stderr, " $%d = ", yyi + 1); + yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], + &(yyvsp[(yyi + 1) - (yynrhs)]) + ); + YYFPRINTF (stderr, "\n"); + } +} + +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (yyvsp, Rule); \ +} while (YYID (0)) + +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; +#else /* !YYDEBUG */ +# define YYDPRINTF(Args) +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) +# define YY_STACK_PRINT(Bottom, Top) +# define YY_REDUCE_PRINT(Rule) +#endif /* !YYDEBUG */ + + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH 10000 +#endif + + +#if YYERROR_VERBOSE + +# ifndef yystrlen +# if defined __GLIBC__ && defined _STRING_H +# define yystrlen strlen +# else +/* Return the length of YYSTR. */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static YYSIZE_T +yystrlen (const char *yystr) +#else +static YYSIZE_T +yystrlen (yystr) + const char *yystr; +#endif +{ + YYSIZE_T yylen; + for (yylen = 0; yystr[yylen]; yylen++) + continue; + return yylen; +} +# endif +# endif + +# ifndef yystpcpy +# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static char * +yystpcpy (char *yydest, const char *yysrc) +#else +static char * +yystpcpy (yydest, yysrc) + char *yydest; + const char *yysrc; +#endif +{ + char *yyd = yydest; + const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +# endif +# endif + +# ifndef yytnamerr +/* Copy to YYRES the contents of YYSTR after stripping away unnecessary + quotes and backslashes, so that it's suitable for yyerror. The + heuristic is that double-quoting is unnecessary unless the string + contains an apostrophe, a comma, or backslash (other than + backslash-backslash). YYSTR is taken from yytname. If YYRES is + null, do not copy; instead, return the length of what the result + would have been. */ +static YYSIZE_T +yytnamerr (char *yyres, const char *yystr) +{ + if (*yystr == '"') + { + YYSIZE_T yyn = 0; + char const *yyp = yystr; + + for (;;) + switch (*++yyp) + { + case '\'': + case ',': + goto do_not_strip_quotes; + + case '\\': + if (*++yyp != '\\') + goto do_not_strip_quotes; + /* Fall through. */ + default: + if (yyres) + yyres[yyn] = *yyp; + yyn++; + break; + + case '"': + if (yyres) + yyres[yyn] = '\0'; + return yyn; + } + do_not_strip_quotes: ; + } + + if (! yyres) + return yystrlen (yystr); + + return yystpcpy (yyres, yystr) - yyres; +} +# endif + +/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message + about the unexpected token YYTOKEN for the state stack whose top is + YYSSP. + + Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is + not large enough to hold the message. In that case, also set + *YYMSG_ALLOC to the required number of bytes. Return 2 if the + required number of bytes is too large to store. */ +static int +yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, + yytype_int16 *yyssp, int yytoken) +{ + YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]); + YYSIZE_T yysize = yysize0; + YYSIZE_T yysize1; + enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; + /* Internationalized format string. */ + const char *yyformat = 0; + /* Arguments of yyformat. */ + char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; + /* Number of reported tokens (one for the "unexpected", one per + "expected"). */ + int yycount = 0; + + /* There are many possibilities here to consider: + - Assume YYFAIL is not used. It's too flawed to consider. See + + for details. YYERROR is fine as it does not invoke this + function. + - If this state is a consistent state with a default action, then + the only way this function was invoked is if the default action + is an error action. In that case, don't check for expected + tokens because there are none. + - The only way there can be no lookahead present (in yychar) is if + this state is a consistent state with a default action. Thus, + detecting the absence of a lookahead is sufficient to determine + that there is no unexpected or expected token to report. In that + case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this state is a + consistent state with a default action. There might have been a + previous inconsistent state, consistent state with a non-default + action, or user semantic action that manipulated yychar. + - Of course, the expected token list depends on states to have + correct lookahead information, and it depends on the parser not + to perform extra reductions after fetching a lookahead from the + scanner and before detecting a syntax error. Thus, state merging + (from LALR or IELR) and default reductions corrupt the expected + token list. However, the list is correct for canonical LR with + one exception: it will still contain any token that will not be + accepted due to an error action in a later state. + */ + if (yytoken != YYEMPTY) + { + int yyn = yypact[*yyssp]; + yyarg[yycount++] = yytname[yytoken]; + if (!yypact_value_is_default (yyn)) + { + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. In other words, skip the first -YYN actions for + this state because they are default actions. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn + 1; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yyx; + + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR + && !yytable_value_is_error (yytable[yyx + yyn])) + { + if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) + { + yycount = 1; + yysize = yysize0; + break; + } + yyarg[yycount++] = yytname[yyx]; + yysize1 = yysize + yytnamerr (0, yytname[yyx]); + if (! (yysize <= yysize1 + && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + return 2; + yysize = yysize1; + } + } + } + + switch (yycount) + { +# define YYCASE_(N, S) \ + case N: \ + yyformat = S; \ + break + YYCASE_(0, YY_("syntax error")); + YYCASE_(1, YY_("syntax error, unexpected %s")); + YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); + YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); + YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); + YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); +# undef YYCASE_ + } + + yysize1 = yysize + yystrlen (yyformat); + if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + return 2; + yysize = yysize1; + + if (*yymsg_alloc < yysize) + { + *yymsg_alloc = 2 * yysize; + if (! (yysize <= *yymsg_alloc + && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) + *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; + return 1; + } + + /* Avoid sprintf, as that infringes on the user's name space. + Don't have undefined behavior even if the translation + produced a string with the wrong number of "%s"s. */ + { + char *yyp = *yymsg; + int yyi = 0; + while ((*yyp = *yyformat) != '\0') + if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) + { + yyp += yytnamerr (yyp, yyarg[yyi++]); + yyformat += 2; + } + else + { + yyp++; + yyformat++; + } + } + return 0; +} +#endif /* YYERROR_VERBOSE */ + +/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +/*ARGSUSED*/ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) +#else +static void +yydestruct (yymsg, yytype, yyvaluep) + const char *yymsg; + int yytype; + YYSTYPE *yyvaluep; +#endif +{ + YYUSE (yyvaluep); + + if (!yymsg) + yymsg = "Deleting"; + YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); + + switch (yytype) + { + + default: + break; + } +} + + +/* Prevent warnings from -Wmissing-prototypes. */ +#ifdef YYPARSE_PARAM +#if defined __STDC__ || defined __cplusplus +int yyparse (void *YYPARSE_PARAM); +#else +int yyparse (); +#endif +#else /* ! YYPARSE_PARAM */ +#if defined __STDC__ || defined __cplusplus +int yyparse (void); +#else +int yyparse (); +#endif +#endif /* ! YYPARSE_PARAM */ + + +/* The lookahead symbol. */ +int yychar; + +/* The semantic value of the lookahead symbol. */ +YYSTYPE yylval; + +/* Number of syntax errors so far. */ +int yynerrs; + + +/*----------. +| yyparse. | +`----------*/ + +#ifdef YYPARSE_PARAM +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +int +yyparse (void *YYPARSE_PARAM) +#else +int +yyparse (YYPARSE_PARAM) + void *YYPARSE_PARAM; +#endif +#else /* ! YYPARSE_PARAM */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +int +yyparse (void) +#else +int +yyparse () + +#endif +#endif +{ + int yystate; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus; + + /* The stacks and their tools: + `yyss': related to states. + `yyvs': related to semantic values. + + Refer to the stacks thru separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* The state stack. */ + yytype_int16 yyssa[YYINITDEPTH]; + yytype_int16 *yyss; + yytype_int16 *yyssp; + + /* The semantic value stack. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs; + YYSTYPE *yyvsp; + + YYSIZE_T yystacksize; + + int yyn; + int yyresult; + /* Lookahead token as an internal (translated) token number. */ + int yytoken; + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; + +#if YYERROR_VERBOSE + /* Buffer for error messages, and its allocated size. */ + char yymsgbuf[128]; + char *yymsg = yymsgbuf; + YYSIZE_T yymsg_alloc = sizeof yymsgbuf; +#endif + +#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) + + /* The number of symbols on the RHS of the reduced rule. + Keep to zero when no symbol should be popped. */ + int yylen = 0; + + yytoken = 0; + yyss = yyssa; + yyvs = yyvsa; + yystacksize = YYINITDEPTH; + + YYDPRINTF ((stderr, "Starting parse\n")); + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + yyssp = yyss; + yyvsp = yyvs; + + goto yysetstate; + +/*------------------------------------------------------------. +| yynewstate -- Push a new state, which is found in yystate. | +`------------------------------------------------------------*/ + yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. So pushing a state here evens the stacks. */ + yyssp++; + + yysetstate: + *yyssp = yystate; + + if (yyss + yystacksize - 1 <= yyssp) + { + /* Get the current used size of the three stacks, in elements. */ + YYSIZE_T yysize = yyssp - yyss + 1; + +#ifdef yyoverflow + { + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + YYSTYPE *yyvs1 = yyvs; + yytype_int16 *yyss1 = yyss; + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ + yyoverflow (YY_("memory exhausted"), + &yyss1, yysize * sizeof (*yyssp), + &yyvs1, yysize * sizeof (*yyvsp), + &yystacksize); + + yyss = yyss1; + yyvs = yyvs1; + } +#else /* no yyoverflow */ +# ifndef YYSTACK_RELOCATE + goto yyexhaustedlab; +# else + /* Extend the stack our own way. */ + if (YYMAXDEPTH <= yystacksize) + goto yyexhaustedlab; + yystacksize *= 2; + if (YYMAXDEPTH < yystacksize) + yystacksize = YYMAXDEPTH; + + { + yytype_int16 *yyss1 = yyss; + union yyalloc *yyptr = + (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); + if (! yyptr) + goto yyexhaustedlab; + YYSTACK_RELOCATE (yyss_alloc, yyss); + YYSTACK_RELOCATE (yyvs_alloc, yyvs); +# undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); + } +# endif +#endif /* no yyoverflow */ + + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1; + + YYDPRINTF ((stderr, "Stack size increased to %lu\n", + (unsigned long int) yystacksize)); + + if (yyss + yystacksize - 1 <= yyssp) + YYABORT; + } + + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + + if (yystate == YYFINAL) + YYACCEPT; + + goto yybackup; + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: + + /* Do appropriate processing given the current state. Read a + lookahead token if we need one and don't already have one. */ + + /* First try to decide what to do without reference to lookahead token. */ + yyn = yypact[yystate]; + if (yypact_value_is_default (yyn)) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ + if (yychar == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = YYLEX; + } + + if (yychar <= YYEOF) + { + yychar = yytoken = YYEOF; + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) + goto yydefault; + yyn = yytable[yyn]; + if (yyn <= 0) + { + if (yytable_value_is_error (yyn)) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; + + /* Shift the lookahead token. */ + YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); + + /* Discard the shifted token. */ + yychar = YYEMPTY; + + yystate = yyn; + *++yyvsp = yylval; + + goto yynewstate; + + +/*-----------------------------------------------------------. +| yydefault -- do the default action for the current state. | +`-----------------------------------------------------------*/ +yydefault: + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + +/*-----------------------------. +| yyreduce -- Do a reduction. | +`-----------------------------*/ +yyreduce: + /* yyn is the number of a rule to reduce with. */ + yylen = yyr2[yyn]; + + /* If YYLEN is nonzero, implement the default value of the action: + `$$ = $1'. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. Assigning to YYVAL + unconditionally makes the parser a bit smaller, and it avoids a + GCC warning that YYVAL may be used uninitialized. */ + yyval = yyvsp[1-yylen]; + + + YY_REDUCE_PRINT (yyn); + switch (yyn) + { + case 2: + +/* Line 1806 of yacc.c */ +#line 281 "parser.yy" + { + typedefTable.enterScope(); + } + break; + + case 3: + +/* Line 1806 of yacc.c */ +#line 287 "parser.yy" + { + typedefTable.leaveScope(); + } + break; + + case 4: + +/* Line 1806 of yacc.c */ +#line 297 "parser.yy" + { (yyval.constant) = new ConstantNode(ConstantNode::Integer, (yyvsp[(1) - (1)].tok)); } + break; + + case 5: + +/* Line 1806 of yacc.c */ +#line 298 "parser.yy" + { (yyval.constant) = new ConstantNode(ConstantNode::Float, (yyvsp[(1) - (1)].tok)); } + break; + + case 6: + +/* Line 1806 of yacc.c */ +#line 299 "parser.yy" + { (yyval.constant) = new ConstantNode(ConstantNode::Character, (yyvsp[(1) - (1)].tok)); } + break; + + case 15: + +/* Line 1806 of yacc.c */ +#line 323 "parser.yy" + { (yyval.constant) = new ConstantNode(ConstantNode::String, (yyvsp[(1) - (1)].tok)); } + break; + + case 16: + +/* Line 1806 of yacc.c */ +#line 324 "parser.yy" + { (yyval.constant) = (yyvsp[(1) - (2)].constant)->append( (yyvsp[(2) - (2)].tok) ); } + break; + + case 17: + +/* Line 1806 of yacc.c */ +#line 331 "parser.yy" + { (yyval.en) = new VarRefNode((yyvsp[(1) - (1)].tok)); } + break; + + case 18: + +/* Line 1806 of yacc.c */ +#line 333 "parser.yy" + { (yyval.en) = new VarRefNode((yyvsp[(1) - (1)].tok)); } + break; + + case 19: + +/* Line 1806 of yacc.c */ +#line 335 "parser.yy" + { (yyval.en) = (yyvsp[(1) - (1)].constant); } + break; + + case 20: + +/* Line 1806 of yacc.c */ +#line 337 "parser.yy" + { (yyval.en) = (yyvsp[(1) - (1)].constant); } + break; + + case 21: + +/* Line 1806 of yacc.c */ +#line 339 "parser.yy" + { (yyval.en) = (yyvsp[(2) - (3)].en); } + break; + + case 22: + +/* Line 1806 of yacc.c */ +#line 341 "parser.yy" + { (yyval.en) = new ValofExprNode((yyvsp[(2) - (3)].sn)); } + break; + + case 24: + +/* Line 1806 of yacc.c */ +#line 351 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::Index), (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en)); } + break; + + case 25: + +/* Line 1806 of yacc.c */ +#line 353 "parser.yy" + { (yyval.en) = new CompositeExprNode((yyvsp[(1) - (4)].en), (yyvsp[(3) - (4)].en)); } + break; + + case 26: + +/* Line 1806 of yacc.c */ +#line 355 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::FieldSel), (yyvsp[(1) - (3)].en), new VarRefNode((yyvsp[(3) - (3)].tok))); } + break; + + case 28: + +/* Line 1806 of yacc.c */ +#line 358 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::PFieldSel), (yyvsp[(1) - (3)].en), new VarRefNode((yyvsp[(3) - (3)].tok))); } + break; + + case 30: + +/* Line 1806 of yacc.c */ +#line 361 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::IncrPost), (yyvsp[(1) - (2)].en)); } + break; + + case 31: + +/* Line 1806 of yacc.c */ +#line 363 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::DecrPost), (yyvsp[(1) - (2)].en)); } + break; + + case 32: + +/* Line 1806 of yacc.c */ +#line 366 "parser.yy" + { (yyval.en) = 0; } + break; + + case 34: + +/* Line 1806 of yacc.c */ +#line 372 "parser.yy" + { (yyval.en) = (ExpressionNode *)((yyvsp[(1) - (3)].en)->set_link((yyvsp[(3) - (3)].en))); } + break; + + case 35: + +/* Line 1806 of yacc.c */ +#line 377 "parser.yy" + { (yyval.en) = 0; } + break; + + case 37: + +/* Line 1806 of yacc.c */ +#line 380 "parser.yy" + { (yyval.en) = (yyvsp[(3) - (3)].en)->set_asArgName((yyvsp[(1) - (3)].tok)); } + break; + + case 38: + +/* Line 1806 of yacc.c */ +#line 385 "parser.yy" + { (yyval.en) = (yyvsp[(7) - (7)].en)->set_asArgName((yyvsp[(3) - (7)].en)); } + break; + + case 39: + +/* Line 1806 of yacc.c */ +#line 387 "parser.yy" + { (yyval.en) = (yyvsp[(9) - (9)].en)->set_asArgName( new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(yyvsp[(3) - (9)].en)->set_link( flattenCommas( (yyvsp[(5) - (9)].en) )))); } + break; + + case 41: + +/* Line 1806 of yacc.c */ +#line 392 "parser.yy" + { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); } + break; + + case 42: + +/* Line 1806 of yacc.c */ +#line 397 "parser.yy" + { (yyval.en) = new VarRefNode( (yyvsp[(1) - (1)].tok) ); } + break; + + case 43: + +/* Line 1806 of yacc.c */ +#line 399 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::FieldSel), new VarRefNode( (yyvsp[(1) - (3)].tok) ), (yyvsp[(3) - (3)].en)); } + break; + + case 44: + +/* Line 1806 of yacc.c */ +#line 401 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::FieldSel), new VarRefNode( (yyvsp[(1) - (7)].tok) ), (yyvsp[(5) - (7)].en)); } + break; + + case 45: + +/* Line 1806 of yacc.c */ +#line 403 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::PFieldSel), new VarRefNode( (yyvsp[(1) - (3)].tok) ), (yyvsp[(3) - (3)].en)); } + break; + + case 46: + +/* Line 1806 of yacc.c */ +#line 405 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::PFieldSel), new VarRefNode( (yyvsp[(1) - (7)].tok) ), (yyvsp[(5) - (7)].en)); } + break; + + case 48: + +/* Line 1806 of yacc.c */ +#line 411 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::Incr), (yyvsp[(2) - (2)].en)); } + break; + + case 49: + +/* Line 1806 of yacc.c */ +#line 413 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::Decr), (yyvsp[(2) - (2)].en)); } + break; + + case 50: + +/* Line 1806 of yacc.c */ +#line 415 "parser.yy" + { (yyval.en) = (yyvsp[(2) - (2)].en); } + break; + + case 51: + +/* Line 1806 of yacc.c */ +#line 417 "parser.yy" + { (yyval.en) = new CompositeExprNode((yyvsp[(1) - (2)].en), (yyvsp[(2) - (2)].en)); } + break; + + case 52: + +/* Line 1806 of yacc.c */ +#line 419 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::Neg), (yyvsp[(2) - (2)].en)); } + break; + + case 53: + +/* Line 1806 of yacc.c */ +#line 421 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::PointTo), (yyvsp[(2) - (2)].en)); } + break; + + case 54: + +/* Line 1806 of yacc.c */ +#line 427 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::SizeOf), (yyvsp[(2) - (2)].en)); } + break; + + case 55: + +/* Line 1806 of yacc.c */ +#line 429 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::SizeOf), new TypeValueNode((yyvsp[(3) - (4)].decl))); } + break; + + case 56: + +/* Line 1806 of yacc.c */ +#line 431 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::Attr), new VarRefNode((yyvsp[(1) - (1)].tok))); } + break; + + case 57: + +/* Line 1806 of yacc.c */ +#line 433 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::Attr), new VarRefNode((yyvsp[(1) - (4)].tok)), new TypeValueNode((yyvsp[(3) - (4)].decl))); } + break; + + case 58: + +/* Line 1806 of yacc.c */ +#line 435 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::Attr), new VarRefNode((yyvsp[(1) - (4)].tok)), (yyvsp[(3) - (4)].en)); } + break; + + case 59: + +/* Line 1806 of yacc.c */ +#line 437 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::AlignOf), (yyvsp[(2) - (2)].en)); } + break; + + case 60: + +/* Line 1806 of yacc.c */ +#line 439 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::AlignOf), new TypeValueNode((yyvsp[(3) - (4)].decl))); } + break; + + case 61: + +/* Line 1806 of yacc.c */ +#line 441 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::LabelAddress), new VarRefNode((yyvsp[(2) - (2)].tok), true)); } + break; + + case 62: + +/* Line 1806 of yacc.c */ +#line 445 "parser.yy" + { (yyval.en) = new OperatorNode(OperatorNode::AddressOf); } + break; + + case 63: + +/* Line 1806 of yacc.c */ +#line 446 "parser.yy" + { (yyval.en) = new OperatorNode(OperatorNode::UnPlus); } + break; + + case 64: + +/* Line 1806 of yacc.c */ +#line 447 "parser.yy" + { (yyval.en) = new OperatorNode(OperatorNode::UnMinus); } + break; + + case 65: + +/* Line 1806 of yacc.c */ +#line 448 "parser.yy" + { (yyval.en) = new OperatorNode(OperatorNode::BitNeg); } + break; + + case 67: + +/* Line 1806 of yacc.c */ +#line 454 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::Cast), new TypeValueNode((yyvsp[(2) - (4)].decl)), (yyvsp[(4) - (4)].en)); } + break; + + case 68: + +/* Line 1806 of yacc.c */ +#line 456 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::Cast), new TypeValueNode((yyvsp[(2) - (4)].decl)), (yyvsp[(4) - (4)].en)); } + break; + + case 70: + +/* Line 1806 of yacc.c */ +#line 462 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::Mul),(yyvsp[(1) - (3)].en),(yyvsp[(3) - (3)].en)); } + break; + + case 71: + +/* Line 1806 of yacc.c */ +#line 464 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::Div),(yyvsp[(1) - (3)].en),(yyvsp[(3) - (3)].en)); } + break; + + case 72: + +/* Line 1806 of yacc.c */ +#line 466 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::Mod),(yyvsp[(1) - (3)].en),(yyvsp[(3) - (3)].en)); } + break; + + case 74: + +/* Line 1806 of yacc.c */ +#line 472 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::Plus),(yyvsp[(1) - (3)].en),(yyvsp[(3) - (3)].en)); } + break; + + case 75: + +/* Line 1806 of yacc.c */ +#line 474 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::Minus),(yyvsp[(1) - (3)].en),(yyvsp[(3) - (3)].en)); } + break; + + case 77: + +/* Line 1806 of yacc.c */ +#line 480 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::LShift),(yyvsp[(1) - (3)].en),(yyvsp[(3) - (3)].en)); } + break; + + case 78: + +/* Line 1806 of yacc.c */ +#line 482 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::RShift),(yyvsp[(1) - (3)].en),(yyvsp[(3) - (3)].en)); } + break; + + case 80: + +/* Line 1806 of yacc.c */ +#line 488 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::LThan),(yyvsp[(1) - (3)].en),(yyvsp[(3) - (3)].en)); } + break; + + case 81: + +/* Line 1806 of yacc.c */ +#line 490 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::GThan),(yyvsp[(1) - (3)].en),(yyvsp[(3) - (3)].en)); } + break; + + case 82: + +/* Line 1806 of yacc.c */ +#line 492 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::LEThan),(yyvsp[(1) - (3)].en),(yyvsp[(3) - (3)].en)); } + break; + + case 83: + +/* Line 1806 of yacc.c */ +#line 494 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::GEThan),(yyvsp[(1) - (3)].en),(yyvsp[(3) - (3)].en)); } + break; + + case 85: + +/* Line 1806 of yacc.c */ +#line 500 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::Eq), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en)); } + break; + + case 86: + +/* Line 1806 of yacc.c */ +#line 502 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::Neq), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en)); } + break; + + case 88: + +/* Line 1806 of yacc.c */ +#line 508 "parser.yy" + { (yyval.en) =new CompositeExprNode(new OperatorNode(OperatorNode::BitAnd), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en)); } + break; + + case 90: + +/* Line 1806 of yacc.c */ +#line 514 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::Xor), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en)); } + break; + + case 92: + +/* Line 1806 of yacc.c */ +#line 520 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::BitOr), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en)); } + break; + + case 94: + +/* Line 1806 of yacc.c */ +#line 526 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::And), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en)); } + break; + + case 96: + +/* Line 1806 of yacc.c */ +#line 532 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::Or), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en)); } + break; + + case 98: + +/* Line 1806 of yacc.c */ +#line 538 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::Cond), (ExpressionNode *)mkList((*(yyvsp[(1) - (5)].en),*(yyvsp[(3) - (5)].en),*(yyvsp[(5) - (5)].en)))); } + break; + + case 99: + +/* Line 1806 of yacc.c */ +#line 540 "parser.yy" + { (yyval.en)=new CompositeExprNode(new OperatorNode(OperatorNode::NCond),(yyvsp[(1) - (4)].en),(yyvsp[(4) - (4)].en)); } + break; + + case 100: + +/* Line 1806 of yacc.c */ +#line 542 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::Cond), (ExpressionNode *)mkList(( *(yyvsp[(1) - (5)].en), *(yyvsp[(3) - (5)].en), *(yyvsp[(5) - (5)].en) ))); } + break; + + case 103: + +/* Line 1806 of yacc.c */ +#line 553 "parser.yy" + { (yyval.en) =new CompositeExprNode(new OperatorNode(OperatorNode::Assign), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en)); } + break; + + case 104: + +/* Line 1806 of yacc.c */ +#line 555 "parser.yy" + { (yyval.en) =new CompositeExprNode((yyvsp[(2) - (3)].en), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en)); } + break; + + case 105: + +/* Line 1806 of yacc.c */ +#line 557 "parser.yy" + { (yyval.en) = ((yyvsp[(2) - (2)].en) == 0) ? (yyvsp[(1) - (2)].en) : new CompositeExprNode( new OperatorNode( OperatorNode::Assign ), (yyvsp[(1) - (2)].en), (yyvsp[(2) - (2)].en) ); } + break; + + case 106: + +/* Line 1806 of yacc.c */ +#line 562 "parser.yy" + { (yyval.en) = new NullExprNode; } + break; + + case 108: + +/* Line 1806 of yacc.c */ +#line 570 "parser.yy" + { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ) ); } + break; + + case 109: + +/* Line 1806 of yacc.c */ +#line 572 "parser.yy" + { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (yyvsp[(3) - (5)].en) ); } + break; + + case 110: + +/* Line 1806 of yacc.c */ +#line 574 "parser.yy" + { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(new NullExprNode)->set_link( (yyvsp[(4) - (6)].en) ) ); } + break; + + case 111: + +/* Line 1806 of yacc.c */ +#line 576 "parser.yy" + { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(yyvsp[(3) - (7)].en)->set_link( flattenCommas( (yyvsp[(5) - (7)].en) ) ) ); } + break; + + case 113: + +/* Line 1806 of yacc.c */ +#line 582 "parser.yy" + { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); } + break; + + case 114: + +/* Line 1806 of yacc.c */ +#line 586 "parser.yy" + { (yyval.en) = new OperatorNode(OperatorNode::MulAssn); } + break; + + case 115: + +/* Line 1806 of yacc.c */ +#line 587 "parser.yy" + { (yyval.en) = new OperatorNode(OperatorNode::DivAssn); } + break; + + case 116: + +/* Line 1806 of yacc.c */ +#line 588 "parser.yy" + { (yyval.en) = new OperatorNode(OperatorNode::ModAssn); } + break; + + case 117: + +/* Line 1806 of yacc.c */ +#line 589 "parser.yy" + { (yyval.en) = new OperatorNode(OperatorNode::PlusAssn); } + break; + + case 118: + +/* Line 1806 of yacc.c */ +#line 590 "parser.yy" + { (yyval.en) = new OperatorNode(OperatorNode::MinusAssn); } + break; + + case 119: + +/* Line 1806 of yacc.c */ +#line 591 "parser.yy" + { (yyval.en) = new OperatorNode(OperatorNode::LSAssn); } + break; + + case 120: + +/* Line 1806 of yacc.c */ +#line 592 "parser.yy" + { (yyval.en) = new OperatorNode(OperatorNode::RSAssn); } + break; + + case 121: + +/* Line 1806 of yacc.c */ +#line 593 "parser.yy" + { (yyval.en) = new OperatorNode(OperatorNode::AndAssn); } + break; + + case 122: + +/* Line 1806 of yacc.c */ +#line 594 "parser.yy" + { (yyval.en) = new OperatorNode(OperatorNode::ERAssn); } + break; + + case 123: + +/* Line 1806 of yacc.c */ +#line 595 "parser.yy" + { (yyval.en) = new OperatorNode(OperatorNode::OrAssn); } + break; + + case 125: + +/* Line 1806 of yacc.c */ +#line 601 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::Comma),(yyvsp[(1) - (3)].en),(yyvsp[(3) - (3)].en)); } + break; + + case 126: + +/* Line 1806 of yacc.c */ +#line 606 "parser.yy" + { (yyval.en) = 0; } + break; + + case 130: + +/* Line 1806 of yacc.c */ +#line 615 "parser.yy" + { (yyval.sn) = (yyvsp[(1) - (1)].sn); } + break; + + case 136: + +/* Line 1806 of yacc.c */ +#line 625 "parser.yy" + { (yyval.sn) = (yyvsp[(4) - (4)].sn)->add_label((yyvsp[(1) - (4)].tok));} + break; + + case 137: + +/* Line 1806 of yacc.c */ +#line 630 "parser.yy" + { (yyval.sn) = new CompoundStmtNode( (StatementNode *)0 ); } + break; + + case 138: + +/* Line 1806 of yacc.c */ +#line 637 "parser.yy" + { (yyval.sn) = new CompoundStmtNode( (yyvsp[(5) - (7)].sn) ); } + break; + + case 140: + +/* Line 1806 of yacc.c */ +#line 643 "parser.yy" + { if ((yyvsp[(1) - (3)].sn) != 0) { (yyvsp[(1) - (3)].sn)->set_link((yyvsp[(3) - (3)].sn)); (yyval.sn) = (yyvsp[(1) - (3)].sn); } } + break; + + case 141: + +/* Line 1806 of yacc.c */ +#line 648 "parser.yy" + { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); } + break; + + case 142: + +/* Line 1806 of yacc.c */ +#line 650 "parser.yy" + { (yyval.sn) = new StatementNode( (yyvsp[(2) - (2)].decl) ); } + break; + + case 143: + +/* Line 1806 of yacc.c */ +#line 652 "parser.yy" + { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); } + break; + + case 146: + +/* Line 1806 of yacc.c */ +#line 659 "parser.yy" + { if ((yyvsp[(1) - (2)].sn) != 0) { (yyvsp[(1) - (2)].sn)->set_link((yyvsp[(2) - (2)].sn)); (yyval.sn) = (yyvsp[(1) - (2)].sn); } } + break; + + case 147: + +/* Line 1806 of yacc.c */ +#line 664 "parser.yy" + { (yyval.sn) = new StatementNode(StatementNode::Exp, (yyvsp[(1) - (2)].en), 0); } + break; + + case 148: + +/* Line 1806 of yacc.c */ +#line 670 "parser.yy" + { (yyval.sn) = new StatementNode(StatementNode::If, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn)); } + break; + + case 149: + +/* Line 1806 of yacc.c */ +#line 672 "parser.yy" + { (yyval.sn) = new StatementNode(StatementNode::If, (yyvsp[(3) - (7)].en), (StatementNode *)mkList((*(yyvsp[(5) - (7)].sn), *(yyvsp[(7) - (7)].sn))) ); } + break; + + case 150: + +/* Line 1806 of yacc.c */ +#line 674 "parser.yy" + { (yyval.sn) = new StatementNode(StatementNode::Switch, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn)); } + break; + + case 151: + +/* Line 1806 of yacc.c */ +#line 676 "parser.yy" + { (yyval.sn) = new StatementNode(StatementNode::Switch, (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn)); /* xxx */ } + break; + + case 152: + +/* Line 1806 of yacc.c */ +#line 682 "parser.yy" + { (yyval.sn) = new StatementNode(StatementNode::Choose, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn)); } + break; + + case 153: + +/* Line 1806 of yacc.c */ +#line 684 "parser.yy" + { (yyval.sn) = new StatementNode(StatementNode::Choose, (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn)); } + break; + + case 154: + +/* Line 1806 of yacc.c */ +#line 691 "parser.yy" + { (yyval.en) = (yyvsp[(1) - (1)].en); } + break; + + case 155: + +/* Line 1806 of yacc.c */ +#line 693 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::Range),(yyvsp[(1) - (3)].en),(yyvsp[(3) - (3)].en)); } + break; + + case 158: + +/* Line 1806 of yacc.c */ +#line 700 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(tupleContents((yyvsp[(1) - (3)].en)))->set_link((yyvsp[(3) - (3)].en)) ); } + break; + + case 159: + +/* Line 1806 of yacc.c */ +#line 704 "parser.yy" + { (yyval.sn) = new StatementNode(StatementNode::Case, (yyvsp[(2) - (3)].en), 0); } + break; + + case 160: + +/* Line 1806 of yacc.c */ +#line 705 "parser.yy" + { (yyval.sn) = new StatementNode(StatementNode::Default); } + break; + + case 162: + +/* Line 1806 of yacc.c */ +#line 711 "parser.yy" + { (yyval.sn) = (StatementNode *)((yyvsp[(1) - (2)].sn)->set_link((yyvsp[(2) - (2)].sn))); } + break; + + case 163: + +/* Line 1806 of yacc.c */ +#line 715 "parser.yy" + { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case((yyvsp[(2) - (2)].sn)); } + break; + + case 164: + +/* Line 1806 of yacc.c */ +#line 720 "parser.yy" + { (yyval.sn) = 0; } + break; + + case 166: + +/* Line 1806 of yacc.c */ +#line 726 "parser.yy" + { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case((yyvsp[(2) - (2)].sn)); } + break; + + case 167: + +/* Line 1806 of yacc.c */ +#line 728 "parser.yy" + { (yyval.sn) = (StatementNode *)((yyvsp[(1) - (3)].sn)->set_link((yyvsp[(2) - (3)].sn)->append_last_case((yyvsp[(3) - (3)].sn)))); } + break; + + case 168: + +/* Line 1806 of yacc.c */ +#line 733 "parser.yy" + { (yyval.sn) = 0; } + break; + + case 170: + +/* Line 1806 of yacc.c */ +#line 739 "parser.yy" + { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case((yyvsp[(2) - (2)].sn)); } + break; + + case 171: + +/* Line 1806 of yacc.c */ +#line 741 "parser.yy" + { (yyval.sn) = (yyvsp[(1) - (3)].sn)->append_last_case((StatementNode *)mkList((*(yyvsp[(2) - (3)].sn),*(yyvsp[(3) - (3)].sn)))); } + break; + + case 172: + +/* Line 1806 of yacc.c */ +#line 743 "parser.yy" + { (yyval.sn) = (StatementNode *)((yyvsp[(1) - (3)].sn)->set_link((yyvsp[(2) - (3)].sn)->append_last_case((yyvsp[(3) - (3)].sn)))); } + break; + + case 173: + +/* Line 1806 of yacc.c */ +#line 745 "parser.yy" + { (yyval.sn) = (StatementNode *)((yyvsp[(1) - (4)].sn)->set_link((yyvsp[(2) - (4)].sn)->append_last_case((StatementNode *)mkList((*(yyvsp[(3) - (4)].sn),*(yyvsp[(4) - (4)].sn)))))); } + break; + + case 174: + +/* Line 1806 of yacc.c */ +#line 750 "parser.yy" + { (yyval.sn) = 0; } + break; + + case 176: + +/* Line 1806 of yacc.c */ +#line 755 "parser.yy" + { (yyval.sn) = new StatementNode(StatementNode::Fallthru, 0, 0); } + break; + + case 177: + +/* Line 1806 of yacc.c */ +#line 756 "parser.yy" + { (yyval.sn) = new StatementNode(StatementNode::Fallthru, 0, 0); } + break; + + case 178: + +/* Line 1806 of yacc.c */ +#line 761 "parser.yy" + { (yyval.sn) = new StatementNode(StatementNode::While, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn)); } + break; + + case 179: + +/* Line 1806 of yacc.c */ +#line 763 "parser.yy" + { (yyval.sn) = new StatementNode(StatementNode::Do, (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn)); } + break; + + case 180: + +/* Line 1806 of yacc.c */ +#line 765 "parser.yy" + { (yyval.sn) = new StatementNode(StatementNode::For, (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].sn)); } + break; + + case 181: + +/* Line 1806 of yacc.c */ +#line 770 "parser.yy" + { (yyval.en) = new ForCtlExprNode((yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].en)); } + break; + + case 182: + +/* Line 1806 of yacc.c */ +#line 773 "parser.yy" + { (yyval.en) = new ForCtlExprNode((yyvsp[(1) - (4)].decl), (yyvsp[(2) - (4)].en), (yyvsp[(4) - (4)].en)); } + break; + + case 183: + +/* Line 1806 of yacc.c */ +#line 778 "parser.yy" + { (yyval.sn) = new StatementNode(StatementNode::Goto, (yyvsp[(2) - (3)].tok)); } + break; + + case 184: + +/* Line 1806 of yacc.c */ +#line 782 "parser.yy" + { (yyval.sn) = new StatementNode(StatementNode::Goto, (yyvsp[(3) - (4)].en)); } + break; + + case 185: + +/* Line 1806 of yacc.c */ +#line 786 "parser.yy" + { (yyval.sn) = new StatementNode(StatementNode::Continue, 0, 0); } + break; + + case 186: + +/* Line 1806 of yacc.c */ +#line 790 "parser.yy" + { (yyval.sn) = new StatementNode(StatementNode::Continue, (yyvsp[(2) - (3)].tok)); } + break; + + case 187: + +/* Line 1806 of yacc.c */ +#line 794 "parser.yy" + { (yyval.sn) = new StatementNode(StatementNode::Break, 0, 0); } + break; + + case 188: + +/* Line 1806 of yacc.c */ +#line 798 "parser.yy" + { (yyval.sn) = new StatementNode(StatementNode::Break, (yyvsp[(2) - (3)].tok) ); } + break; + + case 189: + +/* Line 1806 of yacc.c */ +#line 800 "parser.yy" + { (yyval.sn) = new StatementNode(StatementNode::Return, (yyvsp[(2) - (3)].en), 0); } + break; + + case 190: + +/* Line 1806 of yacc.c */ +#line 802 "parser.yy" + { (yyval.sn) = new StatementNode(StatementNode::Throw, (yyvsp[(2) - (3)].en), 0); } + break; + + case 191: + +/* Line 1806 of yacc.c */ +#line 804 "parser.yy" + { (yyval.sn) = new StatementNode(StatementNode::Throw, 0, 0); } + break; + + case 192: + +/* Line 1806 of yacc.c */ +#line 809 "parser.yy" + { (yyval.sn) = new StatementNode(StatementNode::Try, 0,(StatementNode *)(mkList((*(yyvsp[(2) - (3)].sn),*(yyvsp[(3) - (3)].pn))))); } + break; + + case 193: + +/* Line 1806 of yacc.c */ +#line 811 "parser.yy" + { (yyval.sn) = new StatementNode(StatementNode::Try, 0,(StatementNode *)(mkList((*(yyvsp[(2) - (3)].sn),*(yyvsp[(3) - (3)].pn))))); } + break; + + case 194: + +/* Line 1806 of yacc.c */ +#line 813 "parser.yy" + { + (yyvsp[(3) - (4)].pn)->set_link((yyvsp[(4) - (4)].pn)); + (yyval.sn) = new StatementNode(StatementNode::Try, 0,(StatementNode *)(mkList((*(yyvsp[(2) - (4)].sn),*(yyvsp[(3) - (4)].pn))))); + } + break; + + case 196: + +/* Line 1806 of yacc.c */ +#line 825 "parser.yy" + { (yyval.pn) = StatementNode::newCatchStmt( 0, (yyvsp[(5) - (5)].sn), true ); } + break; + + case 197: + +/* Line 1806 of yacc.c */ +#line 827 "parser.yy" + { (yyval.pn) = (yyvsp[(1) - (6)].pn)->set_link( StatementNode::newCatchStmt( 0, (yyvsp[(6) - (6)].sn), true ) ); } + break; + + case 198: + +/* Line 1806 of yacc.c */ +#line 832 "parser.yy" + { (yyval.pn) = StatementNode::newCatchStmt((yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn)); } + break; + + case 199: + +/* Line 1806 of yacc.c */ +#line 834 "parser.yy" + { (yyval.pn) = (yyvsp[(1) - (10)].pn)->set_link( StatementNode::newCatchStmt((yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn)) ); } + break; + + case 200: + +/* Line 1806 of yacc.c */ +#line 839 "parser.yy" + { + (yyval.pn) = new StatementNode(StatementNode::Finally, 0, (yyvsp[(2) - (2)].sn)); + std::cout << "Just created a finally node" << std::endl; + } + break; + + case 202: + +/* Line 1806 of yacc.c */ +#line 853 "parser.yy" + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); + } + break; + + case 203: + +/* Line 1806 of yacc.c */ +#line 858 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); } + break; + + case 204: + +/* Line 1806 of yacc.c */ +#line 860 "parser.yy" + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + (yyval.decl) = (yyvsp[(1) - (2)].decl)->addName( (yyvsp[(2) - (2)].tok) ); + } + break; + + case 206: + +/* Line 1806 of yacc.c */ +#line 869 "parser.yy" + { (yyval.sn) = new StatementNode(StatementNode::Asm, 0, 0); } + break; + + case 207: + +/* Line 1806 of yacc.c */ +#line 871 "parser.yy" + { (yyval.sn) = new StatementNode(StatementNode::Asm, 0, 0); } + break; + + case 208: + +/* Line 1806 of yacc.c */ +#line 873 "parser.yy" + { (yyval.sn) = new StatementNode(StatementNode::Asm, 0, 0); } + break; + + case 209: + +/* Line 1806 of yacc.c */ +#line 875 "parser.yy" + { (yyval.sn) = new StatementNode(StatementNode::Asm, 0, 0); } + break; + + case 214: + +/* Line 1806 of yacc.c */ +#line 889 "parser.yy" + {} + break; + + case 215: + +/* Line 1806 of yacc.c */ +#line 893 "parser.yy" + {} + break; + + case 217: + +/* Line 1806 of yacc.c */ +#line 901 "parser.yy" + { (yyval.decl) = 0; } + break; + + case 220: + +/* Line 1806 of yacc.c */ +#line 908 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); } + break; + + case 221: + +/* Line 1806 of yacc.c */ +#line 913 "parser.yy" + { (yyval.decl) = 0; } + break; + + case 224: + +/* Line 1806 of yacc.c */ +#line 920 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); } + break; + + case 229: + +/* Line 1806 of yacc.c */ +#line 934 "parser.yy" + {} + break; + + case 230: + +/* Line 1806 of yacc.c */ +#line 935 "parser.yy" + {} + break; + + case 238: + +/* Line 1806 of yacc.c */ +#line 965 "parser.yy" + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + (yyval.decl) = (yyvsp[(1) - (2)].decl); + } + break; + + case 239: + +/* Line 1806 of yacc.c */ +#line 972 "parser.yy" + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) ); + } + break; + + case 240: + +/* Line 1806 of yacc.c */ +#line 977 "parser.yy" + { + typedefTable.addToEnclosingScope( *(yyvsp[(5) - (6)].tok), TypedefTable::ID ); + (yyval.decl) = (yyvsp[(1) - (6)].decl)->appendList( (yyvsp[(1) - (6)].decl)->cloneType( (yyvsp[(5) - (6)].tok) ) ); + } + break; + + case 241: + +/* Line 1806 of yacc.c */ +#line 987 "parser.yy" + { + typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) ); + (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); + } + break; + + case 242: + +/* Line 1806 of yacc.c */ +#line 992 "parser.yy" + { + typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) ); + (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); + } + break; + + case 243: + +/* Line 1806 of yacc.c */ +#line 997 "parser.yy" + { + typedefTable.setNextIdentifier( *(yyvsp[(3) - (4)].tok) ); + (yyval.decl) = (yyvsp[(2) - (4)].decl)->addQualifiers( (yyvsp[(1) - (4)].decl) )->addName( (yyvsp[(3) - (4)].tok) ); + } + break; + + case 244: + +/* Line 1806 of yacc.c */ +#line 1005 "parser.yy" + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + (yyval.decl) = (yyvsp[(1) - (1)].decl); + } + break; + + case 245: + +/* Line 1806 of yacc.c */ +#line 1010 "parser.yy" + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); + } + break; + + case 246: + +/* Line 1806 of yacc.c */ +#line 1015 "parser.yy" + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); + } + break; + + case 247: + +/* Line 1806 of yacc.c */ +#line 1020 "parser.yy" + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(2) - (3)].decl) ); + } + break; + + case 248: + +/* Line 1806 of yacc.c */ +#line 1025 "parser.yy" + { + typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::ID ); + (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(1) - (5)].decl)->cloneType( (yyvsp[(5) - (5)].tok) ) ); + } + break; + + case 249: + +/* Line 1806 of yacc.c */ +#line 1033 "parser.yy" + { + typedefTable.setNextIdentifier( *((yyvsp[(5) - (10)].tok)) ); + (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(5) - (10)].tok), DeclarationNode::newTuple( 0 ), (yyvsp[(8) - (10)].decl), 0, true ); + } + break; + + case 250: + +/* Line 1806 of yacc.c */ +#line 1038 "parser.yy" + { + typedefTable.setNextIdentifier( *((yyvsp[(5) - (10)].tok)) ); + (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(5) - (10)].tok), DeclarationNode::newTuple( 0 ), (yyvsp[(8) - (10)].decl), 0, true ); + } + break; + + case 251: + +/* Line 1806 of yacc.c */ +#line 1053 "parser.yy" + { + (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true ); + } + break; + + case 252: + +/* Line 1806 of yacc.c */ +#line 1057 "parser.yy" + { + (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true ); + } + break; + + case 253: + +/* Line 1806 of yacc.c */ +#line 1064 "parser.yy" + { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); } + break; + + case 254: + +/* Line 1806 of yacc.c */ +#line 1068 "parser.yy" + { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (9)].decl)->appendList( (yyvsp[(7) - (9)].decl) ) ); } + break; + + case 255: + +/* Line 1806 of yacc.c */ +#line 1073 "parser.yy" + { + typedefTable.addToEnclosingScope( TypedefTable::TD); + (yyval.decl) = (yyvsp[(2) - (2)].decl)->addTypedef(); + } + break; + + case 256: + +/* Line 1806 of yacc.c */ +#line 1078 "parser.yy" + { + typedefTable.addToEnclosingScope( TypedefTable::TD); + (yyval.decl) = (yyvsp[(2) - (2)].decl)->addTypedef(); + } + break; + + case 257: + +/* Line 1806 of yacc.c */ +#line 1083 "parser.yy" + { + typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::TD); + (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(1) - (5)].decl)->cloneType( (yyvsp[(5) - (5)].tok) ) ); + } + break; + + case 258: + +/* Line 1806 of yacc.c */ +#line 1095 "parser.yy" + { + typedefTable.addToEnclosingScope( TypedefTable::TD); + (yyval.decl) = (yyvsp[(3) - (3)].decl)->addType( (yyvsp[(2) - (3)].decl) )->addTypedef(); + } + break; + + case 259: + +/* Line 1806 of yacc.c */ +#line 1100 "parser.yy" + { + typedefTable.addToEnclosingScope( TypedefTable::TD); + (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(1) - (5)].decl)->cloneBaseType( (yyvsp[(5) - (5)].decl) )->addTypedef() ); + } + break; + + case 260: + +/* Line 1806 of yacc.c */ +#line 1105 "parser.yy" + { + typedefTable.addToEnclosingScope( TypedefTable::TD); + (yyval.decl) = (yyvsp[(4) - (4)].decl)->addType( (yyvsp[(3) - (4)].decl) )->addQualifiers( (yyvsp[(1) - (4)].decl) )->addTypedef(); + } + break; + + case 261: + +/* Line 1806 of yacc.c */ +#line 1110 "parser.yy" + { + typedefTable.addToEnclosingScope( TypedefTable::TD); + (yyval.decl) = (yyvsp[(3) - (3)].decl)->addType( (yyvsp[(1) - (3)].decl) )->addTypedef(); + } + break; + + case 262: + +/* Line 1806 of yacc.c */ +#line 1115 "parser.yy" + { + typedefTable.addToEnclosingScope( TypedefTable::TD); + (yyval.decl) = (yyvsp[(4) - (4)].decl)->addQualifiers((yyvsp[(1) - (4)].decl))->addTypedef()->addType((yyvsp[(1) - (4)].decl)); + } + break; + + case 263: + +/* Line 1806 of yacc.c */ +#line 1123 "parser.yy" + { + typedefTable.addToEnclosingScope(*((yyvsp[(2) - (4)].tok)), TypedefTable::TD); + (yyval.decl) = DeclarationNode::newName( 0 ); // XXX + } + break; + + case 264: + +/* Line 1806 of yacc.c */ +#line 1128 "parser.yy" + { + typedefTable.addToEnclosingScope(*((yyvsp[(5) - (7)].tok)), TypedefTable::TD); + (yyval.decl) = DeclarationNode::newName( 0 ); // XXX + } + break; + + case 269: + +/* Line 1806 of yacc.c */ +#line 1145 "parser.yy" + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + (yyval.decl) = ((yyvsp[(2) - (4)].decl)->addType( (yyvsp[(1) - (4)].decl) ))->addInitializer((yyvsp[(4) - (4)].in)); + } + break; + + case 270: + +/* Line 1806 of yacc.c */ +#line 1150 "parser.yy" + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + (yyval.decl) = (yyvsp[(1) - (6)].decl)->appendList( (yyvsp[(1) - (6)].decl)->cloneBaseType( (yyvsp[(4) - (6)].decl)->addInitializer((yyvsp[(6) - (6)].in)) ) ); + } + break; + + case 279: + +/* Line 1806 of yacc.c */ +#line 1172 "parser.yy" + { (yyval.decl) = 0; } + break; + + case 282: + +/* Line 1806 of yacc.c */ +#line 1185 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } + break; + + case 284: + +/* Line 1806 of yacc.c */ +#line 1191 "parser.yy" + { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Attribute ); } + break; + + case 285: + +/* Line 1806 of yacc.c */ +#line 1196 "parser.yy" + { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); } + break; + + case 286: + +/* Line 1806 of yacc.c */ +#line 1198 "parser.yy" + { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); } + break; + + case 287: + +/* Line 1806 of yacc.c */ +#line 1200 "parser.yy" + { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); } + break; + + case 288: + +/* Line 1806 of yacc.c */ +#line 1202 "parser.yy" + { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); } + break; + + case 289: + +/* Line 1806 of yacc.c */ +#line 1204 "parser.yy" + { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); } + break; + + case 290: + +/* Line 1806 of yacc.c */ +#line 1206 "parser.yy" + { + typedefTable.enterScope(); + } + break; + + case 291: + +/* Line 1806 of yacc.c */ +#line 1210 "parser.yy" + { + typedefTable.leaveScope(); + (yyval.decl) = DeclarationNode::newForall( (yyvsp[(4) - (5)].decl) ); + } + break; + + case 293: + +/* Line 1806 of yacc.c */ +#line 1219 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } + break; + + case 294: + +/* Line 1806 of yacc.c */ +#line 1221 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } + break; + + case 296: + +/* Line 1806 of yacc.c */ +#line 1232 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } + break; + + case 298: + +/* Line 1806 of yacc.c */ +#line 1241 "parser.yy" + { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Extern ); } + break; + + case 299: + +/* Line 1806 of yacc.c */ +#line 1243 "parser.yy" + { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Static ); } + break; + + case 300: + +/* Line 1806 of yacc.c */ +#line 1245 "parser.yy" + { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Auto ); } + break; + + case 301: + +/* Line 1806 of yacc.c */ +#line 1247 "parser.yy" + { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Register ); } + break; + + case 302: + +/* Line 1806 of yacc.c */ +#line 1250 "parser.yy" + { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Inline ); } + break; + + case 303: + +/* Line 1806 of yacc.c */ +#line 1252 "parser.yy" + { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); } + break; + + case 304: + +/* Line 1806 of yacc.c */ +#line 1257 "parser.yy" + { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); } + break; + + case 305: + +/* Line 1806 of yacc.c */ +#line 1259 "parser.yy" + { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); } + break; + + case 306: + +/* Line 1806 of yacc.c */ +#line 1261 "parser.yy" + { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); } + break; + + case 307: + +/* Line 1806 of yacc.c */ +#line 1263 "parser.yy" + { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); } + break; + + case 308: + +/* Line 1806 of yacc.c */ +#line 1265 "parser.yy" + { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Long ); } + break; + + case 309: + +/* Line 1806 of yacc.c */ +#line 1267 "parser.yy" + { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Short ); } + break; + + case 310: + +/* Line 1806 of yacc.c */ +#line 1269 "parser.yy" + { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Signed ); } + break; + + case 311: + +/* Line 1806 of yacc.c */ +#line 1271 "parser.yy" + { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Unsigned ); } + break; + + case 312: + +/* Line 1806 of yacc.c */ +#line 1273 "parser.yy" + { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); } + break; + + case 313: + +/* Line 1806 of yacc.c */ +#line 1275 "parser.yy" + { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); } + break; + + case 314: + +/* Line 1806 of yacc.c */ +#line 1277 "parser.yy" + { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Complex ); } + break; + + case 315: + +/* Line 1806 of yacc.c */ +#line 1279 "parser.yy" + { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Imaginary ); } + break; + + case 317: + +/* Line 1806 of yacc.c */ +#line 1286 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } + break; + + case 318: + +/* Line 1806 of yacc.c */ +#line 1288 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } + break; + + case 319: + +/* Line 1806 of yacc.c */ +#line 1290 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } + break; + + case 320: + +/* Line 1806 of yacc.c */ +#line 1292 "parser.yy" + { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addType( (yyvsp[(1) - (3)].decl) ); } + break; + + case 322: + +/* Line 1806 of yacc.c */ +#line 1298 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } + break; + + case 324: + +/* Line 1806 of yacc.c */ +#line 1305 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } + break; + + case 325: + +/* Line 1806 of yacc.c */ +#line 1307 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } + break; + + case 326: + +/* Line 1806 of yacc.c */ +#line 1309 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addType( (yyvsp[(2) - (2)].decl) ); } + break; + + case 327: + +/* Line 1806 of yacc.c */ +#line 1314 "parser.yy" + { (yyval.decl) = (yyvsp[(3) - (4)].decl); } + break; + + case 328: + +/* Line 1806 of yacc.c */ +#line 1316 "parser.yy" + { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); } + break; + + case 329: + +/* Line 1806 of yacc.c */ +#line 1318 "parser.yy" + { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); } + break; + + case 330: + +/* Line 1806 of yacc.c */ +#line 1320 "parser.yy" + { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); } + break; + + case 332: + +/* Line 1806 of yacc.c */ +#line 1326 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } + break; + + case 333: + +/* Line 1806 of yacc.c */ +#line 1328 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } + break; + + case 334: + +/* Line 1806 of yacc.c */ +#line 1330 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } + break; + + case 336: + +/* Line 1806 of yacc.c */ +#line 1336 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } + break; + + case 337: + +/* Line 1806 of yacc.c */ +#line 1338 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } + break; + + case 339: + +/* Line 1806 of yacc.c */ +#line 1344 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } + break; + + case 340: + +/* Line 1806 of yacc.c */ +#line 1346 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } + break; + + case 341: + +/* Line 1806 of yacc.c */ +#line 1348 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } + break; + + case 342: + +/* Line 1806 of yacc.c */ +#line 1353 "parser.yy" + { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); } + break; + + case 343: + +/* Line 1806 of yacc.c */ +#line 1355 "parser.yy" + { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(2) - (2)].tok) )->addQualifiers( (yyvsp[(1) - (2)].decl) ); } + break; + + case 344: + +/* Line 1806 of yacc.c */ +#line 1357 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } + break; + + case 347: + +/* Line 1806 of yacc.c */ +#line 1367 "parser.yy" + { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (4)].aggKey), 0, 0, 0, (yyvsp[(3) - (4)].decl) ); } + break; + + case 348: + +/* Line 1806 of yacc.c */ +#line 1369 "parser.yy" + { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (2)].aggKey), (yyvsp[(2) - (2)].tok), 0, 0, 0 ); } + break; + + case 349: + +/* Line 1806 of yacc.c */ +#line 1371 "parser.yy" + { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (5)].aggKey), (yyvsp[(2) - (5)].tok), 0, 0, (yyvsp[(4) - (5)].decl) ); } + break; + + case 350: + +/* Line 1806 of yacc.c */ +#line 1373 "parser.yy" + { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (9)].aggKey), 0, (yyvsp[(4) - (9)].decl), 0, (yyvsp[(8) - (9)].decl) ); } + break; + + case 351: + +/* Line 1806 of yacc.c */ +#line 1375 "parser.yy" + { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), (yyvsp[(7) - (7)].tok), (yyvsp[(4) - (7)].decl), 0, 0 ); } + break; + + case 352: + +/* Line 1806 of yacc.c */ +#line 1377 "parser.yy" + { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (10)].aggKey), (yyvsp[(7) - (10)].tok), (yyvsp[(4) - (10)].decl), 0, (yyvsp[(9) - (10)].decl) ); } + break; + + case 353: + +/* Line 1806 of yacc.c */ +#line 1379 "parser.yy" + { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (12)].aggKey), 0, (yyvsp[(4) - (12)].decl), (yyvsp[(8) - (12)].en), (yyvsp[(11) - (12)].decl) ); } + break; + + case 354: + +/* Line 1806 of yacc.c */ +#line 1382 "parser.yy" + { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), (yyvsp[(7) - (7)].tok), 0, (yyvsp[(4) - (7)].en), 0 ); } + break; + + case 355: + +/* Line 1806 of yacc.c */ +#line 1384 "parser.yy" + { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (13)].aggKey), (yyvsp[(10) - (13)].tok), (yyvsp[(4) - (13)].decl), (yyvsp[(8) - (13)].en), (yyvsp[(12) - (13)].decl) ); } + break; + + case 356: + +/* Line 1806 of yacc.c */ +#line 1389 "parser.yy" + { (yyval.aggKey) = DeclarationNode::Struct; } + break; + + case 357: + +/* Line 1806 of yacc.c */ +#line 1391 "parser.yy" + { (yyval.aggKey) = DeclarationNode::Union; } + break; + + case 358: + +/* Line 1806 of yacc.c */ +#line 1396 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (1)].decl); } + break; + + case 359: + +/* Line 1806 of yacc.c */ +#line 1398 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ); } + break; + + case 361: + +/* Line 1806 of yacc.c */ +#line 1404 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 363: + +/* Line 1806 of yacc.c */ +#line 1407 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 365: + +/* Line 1806 of yacc.c */ +#line 1413 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addName( (yyvsp[(2) - (2)].tok) ); } + break; + + case 366: + +/* Line 1806 of yacc.c */ +#line 1415 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(1) - (3)].decl)->cloneType( (yyvsp[(3) - (3)].tok) ) ); } + break; + + case 367: + +/* Line 1806 of yacc.c */ +#line 1417 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(1) - (2)].decl)->cloneType( 0 ) ); } + break; + + case 368: + +/* Line 1806 of yacc.c */ +#line 1422 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); } + break; + + case 369: + +/* Line 1806 of yacc.c */ +#line 1424 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(1) - (4)].decl)->cloneBaseType( (yyvsp[(4) - (4)].decl) ) ); } + break; + + case 370: + +/* Line 1806 of yacc.c */ +#line 1429 "parser.yy" + { (yyval.decl) = DeclarationNode::newName( 0 ); /* XXX */ } + break; + + case 371: + +/* Line 1806 of yacc.c */ +#line 1431 "parser.yy" + { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); } + break; + + case 372: + +/* Line 1806 of yacc.c */ +#line 1434 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); } + break; + + case 373: + +/* Line 1806 of yacc.c */ +#line 1437 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); } + break; + + case 375: + +/* Line 1806 of yacc.c */ +#line 1443 "parser.yy" + { (yyval.en) = 0; } + break; + + case 376: + +/* Line 1806 of yacc.c */ +#line 1445 "parser.yy" + { (yyval.en) = (yyvsp[(1) - (1)].en); } + break; + + case 377: + +/* Line 1806 of yacc.c */ +#line 1450 "parser.yy" + { (yyval.en) = (yyvsp[(2) - (2)].en); } + break; + + case 379: + +/* Line 1806 of yacc.c */ +#line 1459 "parser.yy" + { (yyval.decl) = DeclarationNode::newEnum( 0, (yyvsp[(3) - (5)].decl) ); } + break; + + case 380: + +/* Line 1806 of yacc.c */ +#line 1461 "parser.yy" + { (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(2) - (6)].tok), (yyvsp[(4) - (6)].decl) ); } + break; + + case 381: + +/* Line 1806 of yacc.c */ +#line 1463 "parser.yy" + { (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(2) - (2)].tok), 0 ); } + break; + + case 382: + +/* Line 1806 of yacc.c */ +#line 1468 "parser.yy" + { (yyval.decl) = DeclarationNode::newEnumConstant( (yyvsp[(1) - (2)].tok), (yyvsp[(2) - (2)].en) ); } + break; + + case 383: + +/* Line 1806 of yacc.c */ +#line 1470 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( DeclarationNode::newEnumConstant( (yyvsp[(3) - (4)].tok), (yyvsp[(4) - (4)].en) ) ); } + break; + + case 384: + +/* Line 1806 of yacc.c */ +#line 1475 "parser.yy" + { (yyval.en) = 0; } + break; + + case 385: + +/* Line 1806 of yacc.c */ +#line 1477 "parser.yy" + { (yyval.en) = (yyvsp[(2) - (2)].en); } + break; + + case 386: + +/* Line 1806 of yacc.c */ +#line 1484 "parser.yy" + { (yyval.decl) = 0; } + break; + + case 390: + +/* Line 1806 of yacc.c */ +#line 1492 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } + break; + + case 391: + +/* Line 1806 of yacc.c */ +#line 1494 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); } + break; + + case 392: + +/* Line 1806 of yacc.c */ +#line 1496 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); } + break; + + case 394: + +/* Line 1806 of yacc.c */ +#line 1505 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } + break; + + case 395: + +/* Line 1806 of yacc.c */ +#line 1507 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } + break; + + case 396: + +/* Line 1806 of yacc.c */ +#line 1509 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (9)].decl)->appendList( (yyvsp[(5) - (9)].decl) )->appendList( (yyvsp[(9) - (9)].decl) ); } + break; + + case 398: + +/* Line 1806 of yacc.c */ +#line 1515 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } + break; + + case 399: + +/* Line 1806 of yacc.c */ +#line 1520 "parser.yy" + { (yyval.decl) = 0; } + break; + + case 402: + +/* Line 1806 of yacc.c */ +#line 1527 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); } + break; + + case 405: + +/* Line 1806 of yacc.c */ +#line 1534 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } + break; + + case 406: + +/* Line 1806 of yacc.c */ +#line 1536 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } + break; + + case 408: + +/* Line 1806 of yacc.c */ +#line 1546 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); } + break; + + case 409: + +/* Line 1806 of yacc.c */ +#line 1549 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); } + break; + + case 410: + +/* Line 1806 of yacc.c */ +#line 1551 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addName( (yyvsp[(3) - (4)].tok) )->addQualifiers( (yyvsp[(1) - (4)].decl) ); } + break; + + case 415: + +/* Line 1806 of yacc.c */ +#line 1561 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } + break; + + case 417: + +/* Line 1806 of yacc.c */ +#line 1567 "parser.yy" + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + (yyval.decl) = (yyvsp[(2) - (3)].decl)->addType( (yyvsp[(1) - (3)].decl) )->addInitializer( new InitializerNode((yyvsp[(3) - (3)].en)) ); + } + break; + + case 418: + +/* Line 1806 of yacc.c */ +#line 1572 "parser.yy" + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + (yyval.decl) = (yyvsp[(2) - (3)].decl)->addType( (yyvsp[(1) - (3)].decl) )->addInitializer( new InitializerNode((yyvsp[(3) - (3)].en)) ); + } + break; + + case 420: + +/* Line 1806 of yacc.c */ +#line 1581 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); } + break; + + case 421: + +/* Line 1806 of yacc.c */ +#line 1590 "parser.yy" + { (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); } + break; + + case 422: + +/* Line 1806 of yacc.c */ +#line 1592 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( DeclarationNode::newName( (yyvsp[(3) - (3)].tok) ) ); } + break; + + case 434: + +/* Line 1806 of yacc.c */ +#line 1617 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); } + break; + + case 438: + +/* Line 1806 of yacc.c */ +#line 1625 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); } + break; + + case 439: + +/* Line 1806 of yacc.c */ +#line 1630 "parser.yy" + { (yyval.in) = 0; } + break; + + case 440: + +/* Line 1806 of yacc.c */ +#line 1631 "parser.yy" + { (yyval.in) = (yyvsp[(2) - (2)].in); } + break; + + case 441: + +/* Line 1806 of yacc.c */ +#line 1635 "parser.yy" + { (yyval.in) = new InitializerNode((yyvsp[(1) - (1)].en)); } + break; + + case 442: + +/* Line 1806 of yacc.c */ +#line 1636 "parser.yy" + { (yyval.in) = new InitializerNode((yyvsp[(2) - (4)].in), true); } + break; + + case 444: + +/* Line 1806 of yacc.c */ +#line 1641 "parser.yy" + { (yyval.in) = (yyvsp[(2) - (2)].in)->set_designators( (yyvsp[(1) - (2)].en) ); } + break; + + case 445: + +/* Line 1806 of yacc.c */ +#line 1642 "parser.yy" + { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (3)].in)->set_link((yyvsp[(3) - (3)].in)) ); } + break; + + case 446: + +/* Line 1806 of yacc.c */ +#line 1644 "parser.yy" + { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (4)].in)->set_link( (yyvsp[(4) - (4)].in)->set_designators((yyvsp[(3) - (4)].en)) ) ); } + break; + + case 448: + +/* Line 1806 of yacc.c */ +#line 1660 "parser.yy" + { (yyval.en) = new VarRefNode( (yyvsp[(1) - (2)].tok) ); } + break; + + case 450: + +/* Line 1806 of yacc.c */ +#line 1665 "parser.yy" + { (yyval.en) = (ExpressionNode *)((yyvsp[(1) - (2)].en)->set_link( (yyvsp[(2) - (2)].en) )); } + break; + + case 451: + +/* Line 1806 of yacc.c */ +#line 1670 "parser.yy" + { (yyval.en) = new VarRefNode( (yyvsp[(2) - (2)].tok) ); } + break; + + case 452: + +/* Line 1806 of yacc.c */ +#line 1674 "parser.yy" + { (yyval.en) = (yyvsp[(3) - (5)].en); } + break; + + case 453: + +/* Line 1806 of yacc.c */ +#line 1676 "parser.yy" + { (yyval.en) = (yyvsp[(3) - (5)].en); } + break; + + case 454: + +/* Line 1806 of yacc.c */ +#line 1678 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::Range), (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].en)); } + break; + + case 455: + +/* Line 1806 of yacc.c */ +#line 1680 "parser.yy" + { (yyval.en) = (yyvsp[(4) - (6)].en); } + break; + + case 457: + +/* Line 1806 of yacc.c */ +#line 1705 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } + break; + + case 458: + +/* Line 1806 of yacc.c */ +#line 1707 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } + break; + + case 459: + +/* Line 1806 of yacc.c */ +#line 1709 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } + break; + + case 460: + +/* Line 1806 of yacc.c */ +#line 1714 "parser.yy" + { (yyval.decl) = DeclarationNode::newFromTypeGen( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); } + break; + + case 461: + +/* Line 1806 of yacc.c */ +#line 1716 "parser.yy" + { (yyval.decl) = DeclarationNode::newFromTypeGen( (yyvsp[(2) - (5)].tok), (yyvsp[(4) - (5)].en) )->addQualifiers( (yyvsp[(1) - (5)].decl) ); } + break; + + case 462: + +/* Line 1806 of yacc.c */ +#line 1718 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } + break; + + case 464: + +/* Line 1806 of yacc.c */ +#line 1724 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(3) - (4)].decl) ); } + break; + + case 465: + +/* Line 1806 of yacc.c */ +#line 1729 "parser.yy" + { typedefTable.addToEnclosingScope(*((yyvsp[(2) - (2)].tok)), TypedefTable::TD); } + break; + + case 466: + +/* Line 1806 of yacc.c */ +#line 1731 "parser.yy" + { (yyval.decl) = DeclarationNode::newTypeParam( (yyvsp[(1) - (4)].tclass), (yyvsp[(2) - (4)].tok) )->addAssertions( (yyvsp[(4) - (4)].decl) ); } + break; + + case 468: + +/* Line 1806 of yacc.c */ +#line 1737 "parser.yy" + { (yyval.tclass) = DeclarationNode::Type; } + break; + + case 469: + +/* Line 1806 of yacc.c */ +#line 1739 "parser.yy" + { (yyval.tclass) = DeclarationNode::Ftype; } + break; + + case 470: + +/* Line 1806 of yacc.c */ +#line 1741 "parser.yy" + { (yyval.tclass) = DeclarationNode::Dtype; } + break; + + case 471: + +/* Line 1806 of yacc.c */ +#line 1746 "parser.yy" + { (yyval.decl) = 0; } + break; + + case 472: + +/* Line 1806 of yacc.c */ +#line 1748 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (2)].decl) == 0 ? (yyvsp[(2) - (2)].decl) : (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ); } + break; + + case 473: + +/* Line 1806 of yacc.c */ +#line 1753 "parser.yy" + { + typedefTable.openContext( *((yyvsp[(2) - (5)].tok)) ); + (yyval.decl) = DeclarationNode::newContextUse( (yyvsp[(2) - (5)].tok), (yyvsp[(4) - (5)].en) ); + } + break; + + case 474: + +/* Line 1806 of yacc.c */ +#line 1758 "parser.yy" + { (yyval.decl) = (yyvsp[(4) - (5)].decl); } + break; + + case 475: + +/* Line 1806 of yacc.c */ +#line 1760 "parser.yy" + { (yyval.decl) = 0; } + break; + + case 476: + +/* Line 1806 of yacc.c */ +#line 1765 "parser.yy" + { (yyval.en) = new TypeValueNode( (yyvsp[(1) - (1)].decl) ); } + break; + + case 478: + +/* Line 1806 of yacc.c */ +#line 1768 "parser.yy" + { (yyval.en) = (ExpressionNode *)((yyvsp[(1) - (3)].en)->set_link(new TypeValueNode( (yyvsp[(3) - (3)].decl) ))); } + break; + + case 479: + +/* Line 1806 of yacc.c */ +#line 1770 "parser.yy" + { (yyval.en) = (ExpressionNode *)((yyvsp[(1) - (3)].en)->set_link((yyvsp[(3) - (3)].en))); } + break; + + case 480: + +/* Line 1806 of yacc.c */ +#line 1775 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl); } + break; + + case 481: + +/* Line 1806 of yacc.c */ +#line 1777 "parser.yy" + { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) ); } + break; + + case 482: + +/* Line 1806 of yacc.c */ +#line 1779 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl)->copyStorageClasses( (yyvsp[(1) - (3)].decl) ) ); } + break; + + case 483: + +/* Line 1806 of yacc.c */ +#line 1784 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addAssertions( (yyvsp[(2) - (2)].decl) ); } + break; + + case 484: + +/* Line 1806 of yacc.c */ +#line 1786 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addAssertions( (yyvsp[(2) - (4)].decl) )->addType( (yyvsp[(4) - (4)].decl) ); } + break; + + case 485: + +/* Line 1806 of yacc.c */ +#line 1791 "parser.yy" + { + typedefTable.addToEnclosingScope(*((yyvsp[(1) - (1)].tok)), TypedefTable::TD); + (yyval.decl) = DeclarationNode::newTypeDecl( (yyvsp[(1) - (1)].tok), 0 ); + } + break; + + case 486: + +/* Line 1806 of yacc.c */ +#line 1796 "parser.yy" + { + typedefTable.addToEnclosingScope(*((yyvsp[(1) - (6)].tok)), TypedefTable::TG); + (yyval.decl) = DeclarationNode::newTypeDecl( (yyvsp[(1) - (6)].tok), (yyvsp[(4) - (6)].decl) ); + } + break; + + case 487: + +/* Line 1806 of yacc.c */ +#line 1804 "parser.yy" + { + typedefTable.addToEnclosingScope(*((yyvsp[(2) - (9)].tok)), TypedefTable::ID ); + (yyval.decl) = DeclarationNode::newContext( (yyvsp[(2) - (9)].tok), (yyvsp[(5) - (9)].decl), 0 ); + } + break; + + case 488: + +/* Line 1806 of yacc.c */ +#line 1809 "parser.yy" + { + typedefTable.enterContext( *((yyvsp[(2) - (8)].tok)) ); + typedefTable.enterScope(); + } + break; + + case 489: + +/* Line 1806 of yacc.c */ +#line 1814 "parser.yy" + { + typedefTable.leaveContext(); + typedefTable.addToEnclosingScope(*((yyvsp[(2) - (11)].tok)), TypedefTable::ID ); + (yyval.decl) = DeclarationNode::newContext( (yyvsp[(2) - (11)].tok), (yyvsp[(5) - (11)].decl), (yyvsp[(10) - (11)].decl) ); + } + break; + + case 491: + +/* Line 1806 of yacc.c */ +#line 1824 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); } + break; + + case 494: + +/* Line 1806 of yacc.c */ +#line 1834 "parser.yy" + { + typedefTable.addToEnclosingScope2( TypedefTable::ID ); + (yyval.decl) = (yyvsp[(1) - (1)].decl); + } + break; + + case 495: + +/* Line 1806 of yacc.c */ +#line 1839 "parser.yy" + { + typedefTable.addToEnclosingScope2( TypedefTable::ID ); + (yyval.decl) = (yyvsp[(1) - (1)].decl); + } + break; + + case 496: + +/* Line 1806 of yacc.c */ +#line 1844 "parser.yy" + { + typedefTable.addToEnclosingScope2( *((yyvsp[(5) - (5)].tok)), TypedefTable::ID ); + (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(1) - (5)].decl)->cloneType( (yyvsp[(5) - (5)].tok) ) ); + } + break; + + case 497: + +/* Line 1806 of yacc.c */ +#line 1852 "parser.yy" + { + typedefTable.addToEnclosingScope2( TypedefTable::ID ); + (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); + } + break; + + case 498: + +/* Line 1806 of yacc.c */ +#line 1857 "parser.yy" + { + typedefTable.addToEnclosingScope2( TypedefTable::ID ); + (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(1) - (5)].decl)->cloneBaseType( (yyvsp[(5) - (5)].decl) ) ); + } + break; + + case 499: + +/* Line 1806 of yacc.c */ +#line 1867 "parser.yy" + {} + break; + + case 500: + +/* Line 1806 of yacc.c */ +#line 1869 "parser.yy" + { + if ( theTree ) { + theTree->appendList( (yyvsp[(1) - (1)].decl) ); + } else { + theTree = (yyvsp[(1) - (1)].decl); + } + } + break; + + case 502: + +/* Line 1806 of yacc.c */ +#line 1881 "parser.yy" + { (yyval.decl) = ((yyvsp[(1) - (3)].decl) != NULL ) ? (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ) : (yyvsp[(3) - (3)].decl); } + break; + + case 503: + +/* Line 1806 of yacc.c */ +#line 1886 "parser.yy" + { (yyval.decl) = 0; } + break; + + case 507: + +/* Line 1806 of yacc.c */ +#line 1894 "parser.yy" + {} + break; + + case 508: + +/* Line 1806 of yacc.c */ +#line 1896 "parser.yy" + { + linkageStack.push( linkage ); + linkage = LinkageSpec::fromString( *(yyvsp[(2) - (2)].tok) ); + } + break; + + case 509: + +/* Line 1806 of yacc.c */ +#line 1901 "parser.yy" + { + linkage = linkageStack.top(); + linkageStack.pop(); + (yyval.decl) = (yyvsp[(5) - (6)].decl); + } + break; + + case 510: + +/* Line 1806 of yacc.c */ +#line 1907 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl); } + break; + + case 512: + +/* Line 1806 of yacc.c */ +#line 1919 "parser.yy" + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + typedefTable.leaveScope(); + (yyval.decl) = (yyvsp[(1) - (2)].decl)->addFunctionBody( (yyvsp[(2) - (2)].sn) ); + } + break; + + case 513: + +/* Line 1806 of yacc.c */ +#line 1925 "parser.yy" + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + typedefTable.leaveScope(); + (yyval.decl) = (yyvsp[(1) - (4)].decl)->addOldDeclList( (yyvsp[(3) - (4)].decl) )->addFunctionBody( (yyvsp[(4) - (4)].sn) ); + } + break; + + case 514: + +/* Line 1806 of yacc.c */ +#line 1934 "parser.yy" + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + typedefTable.leaveScope(); + (yyval.decl) = (yyvsp[(1) - (2)].decl)->addFunctionBody( (yyvsp[(2) - (2)].sn) ); + } + break; + + case 515: + +/* Line 1806 of yacc.c */ +#line 1940 "parser.yy" + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + typedefTable.leaveScope(); + (yyval.decl) = (yyvsp[(2) - (3)].decl)->addFunctionBody( (yyvsp[(3) - (3)].sn) )->addType( (yyvsp[(1) - (3)].decl) ); + } + break; + + case 516: + +/* Line 1806 of yacc.c */ +#line 1946 "parser.yy" + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + typedefTable.leaveScope(); + (yyval.decl) = (yyvsp[(2) - (3)].decl)->addFunctionBody( (yyvsp[(3) - (3)].sn) )->addQualifiers( (yyvsp[(1) - (3)].decl) ); + } + break; + + case 517: + +/* Line 1806 of yacc.c */ +#line 1952 "parser.yy" + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + typedefTable.leaveScope(); + (yyval.decl) = (yyvsp[(2) - (3)].decl)->addFunctionBody( (yyvsp[(3) - (3)].sn) )->addQualifiers( (yyvsp[(1) - (3)].decl) ); + } + break; + + case 518: + +/* Line 1806 of yacc.c */ +#line 1958 "parser.yy" + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + typedefTable.leaveScope(); + (yyval.decl) = (yyvsp[(3) - (4)].decl)->addFunctionBody( (yyvsp[(4) - (4)].sn) )->addQualifiers( (yyvsp[(2) - (4)].decl) )->addQualifiers( (yyvsp[(1) - (4)].decl) ); + } + break; + + case 519: + +/* Line 1806 of yacc.c */ +#line 1966 "parser.yy" + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + typedefTable.leaveScope(); + (yyval.decl) = (yyvsp[(2) - (5)].decl)->addOldDeclList( (yyvsp[(4) - (5)].decl) )->addFunctionBody( (yyvsp[(5) - (5)].sn) )->addType( (yyvsp[(1) - (5)].decl) ); + } + break; + + case 520: + +/* Line 1806 of yacc.c */ +#line 1972 "parser.yy" + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + typedefTable.leaveScope(); + (yyval.decl) = (yyvsp[(2) - (5)].decl)->addOldDeclList( (yyvsp[(4) - (5)].decl) )->addFunctionBody( (yyvsp[(5) - (5)].sn) )->addQualifiers( (yyvsp[(1) - (5)].decl) ); + } + break; + + case 521: + +/* Line 1806 of yacc.c */ +#line 1980 "parser.yy" + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + typedefTable.leaveScope(); + (yyval.decl) = (yyvsp[(2) - (5)].decl)->addOldDeclList( (yyvsp[(4) - (5)].decl) )->addFunctionBody( (yyvsp[(5) - (5)].sn) )->addQualifiers( (yyvsp[(1) - (5)].decl) ); + } + break; + + case 522: + +/* Line 1806 of yacc.c */ +#line 1986 "parser.yy" + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + typedefTable.leaveScope(); + (yyval.decl) = (yyvsp[(3) - (6)].decl)->addOldDeclList( (yyvsp[(5) - (6)].decl) )->addFunctionBody( (yyvsp[(6) - (6)].sn) )->addQualifiers( (yyvsp[(2) - (6)].decl) )->addQualifiers( (yyvsp[(1) - (6)].decl) ); + } + break; + + case 526: + +/* Line 1806 of yacc.c */ +#line 2001 "parser.yy" + { (yyval.en) = new CompositeExprNode(new OperatorNode(OperatorNode::Range), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en)); } + break; + + case 539: + +/* Line 1806 of yacc.c */ +#line 2035 "parser.yy" + {} + break; + + case 540: + +/* Line 1806 of yacc.c */ +#line 2036 "parser.yy" + {} + break; + + case 541: + +/* Line 1806 of yacc.c */ +#line 2037 "parser.yy" + {} + break; + + case 542: + +/* Line 1806 of yacc.c */ +#line 2038 "parser.yy" + {} + break; + + case 547: + +/* Line 1806 of yacc.c */ +#line 2081 "parser.yy" + { + typedefTable.setNextIdentifier( *((yyvsp[(1) - (1)].tok)) ); + (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); + } + break; + + case 548: + +/* Line 1806 of yacc.c */ +#line 2086 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 549: + +/* Line 1806 of yacc.c */ +#line 2091 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } + break; + + case 550: + +/* Line 1806 of yacc.c */ +#line 2093 "parser.yy" + { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } + break; + + case 551: + +/* Line 1806 of yacc.c */ +#line 2095 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 552: + +/* Line 1806 of yacc.c */ +#line 2100 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); } + break; + + case 553: + +/* Line 1806 of yacc.c */ +#line 2102 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + break; + + case 554: + +/* Line 1806 of yacc.c */ +#line 2104 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + break; + + case 555: + +/* Line 1806 of yacc.c */ +#line 2106 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 556: + +/* Line 1806 of yacc.c */ +#line 2111 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } + break; + + case 557: + +/* Line 1806 of yacc.c */ +#line 2113 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 561: + +/* Line 1806 of yacc.c */ +#line 2129 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); } + break; + + case 562: + +/* Line 1806 of yacc.c */ +#line 2131 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } + break; + + case 563: + +/* Line 1806 of yacc.c */ +#line 2133 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 564: + +/* Line 1806 of yacc.c */ +#line 2138 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } + break; + + case 565: + +/* Line 1806 of yacc.c */ +#line 2140 "parser.yy" + { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } + break; + + case 566: + +/* Line 1806 of yacc.c */ +#line 2142 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 567: + +/* Line 1806 of yacc.c */ +#line 2147 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + break; + + case 568: + +/* Line 1806 of yacc.c */ +#line 2149 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + break; + + case 569: + +/* Line 1806 of yacc.c */ +#line 2151 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 573: + +/* Line 1806 of yacc.c */ +#line 2166 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addIdList( (yyvsp[(3) - (4)].decl) ); } + break; + + case 574: + +/* Line 1806 of yacc.c */ +#line 2168 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (6)].decl)->addIdList( (yyvsp[(5) - (6)].decl) ); } + break; + + case 575: + +/* Line 1806 of yacc.c */ +#line 2170 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 576: + +/* Line 1806 of yacc.c */ +#line 2175 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } + break; + + case 577: + +/* Line 1806 of yacc.c */ +#line 2177 "parser.yy" + { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } + break; + + case 578: + +/* Line 1806 of yacc.c */ +#line 2179 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 579: + +/* Line 1806 of yacc.c */ +#line 2184 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + break; + + case 580: + +/* Line 1806 of yacc.c */ +#line 2186 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + break; + + case 581: + +/* Line 1806 of yacc.c */ +#line 2188 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 586: + +/* Line 1806 of yacc.c */ +#line 2210 "parser.yy" + { + typedefTable.setNextIdentifier( *((yyvsp[(1) - (1)].tok)) ); + (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); + } + break; + + case 587: + +/* Line 1806 of yacc.c */ +#line 2215 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 588: + +/* Line 1806 of yacc.c */ +#line 2220 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } + break; + + case 589: + +/* Line 1806 of yacc.c */ +#line 2222 "parser.yy" + { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } + break; + + case 590: + +/* Line 1806 of yacc.c */ +#line 2224 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 591: + +/* Line 1806 of yacc.c */ +#line 2229 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); } + break; + + case 592: + +/* Line 1806 of yacc.c */ +#line 2231 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + break; + + case 593: + +/* Line 1806 of yacc.c */ +#line 2233 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + break; + + case 594: + +/* Line 1806 of yacc.c */ +#line 2235 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 595: + +/* Line 1806 of yacc.c */ +#line 2240 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); } + break; + + case 596: + +/* Line 1806 of yacc.c */ +#line 2242 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } + break; + + case 597: + +/* Line 1806 of yacc.c */ +#line 2244 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 602: + +/* Line 1806 of yacc.c */ +#line 2261 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } + break; + + case 603: + +/* Line 1806 of yacc.c */ +#line 2263 "parser.yy" + { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } + break; + + case 604: + +/* Line 1806 of yacc.c */ +#line 2265 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 605: + +/* Line 1806 of yacc.c */ +#line 2270 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); } + break; + + case 606: + +/* Line 1806 of yacc.c */ +#line 2272 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + break; + + case 607: + +/* Line 1806 of yacc.c */ +#line 2274 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + break; + + case 608: + +/* Line 1806 of yacc.c */ +#line 2276 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 609: + +/* Line 1806 of yacc.c */ +#line 2281 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); } + break; + + case 610: + +/* Line 1806 of yacc.c */ +#line 2283 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } + break; + + case 611: + +/* Line 1806 of yacc.c */ +#line 2285 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 616: + +/* Line 1806 of yacc.c */ +#line 2323 "parser.yy" + { + typedefTable.setNextIdentifier( *((yyvsp[(1) - (1)].tok)) ); + (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); + } + break; + + case 617: + +/* Line 1806 of yacc.c */ +#line 2331 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } + break; + + case 618: + +/* Line 1806 of yacc.c */ +#line 2333 "parser.yy" + { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } + break; + + case 619: + +/* Line 1806 of yacc.c */ +#line 2335 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 620: + +/* Line 1806 of yacc.c */ +#line 2340 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); } + break; + + case 621: + +/* Line 1806 of yacc.c */ +#line 2342 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + break; + + case 622: + +/* Line 1806 of yacc.c */ +#line 2347 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); } + break; + + case 623: + +/* Line 1806 of yacc.c */ +#line 2349 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } + break; + + case 627: + +/* Line 1806 of yacc.c */ +#line 2369 "parser.yy" + { (yyval.decl) = DeclarationNode::newPointer( 0 ); } + break; + + case 628: + +/* Line 1806 of yacc.c */ +#line 2371 "parser.yy" + { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); } + break; + + case 629: + +/* Line 1806 of yacc.c */ +#line 2373 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } + break; + + case 630: + +/* Line 1806 of yacc.c */ +#line 2375 "parser.yy" + { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } + break; + + case 631: + +/* Line 1806 of yacc.c */ +#line 2377 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 633: + +/* Line 1806 of yacc.c */ +#line 2383 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + break; + + case 634: + +/* Line 1806 of yacc.c */ +#line 2385 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + break; + + case 635: + +/* Line 1806 of yacc.c */ +#line 2387 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 636: + +/* Line 1806 of yacc.c */ +#line 2392 "parser.yy" + { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); } + break; + + case 637: + +/* Line 1806 of yacc.c */ +#line 2394 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } + break; + + case 638: + +/* Line 1806 of yacc.c */ +#line 2396 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 639: + +/* Line 1806 of yacc.c */ +#line 2402 "parser.yy" + { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); } + break; + + case 640: + +/* Line 1806 of yacc.c */ +#line 2404 "parser.yy" + { (yyval.decl) = DeclarationNode::newArray( 0, 0, false )->addArray( (yyvsp[(5) - (5)].decl) ); } + break; + + case 642: + +/* Line 1806 of yacc.c */ +#line 2410 "parser.yy" + { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(3) - (5)].en), 0, false ); } + break; + + case 643: + +/* Line 1806 of yacc.c */ +#line 2412 "parser.yy" + { (yyval.decl) = DeclarationNode::newVarArray( 0 ); } + break; + + case 644: + +/* Line 1806 of yacc.c */ +#line 2414 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newArray( (yyvsp[(4) - (6)].en), 0, false ) ); } + break; + + case 645: + +/* Line 1806 of yacc.c */ +#line 2416 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newVarArray( 0 ) ); } + break; + + case 649: + +/* Line 1806 of yacc.c */ +#line 2436 "parser.yy" + { (yyval.decl) = DeclarationNode::newPointer( 0 ); } + break; + + case 650: + +/* Line 1806 of yacc.c */ +#line 2438 "parser.yy" + { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); } + break; + + case 651: + +/* Line 1806 of yacc.c */ +#line 2440 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } + break; + + case 652: + +/* Line 1806 of yacc.c */ +#line 2442 "parser.yy" + { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } + break; + + case 653: + +/* Line 1806 of yacc.c */ +#line 2444 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 655: + +/* Line 1806 of yacc.c */ +#line 2450 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + break; + + case 656: + +/* Line 1806 of yacc.c */ +#line 2452 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + break; + + case 657: + +/* Line 1806 of yacc.c */ +#line 2454 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 658: + +/* Line 1806 of yacc.c */ +#line 2459 "parser.yy" + { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); } + break; + + case 659: + +/* Line 1806 of yacc.c */ +#line 2461 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } + break; + + case 660: + +/* Line 1806 of yacc.c */ +#line 2463 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 662: + +/* Line 1806 of yacc.c */ +#line 2470 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); } + break; + + case 664: + +/* Line 1806 of yacc.c */ +#line 2482 "parser.yy" + { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); } + break; + + case 665: + +/* Line 1806 of yacc.c */ +#line 2485 "parser.yy" + { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); } + break; + + case 666: + +/* Line 1806 of yacc.c */ +#line 2487 "parser.yy" + { (yyval.decl) = DeclarationNode::newArray( 0, (yyvsp[(3) - (5)].decl), false ); } + break; + + case 667: + +/* Line 1806 of yacc.c */ +#line 2490 "parser.yy" + { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); } + break; + + case 668: + +/* Line 1806 of yacc.c */ +#line 2492 "parser.yy" + { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl), true ); } + break; + + case 669: + +/* Line 1806 of yacc.c */ +#line 2494 "parser.yy" + { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(3) - (7)].decl), true ); } + break; + + case 673: + +/* Line 1806 of yacc.c */ +#line 2513 "parser.yy" + { (yyval.decl) = DeclarationNode::newPointer( 0 ); } + break; + + case 674: + +/* Line 1806 of yacc.c */ +#line 2515 "parser.yy" + { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); } + break; + + case 675: + +/* Line 1806 of yacc.c */ +#line 2517 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } + break; + + case 676: + +/* Line 1806 of yacc.c */ +#line 2519 "parser.yy" + { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } + break; + + case 677: + +/* Line 1806 of yacc.c */ +#line 2521 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 679: + +/* Line 1806 of yacc.c */ +#line 2527 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + break; + + case 680: + +/* Line 1806 of yacc.c */ +#line 2529 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + break; + + case 681: + +/* Line 1806 of yacc.c */ +#line 2531 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 682: + +/* Line 1806 of yacc.c */ +#line 2536 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } + break; + + case 683: + +/* Line 1806 of yacc.c */ +#line 2538 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 686: + +/* Line 1806 of yacc.c */ +#line 2548 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } + break; + + case 689: + +/* Line 1806 of yacc.c */ +#line 2558 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } + break; + + case 690: + +/* Line 1806 of yacc.c */ +#line 2560 "parser.yy" + { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } + break; + + case 691: + +/* Line 1806 of yacc.c */ +#line 2562 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } + break; + + case 692: + +/* Line 1806 of yacc.c */ +#line 2564 "parser.yy" + { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } + break; + + case 693: + +/* Line 1806 of yacc.c */ +#line 2566 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } + break; + + case 694: + +/* Line 1806 of yacc.c */ +#line 2568 "parser.yy" + { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } + break; + + case 695: + +/* Line 1806 of yacc.c */ +#line 2575 "parser.yy" + { (yyval.decl) = (yyvsp[(5) - (5)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } + break; + + case 696: + +/* Line 1806 of yacc.c */ +#line 2577 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } + break; + + case 697: + +/* Line 1806 of yacc.c */ +#line 2579 "parser.yy" + { (yyval.decl) = (yyvsp[(6) - (6)].decl)->addNewArray( (yyvsp[(5) - (6)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } + break; + + case 698: + +/* Line 1806 of yacc.c */ +#line 2581 "parser.yy" + { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); } + break; + + case 699: + +/* Line 1806 of yacc.c */ +#line 2583 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } + break; + + case 700: + +/* Line 1806 of yacc.c */ +#line 2585 "parser.yy" + { (yyval.decl) = (yyvsp[(5) - (5)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } + break; + + case 701: + +/* Line 1806 of yacc.c */ +#line 2587 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } + break; + + case 702: + +/* Line 1806 of yacc.c */ +#line 2589 "parser.yy" + { (yyval.decl) = (yyvsp[(6) - (6)].decl)->addNewArray( (yyvsp[(5) - (6)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } + break; + + case 703: + +/* Line 1806 of yacc.c */ +#line 2591 "parser.yy" + { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); } + break; + + case 704: + +/* Line 1806 of yacc.c */ +#line 2593 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } + break; + + case 705: + +/* Line 1806 of yacc.c */ +#line 2598 "parser.yy" + { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); } + break; + + case 706: + +/* Line 1806 of yacc.c */ +#line 2600 "parser.yy" + { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); } + break; + + case 707: + +/* Line 1806 of yacc.c */ +#line 2605 "parser.yy" + { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), true ); } + break; + + case 708: + +/* Line 1806 of yacc.c */ +#line 2607 "parser.yy" + { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl)->addQualifiers( (yyvsp[(3) - (7)].decl) ), true ); } + break; + + case 710: + +/* Line 1806 of yacc.c */ +#line 2634 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } + break; + + case 714: + +/* Line 1806 of yacc.c */ +#line 2645 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } + break; + + case 715: + +/* Line 1806 of yacc.c */ +#line 2647 "parser.yy" + { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } + break; + + case 716: + +/* Line 1806 of yacc.c */ +#line 2649 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } + break; + + case 717: + +/* Line 1806 of yacc.c */ +#line 2651 "parser.yy" + { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } + break; + + case 718: + +/* Line 1806 of yacc.c */ +#line 2653 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } + break; + + case 719: + +/* Line 1806 of yacc.c */ +#line 2655 "parser.yy" + { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } + break; + + case 720: + +/* Line 1806 of yacc.c */ +#line 2662 "parser.yy" + { (yyval.decl) = (yyvsp[(5) - (5)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } + break; + + case 721: + +/* Line 1806 of yacc.c */ +#line 2664 "parser.yy" + { (yyval.decl) = (yyvsp[(6) - (6)].decl)->addNewArray( (yyvsp[(5) - (6)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } + break; + + case 722: + +/* Line 1806 of yacc.c */ +#line 2666 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } + break; + + case 723: + +/* Line 1806 of yacc.c */ +#line 2668 "parser.yy" + { (yyval.decl) = (yyvsp[(5) - (5)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } + break; + + case 724: + +/* Line 1806 of yacc.c */ +#line 2670 "parser.yy" + { (yyval.decl) = (yyvsp[(6) - (6)].decl)->addNewArray( (yyvsp[(5) - (6)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } + break; + + case 725: + +/* Line 1806 of yacc.c */ +#line 2672 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } + break; + + case 726: + +/* Line 1806 of yacc.c */ +#line 2677 "parser.yy" + { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); } + break; + + case 727: + +/* Line 1806 of yacc.c */ +#line 2682 "parser.yy" + { (yyval.decl) = DeclarationNode::newFunction( 0, DeclarationNode::newTuple( 0 ), (yyvsp[(6) - (7)].decl), 0 ); } + break; + + case 728: + +/* Line 1806 of yacc.c */ +#line 2684 "parser.yy" + { (yyval.decl) = DeclarationNode::newFunction( 0, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), 0 ); } + break; + + case 729: + +/* Line 1806 of yacc.c */ +#line 2686 "parser.yy" + { (yyval.decl) = DeclarationNode::newFunction( 0, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), 0 ); } + break; + + case 732: + +/* Line 1806 of yacc.c */ +#line 2712 "parser.yy" + { (yyval.en) = 0; } + break; + + case 733: + +/* Line 1806 of yacc.c */ +#line 2714 "parser.yy" + { (yyval.en) = (yyvsp[(2) - (2)].en); } + break; + + + +/* Line 1806 of yacc.c */ +#line 9034 "Parser/parser.cc" + default: break; + } + /* User semantic actions sometimes alter yychar, and that requires + that yytoken be updated with the new translation. We take the + approach of translating immediately before every use of yytoken. + One alternative is translating here after every semantic action, + but that translation would be missed if the semantic action invokes + YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or + if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an + incorrect destructor might then be invoked immediately. In the + case of YYERROR or YYBACKUP, subsequent parser actions might lead + to an incorrect destructor call or verbose syntax error message + before the lookahead is translated. */ + YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); + + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + + *++yyvsp = yyval; + + /* Now `shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; + if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTOKENS]; + + goto yynewstate; + + +/*------------------------------------. +| yyerrlab -- here on detecting error | +`------------------------------------*/ +yyerrlab: + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); + + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) + { + ++yynerrs; +#if ! YYERROR_VERBOSE + yyerror (YY_("syntax error")); +#else +# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ + yyssp, yytoken) + { + char const *yymsgp = YY_("syntax error"); + int yysyntax_error_status; + yysyntax_error_status = YYSYNTAX_ERROR; + if (yysyntax_error_status == 0) + yymsgp = yymsg; + else if (yysyntax_error_status == 1) + { + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); + yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); + if (!yymsg) + { + yymsg = yymsgbuf; + yymsg_alloc = sizeof yymsgbuf; + yysyntax_error_status = 2; + } + else + { + yysyntax_error_status = YYSYNTAX_ERROR; + yymsgp = yymsg; + } + } + yyerror (yymsgp); + if (yysyntax_error_status == 2) + goto yyexhaustedlab; + } +# undef YYSYNTAX_ERROR +#endif + } + + + + if (yyerrstatus == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + if (yychar <= YYEOF) + { + /* Return failure if at end of input. */ + if (yychar == YYEOF) + YYABORT; + } + else + { + yydestruct ("Error: discarding", + yytoken, &yylval); + yychar = YYEMPTY; + } + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + goto yyerrlab1; + + +/*---------------------------------------------------. +| yyerrorlab -- error raised explicitly by YYERROR. | +`---------------------------------------------------*/ +yyerrorlab: + + /* Pacify compilers like GCC when the user code never invokes + YYERROR and the label yyerrorlab therefore never appears in user + code. */ + if (/*CONSTCOND*/ 0) + goto yyerrorlab; + + /* Do not reclaim the symbols of the rule which action triggered + this YYERROR. */ + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + yystate = *yyssp; + goto yyerrlab1; + + +/*-------------------------------------------------------------. +| yyerrlab1 -- common code for both syntax error and YYERROR. | +`-------------------------------------------------------------*/ +yyerrlab1: + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + for (;;) + { + yyn = yypact[yystate]; + if (!yypact_value_is_default (yyn)) + { + yyn += YYTERROR; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; + + + yydestruct ("Error: popping", + yystos[yystate], yyvsp); + YYPOPSTACK (1); + yystate = *yyssp; + YY_STACK_PRINT (yyss, yyssp); + } + + *++yyvsp = yylval; + + + /* Shift the error token. */ + YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); + + yystate = yyn; + goto yynewstate; + + +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturn; + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yyresult = 1; + goto yyreturn; + +#if !defined(yyoverflow) || YYERROR_VERBOSE +/*-------------------------------------------------. +| yyexhaustedlab -- memory exhaustion comes here. | +`-------------------------------------------------*/ +yyexhaustedlab: + yyerror (YY_("memory exhausted")); + yyresult = 2; + /* Fall through. */ +#endif + +yyreturn: + if (yychar != YYEMPTY) + { + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = YYTRANSLATE (yychar); + yydestruct ("Cleanup: discarding lookahead", + yytoken, &yylval); + } + /* Do not reclaim the symbols of the rule which action triggered + this YYABORT or YYACCEPT. */ + YYPOPSTACK (yylen); + YY_STACK_PRINT (yyss, yyssp); + while (yyssp != yyss) + { + yydestruct ("Cleanup: popping", + yystos[*yyssp], yyvsp); + YYPOPSTACK (1); + } +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); +#endif +#if YYERROR_VERBOSE + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); +#endif + /* Make sure YYID is used. */ + return YYID (yyresult); +} + + + +/* Line 2067 of yacc.c */ +#line 2717 "parser.yy" + +// ----end of grammar---- + +void yyerror( char *string ) { + using std::cout; + using std::endl; + cout << "Error "; + if ( yyfilename ) { + cout << "in file " << yyfilename << " "; + } + cout << "at line " << yylineno << " reading token \"" << *(yylval.tok.str) << "\"" << endl; +} + +// Local Variables: // +// fill-column: 110 // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // + Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision 56c393547addff0a409b2886d25499bdf0079ca7) +++ src/Parser/parser.yy (revision 56c393547addff0a409b2886d25499bdf0079ca7) @@ -0,0 +1,2735 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// cfa.y -- +// +// Author : Peter A. Buhr +// Created On : Sat Sep 1 20:22:55 2001 +// Last Modified By : Peter A. Buhr +// Last Modified On : Sun May 31 18:50:30 2015 +// Update Count : 1016 +// + +// This grammar is based on the ANSI99/11 C grammar, specifically parts of EXPRESSION and STATEMENTS, and on +// the C grammar by James A. Roskind, specifically parts of DECLARATIONS and EXTERNAL DEFINITIONS. While +// parts have been copied, important changes have been made in all sections; these changes are sufficient to +// constitute a new grammar. In particular, this grammar attempts to be more syntactically precise, i.e., it +// parses less incorrect language syntax that must be subsequently rejected by semantic checks. Nevertheless, +// there are still several semantic checks required and many are noted in the grammar. Finally, the grammar is +// extended with GCC and CFA language extensions. + +// Acknowledgments to Richard Bilson, Glen Ditchfield, and Rodolfo Gabriel Esteves who all helped when I got +// stuck with the grammar. + +// The root language for this grammar is ANSI99/11 C. All of ANSI99/11 is parsed, except for: +// +// 1. designation with '=' (use ':' instead) +// +// Most of the syntactic extensions from ANSI90 to ANSI11 C are marked with the comment "C99/C11". This +// grammar also has two levels of extensions. The first extensions cover most of the GCC C extensions, except for: +// +// 1. nested functions +// 2. generalized lvalues +// 3. designation with and without '=' (use ':' instead) +// 4. attributes not allowed in parenthesis of declarator +// +// All of the syntactic extensions for GCC C are marked with the comment "GCC". The second extensions are for +// Cforall (CFA), which fixes several of C's outstanding problems and extends C with many modern language +// concepts. All of the syntactic extensions for CFA C are marked with the comment "CFA". As noted above, +// there is one unreconcileable parsing problem between C99 and CFA with respect to designators; this is +// discussed in detail before the "designation" grammar rule. + +%{ +#define YYDEBUG_LEXER_TEXT (yylval) // lexer loads this up each time +#define YYDEBUG 1 // get the pretty debugging code to compile + +#undef __GNUC_MINOR__ + +#include +#include +#include "TypedefTable.h" +#include "lex.h" +#include "ParseNode.h" +#include "LinkageSpec.h" + +DeclarationNode *theTree = 0; // the resulting parse tree +LinkageSpec::Type linkage = LinkageSpec::Cforall; +std::stack< LinkageSpec::Type > linkageStack; +TypedefTable typedefTable; +%} + +//************************* TERMINAL TOKENS ******************************** + +// keywords +%token TYPEDEF +%token AUTO EXTERN REGISTER STATIC +%token INLINE // C99 +%token FORTRAN // C99, extension ISO/IEC 9899:1999 Section J.5.9(1) +%token CONST VOLATILE +%token RESTRICT // C99 +%token FORALL LVALUE // CFA +%token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED +%token BOOL COMPLEX IMAGINARY // C99 +%token TYPEOF LABEL // GCC +%token ENUM STRUCT UNION +%token TYPE FTYPE DTYPE CONTEXT // CFA +%token SIZEOF +%token ATTRIBUTE EXTENSION // GCC +%token IF ELSE SWITCH CASE DEFAULT DO WHILE FOR BREAK CONTINUE GOTO RETURN +%token CHOOSE FALLTHRU TRY CATCH FINALLY THROW // CFA +%token ASM // C99, extension ISO/IEC 9899:1999 Section J.5.10(1) +%token ALIGNAS ALIGNOF ATOMIC GENERIC NORETURN STATICASSERT THREADLOCAL // C11 + +// names and constants: lexer differentiates between identifier and typedef names +%token IDENTIFIER QUOTED_IDENTIFIER TYPEDEFname TYPEGENname +%token ATTR_IDENTIFIER ATTR_TYPEDEFname ATTR_TYPEGENname +%token INTEGERconstant FLOATINGconstant CHARACTERconstant STRINGliteral +%token ZERO ONE // CFA + +// multi-character operators +%token ARROW // -> +%token ICR DECR // ++ -- +%token LS RS // << >> +%token LE GE EQ NE // <= >= == != +%token ANDAND OROR // && || +%token ELLIPSIS // ... + +%token MULTassign DIVassign MODassign // *= /= %=/ +%token PLUSassign MINUSassign // += -= +%token LSassign RSassign // <<= >>= +%token ANDassign ERassign ORassign // &= ^= |= + +// Types declaration +%union +{ + Token tok; + ParseNode *pn; + ExpressionNode *en; + DeclarationNode *decl; + DeclarationNode::TyCon aggKey; + DeclarationNode::TypeClass tclass; + StatementNode *sn; + ConstantNode *constant; + InitializerNode *in; +} + +%type zero_one identifier no_attr_identifier no_01_identifier +%type identifier_or_typedef_name no_attr_identifier_or_typedef_name no_01_identifier_or_typedef_name +%type string_literal_list + +// expressions +%type constant +%type tuple tuple_expression_list +%type unary_operator assignment_operator +%type primary_expression postfix_expression unary_expression +%type cast_expression multiplicative_expression additive_expression shift_expression +%type relational_expression equality_expression AND_expression exclusive_OR_expression +%type inclusive_OR_expression logical_AND_expression logical_OR_expression conditional_expression +%type constant_expression assignment_expression assignment_expression_opt +%type comma_expression comma_expression_opt +%type argument_expression_list argument_expression for_control_expression assignment_opt +%type subrange + +// statements +%type labeled_statement compound_statement expression_statement selection_statement +%type iteration_statement jump_statement exception_statement asm_statement +%type fall_through_opt fall_through +%type statement statement_list +%type block_item_list block_item +%type case_clause +%type case_value case_value_list +%type case_label case_label_list +%type switch_clause_list_opt switch_clause_list choose_clause_list_opt choose_clause_list +%type handler_list handler_clause finally_clause + +// declarations +%type abstract_array abstract_declarator abstract_function abstract_parameter_array +%type abstract_parameter_declaration abstract_parameter_declarator abstract_parameter_function +%type abstract_parameter_ptr abstract_ptr + +%type aggregate_key +%type aggregate_name + +%type array_dimension array_parameter_1st_dimension array_parameter_dimension multi_array_dimension + +%type assertion assertion_list_opt + +%type bit_subrange_size_opt bit_subrange_size + +%type basic_declaration_specifier basic_type_name basic_type_specifier direct_type_name indirect_type_name + +%type context_declaration context_declaration_list context_declaring_list context_specifier + +%type declaration declaration_list declaration_list_opt declaration_qualifier_list +%type declaration_specifier declarator declaring_list + +%type elaborated_type_name + +%type enumerator_list enum_name +%type enumerator_value_opt + +%type exception_declaration external_definition external_definition_list external_definition_list_opt + +%type field_declaration field_declaration_list field_declarator field_declaring_list +%type field field_list + +%type external_function_definition function_definition function_array function_declarator function_no_ptr function_ptr + +%type identifier_parameter_array identifier_parameter_declarator identifier_parameter_function +%type identifier_parameter_ptr identifier_list + +%type new_abstract_array new_abstract_declarator_no_tuple new_abstract_declarator_tuple +%type new_abstract_function new_abstract_parameter_declaration new_abstract_parameter_list +%type new_abstract_ptr new_abstract_tuple + +%type new_array_parameter_1st_dimension + +%type new_context_declaring_list new_declaration new_field_declaring_list +%type new_function_declaration new_function_return new_function_specifier + +%type new_identifier_parameter_array new_identifier_parameter_declarator_no_tuple +%type new_identifier_parameter_declarator_tuple new_identifier_parameter_ptr + +%type new_parameter_declaration new_parameter_list new_parameter_type_list new_parameter_type_list_opt + +%type new_typedef_declaration new_variable_declaration new_variable_specifier + +%type old_declaration old_declaration_list old_declaration_list_opt old_function_array +%type old_function_declarator old_function_no_ptr old_function_ptr + +%type parameter_declaration parameter_list parameter_type_list +%type parameter_type_list_opt + +%type paren_identifier paren_typedef + +%type storage_class storage_class_name storage_class_list + +%type sue_declaration_specifier sue_type_specifier + +%type type_class +%type type_declarator type_declarator_name type_declaring_list + +%type typedef typedef_array typedef_declaration typedef_declaration_specifier typedef_expression +%type typedef_function typedef_parameter_array typedef_parameter_function typedef_parameter_ptr +%type typedef_parameter_redeclarator typedef_ptr typedef_redeclarator typedef_type_specifier +%type typegen_declaration_specifier typegen_type_specifier + +%type type_name type_name_no_function +%type type_parameter type_parameter_list + +%type type_name_list + +%type type_qualifier type_qualifier_name type_qualifier_list type_qualifier_list_opt type_specifier + +%type variable_abstract_array variable_abstract_declarator variable_abstract_function +%type variable_abstract_ptr variable_array variable_declarator variable_function variable_ptr + +// initializers +%type initializer initializer_list initializer_opt + +// designators +%type designator designator_list designation + + +// Handle single shift/reduce conflict for dangling else by shifting the ELSE token. For example, this string +// is ambiguous: +// .---------. matches IF '(' comma_expression ')' statement +// if ( C ) S1 else S2 +// `-----------------' matches IF '(' comma_expression ')' statement ELSE statement */ + +%nonassoc THEN // rule precedence for IF '(' comma_expression ')' statement +%nonassoc ELSE // token precedence for start of else clause in IF statement + +%start translation_unit // parse-tree root + +%% +//************************* Namespace Management ******************************** + +// The grammar in the ANSI C standard is not strictly context-free, since it relies upon the distinct terminal +// symbols "identifier" and "TYPEDEFname" that are lexically identical. While it is possible to write a +// purely context-free grammar, such a grammar would obscure the relationship between syntactic and semantic +// constructs. Hence, this grammar uses the ANSI style. +// +// Cforall compounds this problem by introducing type names local to the scope of a declaration (for instance, +// those introduced through "forall" qualifiers), and by introducing "type generators" -- parametrized types. +// This latter type name creates a third class of identifiers that must be distinguished by the scanner. +// +// Since the scanner cannot distinguish among the different classes of identifiers without some context +// information, it accesses a data structure (the TypedefTable) to allow classification of an identifier that +// it has just read. Semantic actions during the parser update this data structure when the class of +// identifiers change. +// +// Because the Cforall language is block-scoped, there is the possibility that an identifier can change its +// class in a local scope; it must revert to its original class at the end of the block. Since type names can +// be local to a particular declaration, each declaration is itself a scope. This requires distinguishing +// between type names that are local to the current declaration scope and those that persist past the end of +// the declaration (i.e., names defined in "typedef" or "type" declarations). +// +// The non-terminals "push" and "pop" derive the empty string; their only use is to denote the opening and +// closing of scopes. Every push must have a matching pop, although it is regrettable the matching pairs do +// not always occur within the same rule. These non-terminals may appear in more contexts than strictly +// necessary from a semantic point of view. Unfortunately, these extra rules are necessary to prevent parsing +// conflicts -- the parser may not have enough context and look-ahead information to decide whether a new +// scope is necessary, so the effect of these extra rules is to open a new scope unconditionally. As the +// grammar evolves, it may be neccesary to add or move around "push" and "pop" nonterminals to resolve +// conflicts of this sort. + +push: + { + typedefTable.enterScope(); + } + ; + +pop: + { + typedefTable.leaveScope(); + } + ; + +//************************* CONSTANTS ******************************** + +constant: + // ENUMERATIONconstant is not included here; it is treated as a variable with type + // "enumeration constant". + INTEGERconstant { $$ = new ConstantNode(ConstantNode::Integer, $1); } + | FLOATINGconstant { $$ = new ConstantNode(ConstantNode::Float, $1); } + | CHARACTERconstant { $$ = new ConstantNode(ConstantNode::Character, $1); } + ; + +identifier: + IDENTIFIER + | ATTR_IDENTIFIER // CFA + | zero_one // CFA + ; + +no_01_identifier: + IDENTIFIER + | ATTR_IDENTIFIER // CFA + ; + +no_attr_identifier: + IDENTIFIER + ; + +zero_one: // CFA + ZERO + | ONE + ; + +string_literal_list: // juxtaposed strings are concatenated + STRINGliteral { $$ = new ConstantNode(ConstantNode::String, $1); } + | string_literal_list STRINGliteral { $$ = $1->append( $2 ); } + ; + +//************************* EXPRESSIONS ******************************** + +primary_expression: + IDENTIFIER // typedef name cannot be used as a variable name + { $$ = new VarRefNode($1); } + | zero_one + { $$ = new VarRefNode($1); } + | constant + { $$ = $1; } + | string_literal_list + { $$ = $1; } + | '(' comma_expression ')' + { $$ = $2; } + | '(' compound_statement ')' // GCC, lambda expression + { $$ = new ValofExprNode($2); } + ; + +postfix_expression: + primary_expression + | postfix_expression '[' push assignment_expression pop ']' + // CFA, comma_expression disallowed in the context because it results in a commom user error: + // subscripting a matrix with x[i,j] instead of x[i][j]. While this change is not backwards + // compatible, there seems to be little advantage to this feature and many disadvantages. It is + // possible to write x[(i,j)] in CFA, which is equivalent to the old x[i,j]. + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Index), $1, $4); } + | postfix_expression '(' argument_expression_list ')' + { $$ = new CompositeExprNode($1, $3); } + | postfix_expression '.' no_attr_identifier + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::FieldSel), $1, new VarRefNode($3)); } + | postfix_expression '.' '[' push field_list pop ']' // CFA, tuple field selector + | postfix_expression ARROW no_attr_identifier + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::PFieldSel), $1, new VarRefNode($3)); } + | postfix_expression ARROW '[' push field_list pop ']' // CFA, tuple field selector + | postfix_expression ICR + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::IncrPost), $1); } + | postfix_expression DECR + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::DecrPost), $1); } + // GCC has priority: cast_expression + | '(' type_name_no_function ')' '{' initializer_list comma_opt '}' // C99 + { $$ = 0; } + ; + +argument_expression_list: + argument_expression + | argument_expression_list ',' argument_expression + { $$ = (ExpressionNode *)($1->set_link($3)); } + ; + +argument_expression: + // empty + { $$ = 0; } // use default argument + | assignment_expression + | no_attr_identifier ':' assignment_expression + { $$ = $3->set_asArgName($1); } + // Only a list of no_attr_identifier_or_typedef_name is allowed in this context. However, there is + // insufficient look ahead to distinguish between this list of parameter names and a tuple, so the + // tuple form must be used with an appropriate semantic check. + | '[' push assignment_expression pop ']' ':' assignment_expression + { $$ = $7->set_asArgName($3); } + | '[' push assignment_expression ',' tuple_expression_list pop ']' ':' assignment_expression + { $$ = $9->set_asArgName( new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)$3->set_link( flattenCommas( $5 )))); } + ; + +field_list: // CFA, tuple field selector + field + | field_list ',' field { $$ = (ExpressionNode *)$1->set_link( $3 ); } + ; + +field: // CFA, tuple field selector + no_attr_identifier + { $$ = new VarRefNode( $1 ); } + | no_attr_identifier '.' field + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::FieldSel), new VarRefNode( $1 ), $3); } + | no_attr_identifier '.' '[' push field_list pop ']' + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::FieldSel), new VarRefNode( $1 ), $5); } + | no_attr_identifier ARROW field + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::PFieldSel), new VarRefNode( $1 ), $3); } + | no_attr_identifier ARROW '[' push field_list pop ']' + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::PFieldSel), new VarRefNode( $1 ), $5); } + ; + +unary_expression: + postfix_expression + | ICR unary_expression + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Incr), $2); } + | DECR unary_expression + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Decr), $2); } + | EXTENSION cast_expression // GCC + { $$ = $2; } + | unary_operator cast_expression + { $$ = new CompositeExprNode($1, $2); } + | '!' cast_expression + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Neg), $2); } + | '*' cast_expression // CFA + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::PointTo), $2); } + // '*' is is separated from unary_operator because of shift/reduce conflict in: + // { * X; } // dereference X + // { * int X; } // CFA declaration of pointer to int + // '&' must be moved here if C++ reference variables are supported. + | SIZEOF unary_expression + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::SizeOf), $2); } + | SIZEOF '(' type_name_no_function ')' + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::SizeOf), new TypeValueNode($3)); } + | ATTR_IDENTIFIER + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Attr), new VarRefNode($1)); } + | ATTR_IDENTIFIER '(' type_name ')' + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Attr), new VarRefNode($1), new TypeValueNode($3)); } + | ATTR_IDENTIFIER '(' argument_expression ')' + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Attr), new VarRefNode($1), $3); } + | ALIGNOF unary_expression // GCC, variable alignment + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::AlignOf), $2); } + | ALIGNOF '(' type_name_no_function ')' // GCC, type alignment + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::AlignOf), new TypeValueNode($3)); } + | ANDAND no_attr_identifier // GCC, address of label + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::LabelAddress), new VarRefNode($2, true)); } + ; + +unary_operator: + '&' { $$ = new OperatorNode(OperatorNode::AddressOf); } + | '+' { $$ = new OperatorNode(OperatorNode::UnPlus); } + | '-' { $$ = new OperatorNode(OperatorNode::UnMinus); } + | '~' { $$ = new OperatorNode(OperatorNode::BitNeg); } + ; + +cast_expression: + unary_expression + | '(' type_name_no_function ')' cast_expression + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Cast), new TypeValueNode($2), $4); } + | '(' type_name_no_function ')' tuple + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Cast), new TypeValueNode($2), $4); } + ; + +multiplicative_expression: + cast_expression + | multiplicative_expression '*' cast_expression + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Mul),$1,$3); } + | multiplicative_expression '/' cast_expression + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Div),$1,$3); } + | multiplicative_expression '%' cast_expression + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Mod),$1,$3); } + ; + +additive_expression: + multiplicative_expression + | additive_expression '+' multiplicative_expression + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Plus),$1,$3); } + | additive_expression '-' multiplicative_expression + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Minus),$1,$3); } + ; + +shift_expression: + additive_expression + | shift_expression LS additive_expression + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::LShift),$1,$3); } + | shift_expression RS additive_expression + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::RShift),$1,$3); } + ; + +relational_expression: + shift_expression + | relational_expression '<' shift_expression + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::LThan),$1,$3); } + | relational_expression '>' shift_expression + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::GThan),$1,$3); } + | relational_expression LE shift_expression + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::LEThan),$1,$3); } + | relational_expression GE shift_expression + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::GEThan),$1,$3); } + ; + +equality_expression: + relational_expression + | equality_expression EQ relational_expression + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Eq), $1, $3); } + | equality_expression NE relational_expression + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Neq), $1, $3); } + ; + +AND_expression: + equality_expression + | AND_expression '&' equality_expression + { $$ =new CompositeExprNode(new OperatorNode(OperatorNode::BitAnd), $1, $3); } + ; + +exclusive_OR_expression: + AND_expression + | exclusive_OR_expression '^' AND_expression + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Xor), $1, $3); } + ; + +inclusive_OR_expression: + exclusive_OR_expression + | inclusive_OR_expression '|' exclusive_OR_expression + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::BitOr), $1, $3); } + ; + +logical_AND_expression: + inclusive_OR_expression + | logical_AND_expression ANDAND inclusive_OR_expression + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::And), $1, $3); } + ; + +logical_OR_expression: + logical_AND_expression + | logical_OR_expression OROR logical_AND_expression + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Or), $1, $3); } + ; + +conditional_expression: + logical_OR_expression + | logical_OR_expression '?' comma_expression ':' conditional_expression + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Cond), (ExpressionNode *)mkList((*$1,*$3,*$5))); } + | logical_OR_expression '?' /* empty */ ':' conditional_expression // GCC, omitted first operand + { $$=new CompositeExprNode(new OperatorNode(OperatorNode::NCond),$1,$4); } + | logical_OR_expression '?' comma_expression ':' tuple // CFA, tuple expression + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Cond), (ExpressionNode *)mkList(( *$1, *$3, *$5 ))); } + ; + +constant_expression: + conditional_expression + ; + +assignment_expression: + // CFA, assignment is separated from assignment_operator to ensure no assignment operations for tuples + conditional_expression + | unary_expression '=' assignment_expression + { $$ =new CompositeExprNode(new OperatorNode(OperatorNode::Assign), $1, $3); } + | unary_expression assignment_operator assignment_expression + { $$ =new CompositeExprNode($2, $1, $3); } + | tuple assignment_opt // CFA, tuple expression + { $$ = ($2 == 0) ? $1 : new CompositeExprNode( new OperatorNode( OperatorNode::Assign ), $1, $2 ); } + ; + +assignment_expression_opt: + // empty + { $$ = new NullExprNode; } + | assignment_expression + ; + +tuple: // CFA, tuple + // CFA, one assignment_expression is factored out of comma_expression to eliminate a shift/reduce + // conflict with comma_expression in new_identifier_parameter_array and new_abstract_array + '[' push pop ']' + { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ) ); } + | '[' push assignment_expression pop ']' + { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), $3 ); } + | '[' push ',' tuple_expression_list pop ']' + { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(new NullExprNode)->set_link( $4 ) ); } + | '[' push assignment_expression ',' tuple_expression_list pop ']' + { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)$3->set_link( flattenCommas( $5 ) ) ); } + ; + +tuple_expression_list: + assignment_expression_opt + | tuple_expression_list ',' assignment_expression_opt + { $$ = (ExpressionNode *)$1->set_link( $3 ); } + ; + +assignment_operator: + MULTassign { $$ = new OperatorNode(OperatorNode::MulAssn); } + | DIVassign { $$ = new OperatorNode(OperatorNode::DivAssn); } + | MODassign { $$ = new OperatorNode(OperatorNode::ModAssn); } + | PLUSassign { $$ = new OperatorNode(OperatorNode::PlusAssn); } + | MINUSassign { $$ = new OperatorNode(OperatorNode::MinusAssn); } + | LSassign { $$ = new OperatorNode(OperatorNode::LSAssn); } + | RSassign { $$ = new OperatorNode(OperatorNode::RSAssn); } + | ANDassign { $$ = new OperatorNode(OperatorNode::AndAssn); } + | ERassign { $$ = new OperatorNode(OperatorNode::ERAssn); } + | ORassign { $$ = new OperatorNode(OperatorNode::OrAssn); } + ; + +comma_expression: + assignment_expression + | comma_expression ',' assignment_expression // { $$ = (ExpressionNode *)$1->add_to_list($3); } + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Comma),$1,$3); } + ; + +comma_expression_opt: + // empty + { $$ = 0; } + | comma_expression + ; + +//*************************** STATEMENTS ******************************* + +statement: + labeled_statement + | compound_statement + | expression_statement { $$ = $1; } + | selection_statement + | iteration_statement + | jump_statement + | exception_statement + | asm_statement + ; + +labeled_statement: + no_attr_identifier ':' attribute_list_opt statement + { $$ = $4->add_label($1);} + ; + +compound_statement: + '{' '}' + { $$ = new CompoundStmtNode( (StatementNode *)0 ); } + | '{' + // Two scopes are necessary because the block itself has a scope, but every declaration within the + // block also requires its own scope + push push + label_declaration_opt // GCC, local labels + block_item_list pop '}' // C99, intermix declarations and statements + { $$ = new CompoundStmtNode( $5 ); } + ; + +block_item_list: // C99 + block_item + | block_item_list push block_item + { if ($1 != 0) { $1->set_link($3); $$ = $1; } } + ; + +block_item: + declaration // CFA, new & old style declarations + { $$ = new StatementNode( $1 ); } + | EXTENSION declaration // GCC + { $$ = new StatementNode( $2 ); } + | function_definition + { $$ = new StatementNode( $1 ); } + | statement pop + ; + +statement_list: + statement + | statement_list statement + { if ($1 != 0) { $1->set_link($2); $$ = $1; } } + ; + +expression_statement: + comma_expression_opt ';' + { $$ = new StatementNode(StatementNode::Exp, $1, 0); } + ; + +selection_statement: + IF '(' comma_expression ')' statement %prec THEN + // explicitly deal with the shift/reduce conflict on if/else + { $$ = new StatementNode(StatementNode::If, $3, $5); } + | IF '(' comma_expression ')' statement ELSE statement + { $$ = new StatementNode(StatementNode::If, $3, (StatementNode *)mkList((*$5, *$7)) ); } + | SWITCH '(' comma_expression ')' case_clause // CFA + { $$ = new StatementNode(StatementNode::Switch, $3, $5); } + | SWITCH '(' comma_expression ')' '{' push declaration_list_opt switch_clause_list_opt '}' // CFA + { $$ = new StatementNode(StatementNode::Switch, $3, $8); /* xxx */ } + // The semantics of the declaration list is changed to include any associated initialization, which is + // performed *before* the transfer to the appropriate case clause. Statements after the initial + // declaration list can never be executed, and therefore, are removed from the grammar even though C + // allows it. + | CHOOSE '(' comma_expression ')' case_clause // CFA + { $$ = new StatementNode(StatementNode::Choose, $3, $5); } + | CHOOSE '(' comma_expression ')' '{' push declaration_list_opt choose_clause_list_opt '}' // CFA + { $$ = new StatementNode(StatementNode::Choose, $3, $8); } + ; + +// CASE and DEFAULT clauses are only allowed in the SWITCH statement, precluding Duff's device. In addition, a +// case clause allows a list of values and subranges. + +case_value: // CFA + constant_expression { $$ = $1; } + | constant_expression ELLIPSIS constant_expression // GCC, subrange + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Range),$1,$3); } + | subrange // CFA, subrange + ; + +case_value_list: // CFA + case_value + | case_value_list ',' case_value + { $$ = new CompositeExprNode(new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(tupleContents($1))->set_link($3) ); } + ; + +case_label: // CFA + CASE case_value_list ':' { $$ = new StatementNode(StatementNode::Case, $2, 0); } + | DEFAULT ':' { $$ = new StatementNode(StatementNode::Default); } + // A semantic check is required to ensure only one default clause per switch/choose statement. + ; + +case_label_list: // CFA + case_label + | case_label_list case_label { $$ = (StatementNode *)($1->set_link($2)); } + ; + +case_clause: // CFA + case_label_list statement { $$ = $1->append_last_case($2); } + ; + +switch_clause_list_opt: // CFA + // empty + { $$ = 0; } + | switch_clause_list + ; + +switch_clause_list: // CFA + case_label_list statement_list + { $$ = $1->append_last_case($2); } + | switch_clause_list case_label_list statement_list + { $$ = (StatementNode *)($1->set_link($2->append_last_case($3))); } + ; + +choose_clause_list_opt: // CFA + // empty + { $$ = 0; } + | choose_clause_list + ; + +choose_clause_list: // CFA + case_label_list fall_through + { $$ = $1->append_last_case($2); } + | case_label_list statement_list fall_through_opt + { $$ = $1->append_last_case((StatementNode *)mkList((*$2,*$3))); } + | choose_clause_list case_label_list fall_through + { $$ = (StatementNode *)($1->set_link($2->append_last_case($3))); } + | choose_clause_list case_label_list statement_list fall_through_opt + { $$ = (StatementNode *)($1->set_link($2->append_last_case((StatementNode *)mkList((*$3,*$4))))); } + ; + +fall_through_opt: // CFA + // empty + { $$ = 0; } + | fall_through + ; + +fall_through: // CFA + FALLTHRU { $$ = new StatementNode(StatementNode::Fallthru, 0, 0); } + | FALLTHRU ';' { $$ = new StatementNode(StatementNode::Fallthru, 0, 0); } + ; + +iteration_statement: + WHILE '(' comma_expression ')' statement + { $$ = new StatementNode(StatementNode::While, $3, $5); } + | DO statement WHILE '(' comma_expression ')' ';' + { $$ = new StatementNode(StatementNode::Do, $5, $2); } + | FOR '(' push for_control_expression ')' statement + { $$ = new StatementNode(StatementNode::For, $4, $6); } + ; + +for_control_expression: + comma_expression_opt pop ';' comma_expression_opt ';' comma_expression_opt + { $$ = new ForCtlExprNode($1, $4, $6); } + | declaration comma_expression_opt ';' comma_expression_opt // C99 + // Like C++, the loop index can be declared local to the loop. + { $$ = new ForCtlExprNode($1, $2, $4); } + ; + +jump_statement: + GOTO no_attr_identifier ';' + { $$ = new StatementNode(StatementNode::Goto, $2); } + | GOTO '*' comma_expression ';' // GCC, computed goto + // The syntax for the GCC computed goto violates normal expression precedence, e.g., goto *i+3; => + // goto *(i+3); whereas normal operator precedence yields goto (*i)+3; + { $$ = new StatementNode(StatementNode::Goto, $3); } + | CONTINUE ';' + // A semantic check is required to ensure this statement appears only in the body of an iteration + // statement. + { $$ = new StatementNode(StatementNode::Continue, 0, 0); } + | CONTINUE no_attr_identifier ';' // CFA, multi-level continue + // A semantic check is required to ensure this statement appears only in the body of an iteration + // statement, and the target of the transfer appears only at the start of an iteration statement. + { $$ = new StatementNode(StatementNode::Continue, $2); } + | BREAK ';' + // A semantic check is required to ensure this statement appears only in the body of an iteration + // statement. + { $$ = new StatementNode(StatementNode::Break, 0, 0); } + | BREAK no_attr_identifier ';' // CFA, multi-level exit + // A semantic check is required to ensure this statement appears only in the body of an iteration + // statement, and the target of the transfer appears only at the start of an iteration statement. + { $$ = new StatementNode(StatementNode::Break, $2 ); } + | RETURN comma_expression_opt ';' + { $$ = new StatementNode(StatementNode::Return, $2, 0); } + | THROW assignment_expression ';' + { $$ = new StatementNode(StatementNode::Throw, $2, 0); } + | THROW ';' + { $$ = new StatementNode(StatementNode::Throw, 0, 0); } + ; + +exception_statement: + TRY compound_statement handler_list + { $$ = new StatementNode(StatementNode::Try, 0,(StatementNode *)(mkList((*$2,*$3)))); } + | TRY compound_statement finally_clause + { $$ = new StatementNode(StatementNode::Try, 0,(StatementNode *)(mkList((*$2,*$3)))); } + | TRY compound_statement handler_list finally_clause + { + $3->set_link($4); + $$ = new StatementNode(StatementNode::Try, 0,(StatementNode *)(mkList((*$2,*$3)))); + } + ; + +handler_list: + // There must be at least one catch clause + handler_clause + // ISO/IEC 9899:1999 Section 15.3(6) If present, a "..." handler shall be the last handler for its try + // block. + | CATCH '(' ELLIPSIS ')' compound_statement + { $$ = StatementNode::newCatchStmt( 0, $5, true ); } + | handler_clause CATCH '(' ELLIPSIS ')' compound_statement + { $$ = $1->set_link( StatementNode::newCatchStmt( 0, $6, true ) ); } + ; + +handler_clause: + CATCH '(' push push exception_declaration pop ')' compound_statement pop + { $$ = StatementNode::newCatchStmt($5, $8); } + | handler_clause CATCH '(' push push exception_declaration pop ')' compound_statement pop + { $$ = $1->set_link( StatementNode::newCatchStmt($6, $9) ); } + ; + +finally_clause: + FINALLY compound_statement + { + $$ = new StatementNode(StatementNode::Finally, 0, $2); + std::cout << "Just created a finally node" << std::endl; + } + ; + +exception_declaration: + // A semantic check is required to ensure type_specifier does not create a new type, e.g.: + // + // catch ( struct { int i; } x ) ... + // + // This new type cannot catch any thrown type because of name equivalence among types. + type_specifier + | type_specifier declarator + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + $$ = $2->addType( $1 ); + } + | type_specifier variable_abstract_declarator + { $$ = $2->addType( $1 ); } + | new_abstract_declarator_tuple no_attr_identifier // CFA + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + $$ = $1->addName( $2 ); + } + | new_abstract_declarator_tuple // CFA + ; + +asm_statement: + ASM type_qualifier_list_opt '(' constant_expression ')' ';' + { $$ = new StatementNode(StatementNode::Asm, 0, 0); } + | ASM type_qualifier_list_opt '(' constant_expression ':' asm_operands_opt ')' ';' // remaining GCC + { $$ = new StatementNode(StatementNode::Asm, 0, 0); } + | ASM type_qualifier_list_opt '(' constant_expression ':' asm_operands_opt ':' asm_operands_opt ')' ';' + { $$ = new StatementNode(StatementNode::Asm, 0, 0); } + | ASM type_qualifier_list_opt '(' constant_expression ':' asm_operands_opt ':' asm_operands_opt ':' asm_clobbers_list ')' ';' + { $$ = new StatementNode(StatementNode::Asm, 0, 0); } + ; + +asm_operands_opt: // GCC + // empty + | asm_operands_list + ; + +asm_operands_list: // GCC + asm_operand + | asm_operands_list ',' asm_operand + ; + +asm_operand: // GCC + STRINGliteral '(' constant_expression ')' {} + ; + +asm_clobbers_list: // GCC + STRINGliteral {} + | asm_clobbers_list ',' STRINGliteral + ; + +//******************************* DECLARATIONS ********************************* + +declaration_list_opt: // used at beginning of switch statement + pop + { $$ = 0; } + | declaration_list + ; + +declaration_list: + declaration + | declaration_list push declaration + { $$ = $1->appendList( $3 ); } + ; + +old_declaration_list_opt: // used to declare parameter types in K&R style functions + pop + { $$ = 0; } + | old_declaration_list + ; + +old_declaration_list: + old_declaration + | old_declaration_list push old_declaration + { $$ = $1->appendList( $3 ); } + ; + +label_declaration_opt: // GCC, local label + // empty + | label_declaration_list + ; + +label_declaration_list: // GCC, local label + LABEL label_list ';' + | label_declaration_list LABEL label_list ';' + ; + +label_list: // GCC, local label + no_attr_identifier_or_typedef_name {} + | label_list ',' no_attr_identifier_or_typedef_name {} + ; + +declaration: // CFA, new & old style declarations + new_declaration + | old_declaration + ; + +// C declaration syntax is notoriously confusing and error prone. Cforall provides its own type, variable and +// function declarations. CFA declarations use the same declaration tokens as in C; however, CFA places +// declaration modifiers to the left of the base type, while C declarations place modifiers to the right of +// the base type. CFA declaration modifiers are interpreted from left to right and the entire type +// specification is distributed across all variables in the declaration list (as in Pascal). ANSI C and the +// new CFA declarations may appear together in the same program block, but cannot be mixed within a specific +// declaration. +// +// CFA C +// [10] int x; int x[10]; // array of 10 integers +// [10] * char y; char *y[10]; // array of 10 pointers to char + +new_declaration: // CFA + new_variable_declaration pop ';' + | new_typedef_declaration pop ';' + | new_function_declaration pop ';' + | type_declaring_list pop ';' + | context_specifier pop ';' + ; + +new_variable_declaration: // CFA + new_variable_specifier initializer_opt + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + $$ = $1; + } + | declaration_qualifier_list new_variable_specifier initializer_opt + // declaration_qualifier_list also includes type_qualifier_list, so a semantic check is necessary to + // preclude them as a type_qualifier cannot appear in that context. + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + $$ = $2->addQualifiers( $1 ); + } + | new_variable_declaration pop ',' push identifier_or_typedef_name initializer_opt + { + typedefTable.addToEnclosingScope( *$5, TypedefTable::ID ); + $$ = $1->appendList( $1->cloneType( $5 ) ); + } + ; + +new_variable_specifier: // CFA + // A semantic check is required to ensure asm_name only appears on declarations with implicit or + // explicit static storage-class + new_abstract_declarator_no_tuple identifier_or_typedef_name asm_name_opt + { + typedefTable.setNextIdentifier( *$2 ); + $$ = $1->addName( $2 ); + } + | new_abstract_tuple identifier_or_typedef_name asm_name_opt + { + typedefTable.setNextIdentifier( *$2 ); + $$ = $1->addName( $2 ); + } + | type_qualifier_list new_abstract_tuple identifier_or_typedef_name asm_name_opt + { + typedefTable.setNextIdentifier( *$3 ); + $$ = $2->addQualifiers( $1 )->addName( $3 ); + } + ; + +new_function_declaration: // CFA + new_function_specifier + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + $$ = $1; + } + | type_qualifier_list new_function_specifier + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + $$ = $2->addQualifiers( $1 ); + } + | declaration_qualifier_list new_function_specifier + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + $$ = $2->addQualifiers( $1 ); + } + | declaration_qualifier_list type_qualifier_list new_function_specifier + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + $$ = $3->addQualifiers( $1 )->addQualifiers( $2 ); + } + | new_function_declaration pop ',' push identifier_or_typedef_name + { + typedefTable.addToEnclosingScope( *$5, TypedefTable::ID ); + $$ = $1->appendList( $1->cloneType( $5 ) ); + } + ; + +new_function_specifier: // CFA + '[' push pop ']' identifier '(' push new_parameter_type_list_opt pop ')' + { + typedefTable.setNextIdentifier( *($5) ); + $$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, 0, true ); + } + | '[' push pop ']' TYPEDEFname '(' push new_parameter_type_list_opt pop ')' + { + typedefTable.setNextIdentifier( *($5) ); + $$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, 0, true ); + } + // identifier_or_typedef_name must be broken apart because of the sequence: + // + // '[' ']' identifier_or_typedef_name '(' new_parameter_type_list_opt ')' + // '[' ']' type_specifier + // + // type_specifier can resolve to just TYPEDEFname (e.g. typedef int T; int f( T );). Therefore this + // must be flattened to allow lookahead to the '(' without having to reduce + // identifier_or_typedef_name. + | new_abstract_tuple identifier_or_typedef_name '(' push new_parameter_type_list_opt pop ')' + // To obtain LR(1), this rule must be factored out from function return type (see + // new_abstract_declarator). + { + $$ = DeclarationNode::newFunction( $2, $1, $5, 0, true ); + } + | new_function_return identifier_or_typedef_name '(' push new_parameter_type_list_opt pop ')' + { + $$ = DeclarationNode::newFunction( $2, $1, $5, 0, true ); + } + ; + +new_function_return: // CFA + '[' push new_parameter_list pop ']' + { $$ = DeclarationNode::newTuple( $3 ); } + | '[' push new_parameter_list pop ',' push new_abstract_parameter_list pop ']' + // To obtain LR(1), the last new_abstract_parameter_list is added into this flattened rule to + // lookahead to the ']'. + { $$ = DeclarationNode::newTuple( $3->appendList( $7 ) ); } + ; + +new_typedef_declaration: // CFA + TYPEDEF new_variable_specifier + { + typedefTable.addToEnclosingScope( TypedefTable::TD); + $$ = $2->addTypedef(); + } + | TYPEDEF new_function_specifier + { + typedefTable.addToEnclosingScope( TypedefTable::TD); + $$ = $2->addTypedef(); + } + | new_typedef_declaration pop ',' push no_attr_identifier + { + typedefTable.addToEnclosingScope( *$5, TypedefTable::TD); + $$ = $1->appendList( $1->cloneType( $5 ) ); + } + ; + +// Traditionally typedef is part of storage-class specifier for syntactic convenience only. Here, it is +// factored out as a separate form of declaration, which syntactically precludes storage-class specifiers and +// initialization. + +typedef_declaration: + TYPEDEF type_specifier declarator + { + typedefTable.addToEnclosingScope( TypedefTable::TD); + $$ = $3->addType( $2 )->addTypedef(); + } + | typedef_declaration pop ',' push declarator + { + typedefTable.addToEnclosingScope( TypedefTable::TD); + $$ = $1->appendList( $1->cloneBaseType( $5 )->addTypedef() ); + } + | type_qualifier_list TYPEDEF type_specifier declarator // remaining OBSOLESCENT (see 2) + { + typedefTable.addToEnclosingScope( TypedefTable::TD); + $$ = $4->addType( $3 )->addQualifiers( $1 )->addTypedef(); + } + | type_specifier TYPEDEF declarator + { + typedefTable.addToEnclosingScope( TypedefTable::TD); + $$ = $3->addType( $1 )->addTypedef(); + } + | type_specifier TYPEDEF type_qualifier_list declarator + { + typedefTable.addToEnclosingScope( TypedefTable::TD); + $$ = $4->addQualifiers($1)->addTypedef()->addType($1); + } + ; + +typedef_expression: // GCC, naming expression type + TYPEDEF no_attr_identifier '=' assignment_expression + { + typedefTable.addToEnclosingScope(*($2), TypedefTable::TD); + $$ = DeclarationNode::newName( 0 ); // XXX + } + | typedef_expression pop ',' push no_attr_identifier '=' assignment_expression + { + typedefTable.addToEnclosingScope(*($5), TypedefTable::TD); + $$ = DeclarationNode::newName( 0 ); // XXX + } + ; + +old_declaration: + declaring_list pop ';' + | typedef_declaration pop ';' + | typedef_expression pop ';' // GCC, naming expression type + | sue_declaration_specifier pop ';' + ; + +declaring_list: + // A semantic check is required to ensure asm_name only appears on declarations with implicit or + // explicit static storage-class + declaration_specifier declarator asm_name_opt initializer_opt + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + $$ = ($2->addType( $1 ))->addInitializer($4); + } + | declaring_list ',' attribute_list_opt declarator asm_name_opt initializer_opt + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + $$ = $1->appendList( $1->cloneBaseType( $4->addInitializer($6) ) ); + } + ; + +declaration_specifier: // type specifier + storage class + basic_declaration_specifier + | sue_declaration_specifier + | typedef_declaration_specifier + | typegen_declaration_specifier + ; + +type_specifier: // declaration specifier - storage class + basic_type_specifier + | sue_type_specifier + | typedef_type_specifier + | typegen_type_specifier + ; + +type_qualifier_list_opt: // GCC, used in asm_statement + // empty + { $$ = 0; } + | type_qualifier_list + ; + +type_qualifier_list: + // A semantic check is necessary to ensure a type qualifier is appropriate for the kind of + // declaration. + // + // ISO/IEC 9899:1999 Section 6.7.3(4) : If the same qualifier appears more than once in the same + // specifier-qualifier-list, either directly or via one or more typedefs, the behavior is the same as + // if it appeared only once. + type_qualifier + | type_qualifier_list type_qualifier + { $$ = $1->addQualifiers( $2 ); } + ; + +type_qualifier: + type_qualifier_name + | attribute + { $$ = DeclarationNode::newQualifier( DeclarationNode::Attribute ); } + ; + +type_qualifier_name: + CONST + { $$ = DeclarationNode::newQualifier( DeclarationNode::Const ); } + | RESTRICT + { $$ = DeclarationNode::newQualifier( DeclarationNode::Restrict ); } + | VOLATILE + { $$ = DeclarationNode::newQualifier( DeclarationNode::Volatile ); } + | LVALUE // CFA + { $$ = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); } + | ATOMIC + { $$ = DeclarationNode::newQualifier( DeclarationNode::Atomic ); } + | FORALL '(' + { + typedefTable.enterScope(); + } + type_parameter_list ')' // CFA + { + typedefTable.leaveScope(); + $$ = DeclarationNode::newForall( $4 ); + } + ; + +declaration_qualifier_list: + storage_class_list + | type_qualifier_list storage_class_list // remaining OBSOLESCENT (see 2) + { $$ = $1->addQualifiers( $2 ); } + | declaration_qualifier_list type_qualifier_list storage_class_list + { $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); } + ; + +storage_class_list: + // A semantic check is necessary to ensure a storage class is appropriate for the kind of declaration + // and that only one of each is specified, except for inline, which can appear with the others. + // + // ISO/IEC 9899:1999 Section 6.7.1(2) : At most, one storage-class specifier may be given in the + // declaration specifiers in a declaration. + storage_class + | storage_class_list storage_class + { $$ = $1->addQualifiers( $2 ); } + ; + +storage_class: + storage_class_name + ; + +storage_class_name: + EXTERN + { $$ = DeclarationNode::newStorageClass( DeclarationNode::Extern ); } + | STATIC + { $$ = DeclarationNode::newStorageClass( DeclarationNode::Static ); } + | AUTO + { $$ = DeclarationNode::newStorageClass( DeclarationNode::Auto ); } + | REGISTER + { $$ = DeclarationNode::newStorageClass( DeclarationNode::Register ); } + | INLINE // C99 + // INLINE is essentially a storage class specifier for functions, and hence, belongs here. + { $$ = DeclarationNode::newStorageClass( DeclarationNode::Inline ); } + | FORTRAN // C99 + { $$ = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); } + ; + +basic_type_name: + CHAR + { $$ = DeclarationNode::newBasicType( DeclarationNode::Char ); } + | DOUBLE + { $$ = DeclarationNode::newBasicType( DeclarationNode::Double ); } + | FLOAT + { $$ = DeclarationNode::newBasicType( DeclarationNode::Float ); } + | INT + { $$ = DeclarationNode::newBasicType( DeclarationNode::Int ); } + | LONG + { $$ = DeclarationNode::newModifier( DeclarationNode::Long ); } + | SHORT + { $$ = DeclarationNode::newModifier( DeclarationNode::Short ); } + | SIGNED + { $$ = DeclarationNode::newModifier( DeclarationNode::Signed ); } + | UNSIGNED + { $$ = DeclarationNode::newModifier( DeclarationNode::Unsigned ); } + | VOID + { $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); } + | BOOL // C99 + { $$ = DeclarationNode::newBasicType( DeclarationNode::Bool ); } + | COMPLEX // C99 + { $$ = DeclarationNode::newBasicType( DeclarationNode::Complex ); } + | IMAGINARY // C99 + { $$ = DeclarationNode::newBasicType( DeclarationNode::Imaginary ); } + ; + +basic_declaration_specifier: + // A semantic check is necessary for conflicting storage classes. + basic_type_specifier + | declaration_qualifier_list basic_type_specifier + { $$ = $2->addQualifiers( $1 ); } + | basic_declaration_specifier storage_class // remaining OBSOLESCENT (see 2) + { $$ = $1->addQualifiers( $2 ); } + | basic_declaration_specifier storage_class type_qualifier_list + { $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); } + | basic_declaration_specifier storage_class basic_type_specifier + { $$ = $3->addQualifiers( $2 )->addType( $1 ); } + ; + +basic_type_specifier: + direct_type_name + | type_qualifier_list_opt indirect_type_name type_qualifier_list_opt + { $$ = $2->addQualifiers( $1 )->addQualifiers( $3 ); } + ; + +direct_type_name: + // A semantic check is necessary for conflicting type qualifiers. + basic_type_name + | type_qualifier_list basic_type_name + { $$ = $2->addQualifiers( $1 ); } + | direct_type_name type_qualifier + { $$ = $1->addQualifiers( $2 ); } + | direct_type_name basic_type_name + { $$ = $1->addType( $2 ); } + ; + +indirect_type_name: + TYPEOF '(' type_name ')' // GCC: typeof(x) y; + { $$ = $3; } + | TYPEOF '(' comma_expression ')' // GCC: typeof(a+b) y; + { $$ = DeclarationNode::newTypeof( $3 ); } + | ATTR_TYPEGENname '(' type_name ')' // CFA: e.g., @type(x) y; + { $$ = DeclarationNode::newAttr( $1, $3 ); } + | ATTR_TYPEGENname '(' comma_expression ')' // CFA: e.g., @type(a+b) y; + { $$ = DeclarationNode::newAttr( $1, $3 ); } + ; + +sue_declaration_specifier: + sue_type_specifier + | declaration_qualifier_list sue_type_specifier + { $$ = $2->addQualifiers( $1 ); } + | sue_declaration_specifier storage_class // remaining OBSOLESCENT (see 2) + { $$ = $1->addQualifiers( $2 ); } + | sue_declaration_specifier storage_class type_qualifier_list + { $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); } + ; + +sue_type_specifier: + elaborated_type_name // struct, union, enum + | type_qualifier_list elaborated_type_name + { $$ = $2->addQualifiers( $1 ); } + | sue_type_specifier type_qualifier + { $$ = $1->addQualifiers( $2 ); } + ; + +typedef_declaration_specifier: + typedef_type_specifier + | declaration_qualifier_list typedef_type_specifier + { $$ = $2->addQualifiers( $1 ); } + | typedef_declaration_specifier storage_class // remaining OBSOLESCENT (see 2) + { $$ = $1->addQualifiers( $2 ); } + | typedef_declaration_specifier storage_class type_qualifier_list + { $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); } + ; + +typedef_type_specifier: // typedef types + TYPEDEFname + { $$ = DeclarationNode::newFromTypedef( $1 ); } + | type_qualifier_list TYPEDEFname + { $$ = DeclarationNode::newFromTypedef( $2 )->addQualifiers( $1 ); } + | typedef_type_specifier type_qualifier + { $$ = $1->addQualifiers( $2 ); } + ; + +elaborated_type_name: + aggregate_name + | enum_name + ; + +aggregate_name: + aggregate_key '{' field_declaration_list '}' + { $$ = DeclarationNode::newAggregate( $1, 0, 0, 0, $3 ); } + | aggregate_key no_attr_identifier_or_typedef_name + { $$ = DeclarationNode::newAggregate( $1, $2, 0, 0, 0 ); } + | aggregate_key no_attr_identifier_or_typedef_name '{' field_declaration_list '}' + { $$ = DeclarationNode::newAggregate( $1, $2, 0, 0, $4 ); } + | aggregate_key '(' push type_parameter_list pop ')' '{' field_declaration_list '}' // CFA + { $$ = DeclarationNode::newAggregate( $1, 0, $4, 0, $8 ); } + | aggregate_key '(' push type_parameter_list pop ')' no_attr_identifier_or_typedef_name // CFA + { $$ = DeclarationNode::newAggregate( $1, $7, $4, 0, 0 ); } + | aggregate_key '(' push type_parameter_list pop ')' no_attr_identifier_or_typedef_name '{' field_declaration_list '}' // CFA + { $$ = DeclarationNode::newAggregate( $1, $7, $4, 0, $9 ); } + | aggregate_key '(' push type_parameter_list pop ')' '(' type_name_list ')' '{' field_declaration_list '}' // CFA + { $$ = DeclarationNode::newAggregate( $1, 0, $4, $8, $11 ); } + | aggregate_key '(' push type_name_list pop ')' no_attr_identifier_or_typedef_name // CFA + // push and pop are only to prevent S/R conflicts + { $$ = DeclarationNode::newAggregate( $1, $7, 0, $4, 0 ); } + | aggregate_key '(' push type_parameter_list pop ')' '(' type_name_list ')' no_attr_identifier_or_typedef_name '{' field_declaration_list '}' // CFA + { $$ = DeclarationNode::newAggregate( $1, $10, $4, $8, $12 ); } + ; + +aggregate_key: + STRUCT attribute_list_opt + { $$ = DeclarationNode::Struct; } + | UNION attribute_list_opt + { $$ = DeclarationNode::Union; } + ; + +field_declaration_list: + field_declaration + { $$ = $1; } + | field_declaration_list field_declaration + { $$ = $1->appendList( $2 ); } + ; + +field_declaration: + new_field_declaring_list ';' // CFA, new style field declaration + | EXTENSION new_field_declaring_list ';' // GCC + { $$ = $2; } + | field_declaring_list ';' + | EXTENSION field_declaring_list ';' // GCC + { $$ = $2; } + ; + +new_field_declaring_list: // CFA, new style field declaration + new_abstract_declarator_tuple // CFA, no field name + | new_abstract_declarator_tuple no_attr_identifier_or_typedef_name + { $$ = $1->addName( $2 ); } + | new_field_declaring_list ',' no_attr_identifier_or_typedef_name + { $$ = $1->appendList( $1->cloneType( $3 ) ); } + | new_field_declaring_list ',' // CFA, no field name + { $$ = $1->appendList( $1->cloneType( 0 ) ); } + ; + +field_declaring_list: + type_specifier field_declarator + { $$ = $2->addType( $1 ); } + | field_declaring_list ',' attribute_list_opt field_declarator + { $$ = $1->appendList( $1->cloneBaseType( $4 ) ); } + ; + +field_declarator: + // empty + { $$ = DeclarationNode::newName( 0 ); /* XXX */ } // CFA, no field name + | bit_subrange_size // no field name + { $$ = DeclarationNode::newBitfield( $1 ); } + | variable_declarator bit_subrange_size_opt + // A semantic check is required to ensure bit_subrange only appears on base type int. + { $$ = $1->addBitfield( $2 ); } + | typedef_redeclarator bit_subrange_size_opt + // A semantic check is required to ensure bit_subrange only appears on base type int. + { $$ = $1->addBitfield( $2 ); } + | variable_abstract_declarator // CFA, no field name + ; + +bit_subrange_size_opt: + // empty + { $$ = 0; } + | bit_subrange_size + { $$ = $1; } + ; + +bit_subrange_size: + ':' constant_expression + { $$ = $2; } + ; + +enum_key: + ENUM attribute_list_opt + ; + +enum_name: + enum_key '{' enumerator_list comma_opt '}' + { $$ = DeclarationNode::newEnum( 0, $3 ); } + | enum_key no_attr_identifier_or_typedef_name '{' enumerator_list comma_opt '}' + { $$ = DeclarationNode::newEnum( $2, $4 ); } + | enum_key no_attr_identifier_or_typedef_name + { $$ = DeclarationNode::newEnum( $2, 0 ); } + ; + +enumerator_list: + no_attr_identifier_or_typedef_name enumerator_value_opt + { $$ = DeclarationNode::newEnumConstant( $1, $2 ); } + | enumerator_list ',' no_attr_identifier_or_typedef_name enumerator_value_opt + { $$ = $1->appendList( DeclarationNode::newEnumConstant( $3, $4 ) ); } + ; + +enumerator_value_opt: + // empty + { $$ = 0; } + | '=' constant_expression + { $$ = $2; } + ; + +// Minimum of one parameter after which ellipsis is allowed only at the end. + +new_parameter_type_list_opt: // CFA + // empty + { $$ = 0; } + | new_parameter_type_list + ; + +new_parameter_type_list: // CFA, abstract + real + new_abstract_parameter_list + | new_parameter_list + | new_parameter_list pop ',' push new_abstract_parameter_list + { $$ = $1->appendList( $5 ); } + | new_abstract_parameter_list pop ',' push ELLIPSIS + { $$ = $1->addVarArgs(); } + | new_parameter_list pop ',' push ELLIPSIS + { $$ = $1->addVarArgs(); } + ; + +new_parameter_list: // CFA + // To obtain LR(1) between new_parameter_list and new_abstract_tuple, the last + // new_abstract_parameter_list is factored out from new_parameter_list, flattening the rules to get + // lookahead to the ']'. + new_parameter_declaration + | new_abstract_parameter_list pop ',' push new_parameter_declaration + { $$ = $1->appendList( $5 ); } + | new_parameter_list pop ',' push new_parameter_declaration + { $$ = $1->appendList( $5 ); } + | new_parameter_list pop ',' push new_abstract_parameter_list pop ',' push new_parameter_declaration + { $$ = $1->appendList( $5 )->appendList( $9 ); } + ; + +new_abstract_parameter_list: // CFA, new & old style abstract + new_abstract_parameter_declaration + | new_abstract_parameter_list pop ',' push new_abstract_parameter_declaration + { $$ = $1->appendList( $5 ); } + ; + +parameter_type_list_opt: + // empty + { $$ = 0; } + | parameter_type_list + ; + +parameter_type_list: + parameter_list + | parameter_list pop ',' push ELLIPSIS + { $$ = $1->addVarArgs(); } + ; + +parameter_list: // abstract + real + abstract_parameter_declaration + | parameter_declaration + | parameter_list pop ',' push abstract_parameter_declaration + { $$ = $1->appendList( $5 ); } + | parameter_list pop ',' push parameter_declaration + { $$ = $1->appendList( $5 ); } + ; + +// Provides optional identifier names (abstract_declarator/variable_declarator), no initialization, different +// semantics for typedef name by using typedef_parameter_redeclarator instead of typedef_redeclarator, and +// function prototypes. + +new_parameter_declaration: // CFA, new & old style parameter declaration + parameter_declaration + | new_identifier_parameter_declarator_no_tuple identifier_or_typedef_name assignment_opt + { $$ = $1->addName( $2 ); } + | new_abstract_tuple identifier_or_typedef_name assignment_opt + // To obtain LR(1), these rules must be duplicated here (see new_abstract_declarator). + { $$ = $1->addName( $2 ); } + | type_qualifier_list new_abstract_tuple identifier_or_typedef_name assignment_opt + { $$ = $2->addName( $3 )->addQualifiers( $1 ); } + | new_function_specifier + ; + +new_abstract_parameter_declaration: // CFA, new & old style parameter declaration + abstract_parameter_declaration + | new_identifier_parameter_declarator_no_tuple + | new_abstract_tuple + // To obtain LR(1), these rules must be duplicated here (see new_abstract_declarator). + | type_qualifier_list new_abstract_tuple + { $$ = $2->addQualifiers( $1 ); } + | new_abstract_function + ; + +parameter_declaration: + declaration_specifier identifier_parameter_declarator assignment_opt + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + $$ = $2->addType( $1 )->addInitializer( new InitializerNode($3) ); + } + | declaration_specifier typedef_parameter_redeclarator assignment_opt + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + $$ = $2->addType( $1 )->addInitializer( new InitializerNode($3) ); + } + ; + +abstract_parameter_declaration: + declaration_specifier + | declaration_specifier abstract_parameter_declarator + { $$ = $2->addType( $1 ); } + ; + +// ISO/IEC 9899:1999 Section 6.9.1(6) : "An identifier declared as a typedef name shall not be redeclared as a +// parameter." Because the scope of the K&R-style parameter-list sees the typedef first, the following is +// based only on identifiers. The ANSI-style parameter-list can redefine a typedef name. + +identifier_list: // K&R-style parameter list => no types + no_attr_identifier + { $$ = DeclarationNode::newName( $1 ); } + | identifier_list ',' no_attr_identifier + { $$ = $1->appendList( DeclarationNode::newName( $3 ) ); } + ; + +identifier_or_typedef_name: + identifier + | TYPEDEFname + | TYPEGENname + ; + +no_01_identifier_or_typedef_name: + no_01_identifier + | TYPEDEFname + | TYPEGENname + ; + +no_attr_identifier_or_typedef_name: + no_attr_identifier + | TYPEDEFname + | TYPEGENname + ; + +type_name_no_function: // sizeof, alignof, cast (constructor) + new_abstract_declarator_tuple // CFA + | type_specifier + | type_specifier variable_abstract_declarator + { $$ = $2->addType( $1 ); } + ; + +type_name: // typeof, assertion + new_abstract_declarator_tuple // CFA + | new_abstract_function // CFA + | type_specifier + | type_specifier abstract_declarator + { $$ = $2->addType( $1 ); } + ; + +initializer_opt: + // empty + { $$ = 0; } + | '=' initializer { $$ = $2; } + ; + +initializer: + assignment_expression { $$ = new InitializerNode($1); } + | '{' initializer_list comma_opt '}' { $$ = new InitializerNode($2, true); } + ; + +initializer_list: + initializer + | designation initializer { $$ = $2->set_designators( $1 ); } + | initializer_list ',' initializer { $$ = (InitializerNode *)( $1->set_link($3) ); } + | initializer_list ',' designation initializer + { $$ = (InitializerNode *)( $1->set_link( $4->set_designators($3) ) ); } + ; + +// There is an unreconcileable parsing problem between C99 and CFA with respect to designators. The problem is +// use of '=' to separator the designator from the initializer value, as in: +// +// int x[10] = { [1] = 3 }; +// +// The string "[1] = 3" can be parsed as a designator assignment or a tuple assignment. To disambiguate this +// case, CFA changes the syntax from "=" to ":" as the separator between the designator and initializer. GCC +// does uses ":" for field selection. The optional use of the "=" in GCC, or in this case ":", cannot be +// supported either due to shift/reduce conflicts + +designation: + designator_list ':' // C99, CFA uses ":" instead of "=" + | no_attr_identifier_or_typedef_name ':' // GCC, field name + { $$ = new VarRefNode( $1 ); } + ; + +designator_list: // C99 + designator + | designator_list designator { $$ = (ExpressionNode *)($1->set_link( $2 )); } + ; + +designator: + '.' no_attr_identifier_or_typedef_name // C99, field name + { $$ = new VarRefNode( $2 ); } + | '[' push assignment_expression pop ']' // C99, single array element + // assignment_expression used instead of constant_expression because of shift/reduce conflicts with + // tuple. + { $$ = $3; } + | '[' push subrange pop ']' // CFA, multiple array elements + { $$ = $3; } + | '[' push constant_expression ELLIPSIS constant_expression pop ']' // GCC, multiple array elements + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Range), $3, $5); } + | '.' '[' push field_list pop ']' // CFA, tuple field selector + { $$ = $4; } + ; + +// The CFA type system is based on parametric polymorphism, the ability to declare functions with type +// parameters, rather than an object-oriented type system. This required four groups of extensions: +// +// Overloading: function, data, and operator identifiers may be overloaded. +// +// Type declarations: "type" is used to generate new types for declaring objects. Similarly, "dtype" is used +// for object and incomplete types, and "ftype" is used for function types. Type declarations with +// initializers provide definitions of new types. Type declarations with storage class "extern" provide +// opaque types. +// +// Polymorphic functions: A forall clause declares a type parameter. The corresponding argument is inferred at +// the call site. A polymorphic function is not a template; it is a function, with an address and a type. +// +// Specifications and Assertions: Specifications are collections of declarations parameterized by one or more +// types. They serve many of the purposes of abstract classes, and specification hierarchies resemble +// subclass hierarchies. Unlike classes, they can define relationships between types. Assertions declare +// that a type or types provide the operations declared by a specification. Assertions are normally used +// to declare requirements on type arguments of polymorphic functions. + +typegen_declaration_specifier: // CFA + typegen_type_specifier + | declaration_qualifier_list typegen_type_specifier + { $$ = $2->addQualifiers( $1 ); } + | typegen_declaration_specifier storage_class // remaining OBSOLESCENT (see 2) + { $$ = $1->addQualifiers( $2 ); } + | typegen_declaration_specifier storage_class type_qualifier_list + { $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); } + ; + +typegen_type_specifier: // CFA + TYPEGENname '(' type_name_list ')' + { $$ = DeclarationNode::newFromTypeGen( $1, $3 ); } + | type_qualifier_list TYPEGENname '(' type_name_list ')' + { $$ = DeclarationNode::newFromTypeGen( $2, $4 )->addQualifiers( $1 ); } + | typegen_type_specifier type_qualifier + { $$ = $1->addQualifiers( $2 ); } + ; + +type_parameter_list: // CFA + type_parameter assignment_opt + | type_parameter_list ',' type_parameter assignment_opt + { $$ = $1->appendList( $3 ); } + ; + +type_parameter: // CFA + type_class no_attr_identifier_or_typedef_name + { typedefTable.addToEnclosingScope(*($2), TypedefTable::TD); } + assertion_list_opt + { $$ = DeclarationNode::newTypeParam( $1, $2 )->addAssertions( $4 ); } + | type_specifier identifier_parameter_declarator + ; + +type_class: // CFA + TYPE + { $$ = DeclarationNode::Type; } + | DTYPE + { $$ = DeclarationNode::Ftype; } + | FTYPE + { $$ = DeclarationNode::Dtype; } + ; + +assertion_list_opt: // CFA + // empty + { $$ = 0; } + | assertion_list_opt assertion + { $$ = $1 == 0 ? $2 : $1->appendList( $2 ); } + ; + +assertion: // CFA + '|' no_attr_identifier_or_typedef_name '(' type_name_list ')' + { + typedefTable.openContext( *($2) ); + $$ = DeclarationNode::newContextUse( $2, $4 ); + } + | '|' '{' push context_declaration_list '}' + { $$ = $4; } + | '|' '(' push type_parameter_list pop ')' '{' push context_declaration_list '}' '(' type_name_list ')' + { $$ = 0; } + ; + +type_name_list: // CFA + type_name + { $$ = new TypeValueNode( $1 ); } + | assignment_expression + | type_name_list ',' type_name + { $$ = (ExpressionNode *)($1->set_link(new TypeValueNode( $3 ))); } + | type_name_list ',' assignment_expression + { $$ = (ExpressionNode *)($1->set_link($3)); } + ; + +type_declaring_list: // CFA + TYPE type_declarator + { $$ = $2; } + | storage_class_list TYPE type_declarator + { $$ = $3->addQualifiers( $1 ); } + | type_declaring_list ',' type_declarator + { $$ = $1->appendList( $3->copyStorageClasses( $1 ) ); } + ; + +type_declarator: // CFA + type_declarator_name assertion_list_opt + { $$ = $1->addAssertions( $2 ); } + | type_declarator_name assertion_list_opt '=' type_name + { $$ = $1->addAssertions( $2 )->addType( $4 ); } + ; + +type_declarator_name: // CFA + no_attr_identifier_or_typedef_name + { + typedefTable.addToEnclosingScope(*($1), TypedefTable::TD); + $$ = DeclarationNode::newTypeDecl( $1, 0 ); + } + | no_01_identifier_or_typedef_name '(' push type_parameter_list pop ')' + { + typedefTable.addToEnclosingScope(*($1), TypedefTable::TG); + $$ = DeclarationNode::newTypeDecl( $1, $4 ); + } + ; + +context_specifier: // CFA + CONTEXT no_attr_identifier_or_typedef_name '(' push type_parameter_list pop ')' '{' '}' + { + typedefTable.addToEnclosingScope(*($2), TypedefTable::ID ); + $$ = DeclarationNode::newContext( $2, $5, 0 ); + } + | CONTEXT no_attr_identifier_or_typedef_name '(' push type_parameter_list pop ')' '{' + { + typedefTable.enterContext( *($2) ); + typedefTable.enterScope(); + } + context_declaration_list '}' + { + typedefTable.leaveContext(); + typedefTable.addToEnclosingScope(*($2), TypedefTable::ID ); + $$ = DeclarationNode::newContext( $2, $5, $10 ); + } + ; + +context_declaration_list: // CFA + context_declaration + | context_declaration_list push context_declaration + { $$ = $1->appendList( $3 ); } + ; + +context_declaration: // CFA + new_context_declaring_list pop ';' + | context_declaring_list pop ';' + ; + +new_context_declaring_list: // CFA + new_variable_specifier + { + typedefTable.addToEnclosingScope2( TypedefTable::ID ); + $$ = $1; + } + | new_function_specifier + { + typedefTable.addToEnclosingScope2( TypedefTable::ID ); + $$ = $1; + } + | new_context_declaring_list pop ',' push identifier_or_typedef_name + { + typedefTable.addToEnclosingScope2( *($5), TypedefTable::ID ); + $$ = $1->appendList( $1->cloneType( $5 ) ); + } + ; + +context_declaring_list: // CFA + type_specifier declarator + { + typedefTable.addToEnclosingScope2( TypedefTable::ID ); + $$ = $2->addType( $1 ); + } + | context_declaring_list pop ',' push declarator + { + typedefTable.addToEnclosingScope2( TypedefTable::ID ); + $$ = $1->appendList( $1->cloneBaseType( $5 ) ); + } + ; + +//***************************** EXTERNAL DEFINITIONS ***************************** + +translation_unit: + // empty + {} // empty input file + | external_definition_list + { + if ( theTree ) { + theTree->appendList( $1 ); + } else { + theTree = $1; + } + } + ; + +external_definition_list: + external_definition + | external_definition_list push external_definition + { $$ = ($1 != NULL ) ? $1->appendList( $3 ) : $3; } + ; + +external_definition_list_opt: + // empty + { $$ = 0; } + | external_definition_list + ; + +external_definition: + declaration + | external_function_definition + | asm_statement // GCC, global assembler statement + {} + | EXTERN STRINGliteral + { + linkageStack.push( linkage ); + linkage = LinkageSpec::fromString( *$2 ); + } + '{' external_definition_list_opt '}' // C++-style linkage specifier + { + linkage = linkageStack.top(); + linkageStack.pop(); + $$ = $5; + } + | EXTENSION external_definition + { $$ = $2; } + ; + +external_function_definition: + function_definition + + // These rules are a concession to the "implicit int" type_specifier because there is a significant + // amount of code with functions missing a type-specifier on the return type. Parsing is possible + // because function_definition does not appear in the context of an expression (nested functions would + // preclude this concession). A function prototype declaration must still have a type_specifier. + // OBSOLESCENT (see 1) + | function_declarator compound_statement + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + typedefTable.leaveScope(); + $$ = $1->addFunctionBody( $2 ); + } + | old_function_declarator push old_declaration_list_opt compound_statement + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + typedefTable.leaveScope(); + $$ = $1->addOldDeclList( $3 )->addFunctionBody( $4 ); + } + ; + +function_definition: + new_function_declaration compound_statement // CFA + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + typedefTable.leaveScope(); + $$ = $1->addFunctionBody( $2 ); + } + | declaration_specifier function_declarator compound_statement + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + typedefTable.leaveScope(); + $$ = $2->addFunctionBody( $3 )->addType( $1 ); + } + | type_qualifier_list function_declarator compound_statement + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + typedefTable.leaveScope(); + $$ = $2->addFunctionBody( $3 )->addQualifiers( $1 ); + } + | declaration_qualifier_list function_declarator compound_statement + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + typedefTable.leaveScope(); + $$ = $2->addFunctionBody( $3 )->addQualifiers( $1 ); + } + | declaration_qualifier_list type_qualifier_list function_declarator compound_statement + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + typedefTable.leaveScope(); + $$ = $3->addFunctionBody( $4 )->addQualifiers( $2 )->addQualifiers( $1 ); + } + + // Old-style K&R function definition, OBSOLESCENT (see 4) + | declaration_specifier old_function_declarator push old_declaration_list_opt compound_statement + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + typedefTable.leaveScope(); + $$ = $2->addOldDeclList( $4 )->addFunctionBody( $5 )->addType( $1 ); + } + | type_qualifier_list old_function_declarator push old_declaration_list_opt compound_statement + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + typedefTable.leaveScope(); + $$ = $2->addOldDeclList( $4 )->addFunctionBody( $5 )->addQualifiers( $1 ); + } + + // Old-style K&R function definition with "implicit int" type_specifier, OBSOLESCENT (see 4) + | declaration_qualifier_list old_function_declarator push old_declaration_list_opt compound_statement + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + typedefTable.leaveScope(); + $$ = $2->addOldDeclList( $4 )->addFunctionBody( $5 )->addQualifiers( $1 ); + } + | declaration_qualifier_list type_qualifier_list old_function_declarator push old_declaration_list_opt compound_statement + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); + typedefTable.leaveScope(); + $$ = $3->addOldDeclList( $5 )->addFunctionBody( $6 )->addQualifiers( $2 )->addQualifiers( $1 ); + } + ; + +declarator: + variable_declarator + | function_declarator + | typedef_redeclarator + ; + +subrange: + constant_expression '~' constant_expression // CFA, integer subrange + { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Range), $1, $3); } + ; + +asm_name_opt: // GCC + // empty + | ASM '(' string_literal_list ')' attribute_list_opt + ; + +attribute_list_opt: // GCC + // empty + | attribute_list + ; + +attribute_list: // GCC + attribute + | attribute_list attribute + ; + +attribute: // GCC + ATTRIBUTE '(' '(' attribute_parameter_list ')' ')' + ; + +attribute_parameter_list: // GCC + attrib + | attribute_parameter_list ',' attrib + ; + +attrib: // GCC + // empty + | any_word + | any_word '(' comma_expression_opt ')' + ; + +any_word: // GCC + identifier_or_typedef_name {} + | storage_class_name {} + | basic_type_name {} + | type_qualifier {} + ; + +// ============================================================================ +// The following sections are a series of grammar patterns used to parse declarators. Multiple patterns are +// necessary because the type of an identifier in wrapped around the identifier in the same form as its usage +// in an expression, as in: +// +// int (*f())[10] { ... }; +// ... (*f())[3] += 1; // definition mimics usage +// +// Because these patterns are highly recursive, changes at a lower level in the recursion require copying some +// or all of the pattern. Each of these patterns has some subtle variation to ensure correct syntax in a +// particular context. +// ============================================================================ + +// ---------------------------------------------------------------------------- +// The set of valid declarators before a compound statement for defining a function is less than the set of +// declarators to define a variable or function prototype, e.g.: +// +// valid declaration invalid definition +// ----------------- ------------------ +// int f; int f {} +// int *f; int *f {} +// int f[10]; int f[10] {} +// int (*f)(int); int (*f)(int) {} +// +// To preclude this syntactic anomaly requires separating the grammar rules for variable and function +// declarators, hence variable_declarator and function_declarator. +// ---------------------------------------------------------------------------- + +// This pattern parses a declaration of a variable that is not redefining a typedef name. The pattern +// precludes declaring an array of functions versus a pointer to an array of functions. + +variable_declarator: + paren_identifier attribute_list_opt + | variable_ptr + | variable_array attribute_list_opt + | variable_function attribute_list_opt + ; + +paren_identifier: + identifier + { + typedefTable.setNextIdentifier( *($1) ); + $$ = DeclarationNode::newName( $1 ); + } + | '(' paren_identifier ')' // redundant parenthesis + { $$ = $2; } + ; + +variable_ptr: + '*' variable_declarator + { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); } + | '*' type_qualifier_list variable_declarator + { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); } + | '(' variable_ptr ')' + { $$ = $2; } + ; + +variable_array: + paren_identifier array_dimension + { $$ = $1->addArray( $2 ); } + | '(' variable_ptr ')' array_dimension + { $$ = $2->addArray( $4 ); } + | '(' variable_array ')' multi_array_dimension // redundant parenthesis + { $$ = $2->addArray( $4 ); } + | '(' variable_array ')' // redundant parenthesis + { $$ = $2; } + ; + +variable_function: + '(' variable_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) + { $$ = $2->addParamList( $6 ); } + | '(' variable_function ')' // redundant parenthesis + { $$ = $2; } + ; + +// This pattern parses a function declarator that is not redefining a typedef name. Because functions cannot +// be nested, there is no context where a function definition can redefine a typedef name. To allow nested +// functions requires further separation of variable and function declarators in typedef_redeclarator. The +// pattern precludes returning arrays and functions versus pointers to arrays and functions. + +function_declarator: + function_no_ptr attribute_list_opt + | function_ptr + | function_array attribute_list_opt + ; + +function_no_ptr: + paren_identifier '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) + { $$ = $1->addParamList( $4 ); } + | '(' function_ptr ')' '(' push parameter_type_list_opt pop ')' + { $$ = $2->addParamList( $6 ); } + | '(' function_no_ptr ')' // redundant parenthesis + { $$ = $2; } + ; + +function_ptr: + '*' function_declarator + { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); } + | '*' type_qualifier_list function_declarator + { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); } + | '(' function_ptr ')' + { $$ = $2; } + ; + +function_array: + '(' function_ptr ')' array_dimension + { $$ = $2->addArray( $4 ); } + | '(' function_array ')' multi_array_dimension // redundant parenthesis + { $$ = $2->addArray( $4 ); } + | '(' function_array ')' // redundant parenthesis + { $$ = $2; } + ; + +// This pattern parses an old-style K&R function declarator (OBSOLESCENT, see 4) that is not redefining a +// typedef name (see function_declarator for additional comments). The pattern precludes returning arrays and +// functions versus pointers to arrays and functions. + +old_function_declarator: + old_function_no_ptr + | old_function_ptr + | old_function_array + ; + +old_function_no_ptr: + paren_identifier '(' identifier_list ')' // function_declarator handles empty parameter + { $$ = $1->addIdList( $3 ); } + | '(' old_function_ptr ')' '(' identifier_list ')' + { $$ = $2->addIdList( $5 ); } + | '(' old_function_no_ptr ')' // redundant parenthesis + { $$ = $2; } + ; + +old_function_ptr: + '*' old_function_declarator + { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); } + | '*' type_qualifier_list old_function_declarator + { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); } + | '(' old_function_ptr ')' + { $$ = $2; } + ; + +old_function_array: + '(' old_function_ptr ')' array_dimension + { $$ = $2->addArray( $4 ); } + | '(' old_function_array ')' multi_array_dimension // redundant parenthesis + { $$ = $2->addArray( $4 ); } + | '(' old_function_array ')' // redundant parenthesis + { $$ = $2; } + ; + +// This pattern parses a declaration for a variable or function prototype that redefines a typedef name, e.g.: +// +// typedef int foo; +// { +// int foo; // redefine typedef name in new scope +// } +// +// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and +// returning arrays and functions versus pointers to arrays and functions. + +typedef_redeclarator: + paren_typedef attribute_list_opt + | typedef_ptr + | typedef_array attribute_list_opt + | typedef_function attribute_list_opt + ; + +paren_typedef: + TYPEDEFname + { + typedefTable.setNextIdentifier( *($1) ); + $$ = DeclarationNode::newName( $1 ); + } + | '(' paren_typedef ')' + { $$ = $2; } + ; + +typedef_ptr: + '*' typedef_redeclarator + { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); } + | '*' type_qualifier_list typedef_redeclarator + { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); } + | '(' typedef_ptr ')' + { $$ = $2; } + ; + +typedef_array: + paren_typedef array_dimension + { $$ = $1->addArray( $2 ); } + | '(' typedef_ptr ')' array_dimension + { $$ = $2->addArray( $4 ); } + | '(' typedef_array ')' multi_array_dimension // redundant parenthesis + { $$ = $2->addArray( $4 ); } + | '(' typedef_array ')' // redundant parenthesis + { $$ = $2; } + ; + +typedef_function: + paren_typedef '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) + { $$ = $1->addParamList( $4 ); } + | '(' typedef_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) + { $$ = $2->addParamList( $6 ); } + | '(' typedef_function ')' // redundant parenthesis + { $$ = $2; } + ; + +// This pattern parses a declaration for a parameter variable or function prototype that is not redefining a +// typedef name and allows the C99 array options, which can only appear in a parameter list. The pattern +// precludes declaring an array of functions versus a pointer to an array of functions, and returning arrays +// and functions versus pointers to arrays and functions. + +identifier_parameter_declarator: + paren_identifier attribute_list_opt + | identifier_parameter_ptr + | identifier_parameter_array attribute_list_opt + | identifier_parameter_function attribute_list_opt + ; + +identifier_parameter_ptr: + '*' identifier_parameter_declarator + { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); } + | '*' type_qualifier_list identifier_parameter_declarator + { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); } + | '(' identifier_parameter_ptr ')' + { $$ = $2; } + ; + +identifier_parameter_array: + paren_identifier array_parameter_dimension + { $$ = $1->addArray( $2 ); } + | '(' identifier_parameter_ptr ')' array_dimension + { $$ = $2->addArray( $4 ); } + | '(' identifier_parameter_array ')' multi_array_dimension // redundant parenthesis + { $$ = $2->addArray( $4 ); } + | '(' identifier_parameter_array ')' // redundant parenthesis + { $$ = $2; } + ; + +identifier_parameter_function: + paren_identifier '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) + { $$ = $1->addParamList( $4 ); } + | '(' identifier_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) + { $$ = $2->addParamList( $6 ); } + | '(' identifier_parameter_function ')' // redundant parenthesis + { $$ = $2; } + ; + +// This pattern parses a declaration for a parameter variable or function prototype that is redefining a +// typedef name, e.g.: +// +// typedef int foo; +// int f( int foo ); // redefine typedef name in new scope +// +// and allows the C99 array options, which can only appear in a parameter list. In addition, the pattern +// handles the special meaning of parenthesis around a typedef name: +// +// ISO/IEC 9899:1999 Section 6.7.5.3(11) : "In a parameter declaration, a single typedef name in +// parentheses is taken to be an abstract declarator that specifies a function with a single parameter, +// not as redundant parentheses around the identifier." +// +// which precludes the following cases: +// +// typedef float T; +// int f( int ( T [5] ) ); // see abstract_parameter_declarator +// int g( int ( T ( int ) ) ); // see abstract_parameter_declarator +// int f( int f1( T a[5] ) ); // see identifier_parameter_declarator +// int g( int g1( T g2( int p ) ) ); // see identifier_parameter_declarator +// +// In essence, a '(' immediately to the left of typedef name, T, is interpreted as starting a parameter type +// list, and not as redundant parentheses around a redeclaration of T. Finally, the pattern also precludes +// declaring an array of functions versus a pointer to an array of functions, and returning arrays and +// functions versus pointers to arrays and functions. + +typedef_parameter_redeclarator: + typedef attribute_list_opt + | typedef_parameter_ptr + | typedef_parameter_array attribute_list_opt + | typedef_parameter_function attribute_list_opt + ; + +typedef: + TYPEDEFname + { + typedefTable.setNextIdentifier( *($1) ); + $$ = DeclarationNode::newName( $1 ); + } + ; + +typedef_parameter_ptr: + '*' typedef_parameter_redeclarator + { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); } + | '*' type_qualifier_list typedef_parameter_redeclarator + { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); } + | '(' typedef_parameter_ptr ')' + { $$ = $2; } + ; + +typedef_parameter_array: + typedef array_parameter_dimension + { $$ = $1->addArray( $2 ); } + | '(' typedef_parameter_ptr ')' array_parameter_dimension + { $$ = $2->addArray( $4 ); } + ; + +typedef_parameter_function: + typedef '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) + { $$ = $1->addParamList( $4 ); } + | '(' typedef_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) + { $$ = $2->addParamList( $6 ); } + ; + +// This pattern parses a declaration of an abstract variable or function prototype, i.e., there is no +// identifier to which the type applies, e.g.: +// +// sizeof( int ); +// sizeof( int [10] ); +// +// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and +// returning arrays and functions versus pointers to arrays and functions. + +abstract_declarator: + abstract_ptr + | abstract_array attribute_list_opt + | abstract_function attribute_list_opt + ; + +abstract_ptr: + '*' + { $$ = DeclarationNode::newPointer( 0 ); } + | '*' type_qualifier_list + { $$ = DeclarationNode::newPointer( $2 ); } + | '*' abstract_declarator + { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); } + | '*' type_qualifier_list abstract_declarator + { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); } + | '(' abstract_ptr ')' + { $$ = $2; } + ; + +abstract_array: + array_dimension + | '(' abstract_ptr ')' array_dimension + { $$ = $2->addArray( $4 ); } + | '(' abstract_array ')' multi_array_dimension // redundant parenthesis + { $$ = $2->addArray( $4 ); } + | '(' abstract_array ')' // redundant parenthesis + { $$ = $2; } + ; + +abstract_function: + '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) + { $$ = DeclarationNode::newFunction( 0, 0, $3, 0 ); } + | '(' abstract_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) + { $$ = $2->addParamList( $6 ); } + | '(' abstract_function ')' // redundant parenthesis + { $$ = $2; } + ; + +array_dimension: + // Only the first dimension can be empty. + '[' push pop ']' + { $$ = DeclarationNode::newArray( 0, 0, false ); } + | '[' push pop ']' multi_array_dimension + { $$ = DeclarationNode::newArray( 0, 0, false )->addArray( $5 ); } + | multi_array_dimension + ; + +multi_array_dimension: + '[' push assignment_expression pop ']' + { $$ = DeclarationNode::newArray( $3, 0, false ); } + | '[' push '*' pop ']' // C99 + { $$ = DeclarationNode::newVarArray( 0 ); } + | multi_array_dimension '[' push assignment_expression pop ']' + { $$ = $1->addArray( DeclarationNode::newArray( $4, 0, false ) ); } + | multi_array_dimension '[' push '*' pop ']' // C99 + { $$ = $1->addArray( DeclarationNode::newVarArray( 0 ) ); } + ; + +// This pattern parses a declaration of a parameter abstract variable or function prototype, i.e., there is no +// identifier to which the type applies, e.g.: +// +// int f( int ); // abstract variable parameter; no parameter name specified +// int f( int (int) ); // abstract function-prototype parameter; no parameter name specified +// +// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and +// returning arrays and functions versus pointers to arrays and functions. + +abstract_parameter_declarator: + abstract_parameter_ptr + | abstract_parameter_array attribute_list_opt + | abstract_parameter_function attribute_list_opt + ; + +abstract_parameter_ptr: + '*' + { $$ = DeclarationNode::newPointer( 0 ); } + | '*' type_qualifier_list + { $$ = DeclarationNode::newPointer( $2 ); } + | '*' abstract_parameter_declarator + { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); } + | '*' type_qualifier_list abstract_parameter_declarator + { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); } + | '(' abstract_parameter_ptr ')' + { $$ = $2; } + ; + +abstract_parameter_array: + array_parameter_dimension + | '(' abstract_parameter_ptr ')' array_parameter_dimension + { $$ = $2->addArray( $4 ); } + | '(' abstract_parameter_array ')' multi_array_dimension // redundant parenthesis + { $$ = $2->addArray( $4 ); } + | '(' abstract_parameter_array ')' // redundant parenthesis + { $$ = $2; } + ; + +abstract_parameter_function: + '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) + { $$ = DeclarationNode::newFunction( 0, 0, $3, 0 ); } + | '(' abstract_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) + { $$ = $2->addParamList( $6 ); } + | '(' abstract_parameter_function ')' // redundant parenthesis + { $$ = $2; } + ; + +array_parameter_dimension: + // Only the first dimension can be empty or have qualifiers. + array_parameter_1st_dimension + | array_parameter_1st_dimension multi_array_dimension + { $$ = $1->addArray( $2 ); } + | multi_array_dimension + ; + +// The declaration of an array parameter has additional syntax over arrays in normal variable declarations: +// +// ISO/IEC 9899:1999 Section 6.7.5.2(1) : "The optional type qualifiers and the keyword static shall +// appear only in a declaration of a function parameter with an array type, and then only in the +// outermost array type derivation." + +array_parameter_1st_dimension: + '[' push pop ']' + { $$ = DeclarationNode::newArray( 0, 0, false ); } + // multi_array_dimension handles the '[' '*' ']' case + | '[' push type_qualifier_list '*' pop ']' // remaining C99 + { $$ = DeclarationNode::newVarArray( $3 ); } + | '[' push type_qualifier_list pop ']' + { $$ = DeclarationNode::newArray( 0, $3, false ); } + // multi_array_dimension handles the '[' assignment_expression ']' case + | '[' push type_qualifier_list assignment_expression pop ']' + { $$ = DeclarationNode::newArray( $4, $3, false ); } + | '[' push STATIC type_qualifier_list_opt assignment_expression pop ']' + { $$ = DeclarationNode::newArray( $5, $4, true ); } + | '[' push type_qualifier_list STATIC assignment_expression pop ']' + { $$ = DeclarationNode::newArray( $5, $3, true ); } + ; + +// This pattern parses a declaration of an abstract variable, i.e., there is no identifier to which the type +// applies, e.g.: +// +// sizeof( int ); // abstract variable; no identifier name specified +// +// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and +// returning arrays and functions versus pointers to arrays and functions. + +variable_abstract_declarator: + variable_abstract_ptr + | variable_abstract_array attribute_list_opt + | variable_abstract_function attribute_list_opt + ; + +variable_abstract_ptr: + '*' + { $$ = DeclarationNode::newPointer( 0 ); } + | '*' type_qualifier_list + { $$ = DeclarationNode::newPointer( $2 ); } + | '*' variable_abstract_declarator + { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); } + | '*' type_qualifier_list variable_abstract_declarator + { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); } + | '(' variable_abstract_ptr ')' + { $$ = $2; } + ; + +variable_abstract_array: + array_dimension + | '(' variable_abstract_ptr ')' array_dimension + { $$ = $2->addArray( $4 ); } + | '(' variable_abstract_array ')' multi_array_dimension // redundant parenthesis + { $$ = $2->addArray( $4 ); } + | '(' variable_abstract_array ')' // redundant parenthesis + { $$ = $2; } + ; + +variable_abstract_function: + '(' variable_abstract_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) + { $$ = $2->addParamList( $6 ); } + | '(' variable_abstract_function ')' // redundant parenthesis + { $$ = $2; } + ; + +// This pattern parses a new-style declaration for a parameter variable or function prototype that is either +// an identifier or typedef name and allows the C99 array options, which can only appear in a parameter list. + +new_identifier_parameter_declarator_tuple: // CFA + new_identifier_parameter_declarator_no_tuple + | new_abstract_tuple + | type_qualifier_list new_abstract_tuple + { $$ = $2->addQualifiers( $1 ); } + ; + +new_identifier_parameter_declarator_no_tuple: // CFA + new_identifier_parameter_ptr + | new_identifier_parameter_array + ; + +new_identifier_parameter_ptr: // CFA + '*' type_specifier + { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); } + | type_qualifier_list '*' type_specifier + { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); } + | '*' new_abstract_function + { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); } + | type_qualifier_list '*' new_abstract_function + { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); } + | '*' new_identifier_parameter_declarator_tuple + { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); } + | type_qualifier_list '*' new_identifier_parameter_declarator_tuple + { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); } + ; + +new_identifier_parameter_array: // CFA + // Only the first dimension can be empty or have qualifiers. Empty dimension must be factored out due + // to shift/reduce conflict with new-style empty (void) function return type. + '[' push pop ']' type_specifier + { $$ = $5->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } + | new_array_parameter_1st_dimension type_specifier + { $$ = $2->addNewArray( $1 ); } + | '[' push pop ']' multi_array_dimension type_specifier + { $$ = $6->addNewArray( $5 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } + | new_array_parameter_1st_dimension multi_array_dimension type_specifier + { $$ = $3->addNewArray( $2 )->addNewArray( $1 ); } + | multi_array_dimension type_specifier + { $$ = $2->addNewArray( $1 ); } + | '[' push pop ']' new_identifier_parameter_ptr + { $$ = $5->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } + | new_array_parameter_1st_dimension new_identifier_parameter_ptr + { $$ = $2->addNewArray( $1 ); } + | '[' push pop ']' multi_array_dimension new_identifier_parameter_ptr + { $$ = $6->addNewArray( $5 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } + | new_array_parameter_1st_dimension multi_array_dimension new_identifier_parameter_ptr + { $$ = $3->addNewArray( $2 )->addNewArray( $1 ); } + | multi_array_dimension new_identifier_parameter_ptr + { $$ = $2->addNewArray( $1 ); } + ; + +new_array_parameter_1st_dimension: + '[' push type_qualifier_list '*' pop ']' // remaining C99 + { $$ = DeclarationNode::newVarArray( $3 ); } + | '[' push type_qualifier_list assignment_expression pop ']' + { $$ = DeclarationNode::newArray( $4, $3, false ); } + | '[' push declaration_qualifier_list assignment_expression pop ']' + // declaration_qualifier_list must be used because of shift/reduce conflict with + // assignment_expression, so a semantic check is necessary to preclude them as a type_qualifier cannot + // appear in this context. + { $$ = DeclarationNode::newArray( $4, $3, true ); } + | '[' push declaration_qualifier_list type_qualifier_list assignment_expression pop ']' + { $$ = DeclarationNode::newArray( $5, $4->addQualifiers( $3 ), true ); } + ; + +// This pattern parses a new-style declaration of an abstract variable or function prototype, i.e., there is +// no identifier to which the type applies, e.g.: +// +// [int] f( int ); // abstract variable parameter; no parameter name specified +// [int] f( [int] (int) ); // abstract function-prototype parameter; no parameter name specified +// +// These rules need LR(3): +// +// new_abstract_tuple identifier_or_typedef_name +// '[' new_parameter_list ']' identifier_or_typedef_name '(' new_parameter_type_list_opt ')' +// +// since a function return type can be syntactically identical to a tuple type: +// +// [int, int] t; +// [int, int] f( int ); +// +// Therefore, it is necessary to look at the token after identifier_or_typedef_name to know when to reduce +// new_abstract_tuple. To make this LR(1), several rules have to be flattened (lengthened) to allow the +// necessary lookahead. To accomplish this, new_abstract_declarator has an entry point without tuple, and +// tuple declarations are duplicated when appearing with new_function_specifier. + +new_abstract_declarator_tuple: // CFA + new_abstract_tuple + | type_qualifier_list new_abstract_tuple + { $$ = $2->addQualifiers( $1 ); } + | new_abstract_declarator_no_tuple + ; + +new_abstract_declarator_no_tuple: // CFA + new_abstract_ptr + | new_abstract_array + ; + +new_abstract_ptr: // CFA + '*' type_specifier + { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); } + | type_qualifier_list '*' type_specifier + { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); } + | '*' new_abstract_function + { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); } + | type_qualifier_list '*' new_abstract_function + { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); } + | '*' new_abstract_declarator_tuple + { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); } + | type_qualifier_list '*' new_abstract_declarator_tuple + { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); } + ; + +new_abstract_array: // CFA + // Only the first dimension can be empty. Empty dimension must be factored out due to shift/reduce + // conflict with empty (void) function return type. + '[' push pop ']' type_specifier + { $$ = $5->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } + | '[' push pop ']' multi_array_dimension type_specifier + { $$ = $6->addNewArray( $5 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } + | multi_array_dimension type_specifier + { $$ = $2->addNewArray( $1 ); } + | '[' push pop ']' new_abstract_ptr + { $$ = $5->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } + | '[' push pop ']' multi_array_dimension new_abstract_ptr + { $$ = $6->addNewArray( $5 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } + | multi_array_dimension new_abstract_ptr + { $$ = $2->addNewArray( $1 ); } + ; + +new_abstract_tuple: // CFA + '[' push new_abstract_parameter_list pop ']' + { $$ = DeclarationNode::newTuple( $3 ); } + ; + +new_abstract_function: // CFA + '[' push pop ']' '(' new_parameter_type_list_opt ')' + { $$ = DeclarationNode::newFunction( 0, DeclarationNode::newTuple( 0 ), $6, 0 ); } + | new_abstract_tuple '(' push new_parameter_type_list_opt pop ')' + { $$ = DeclarationNode::newFunction( 0, $1, $4, 0 ); } + | new_function_return '(' push new_parameter_type_list_opt pop ')' + { $$ = DeclarationNode::newFunction( 0, $1, $4, 0 ); } + ; + +// 1) ISO/IEC 9899:1999 Section 6.7.2(2) : "At least one type specifier shall be given in the declaration +// specifiers in each declaration, and in the specifier-qualifier list in each structure declaration and +// type name." +// +// 2) ISO/IEC 9899:1999 Section 6.11.5(1) : "The placement of a storage-class specifier other than at the +// beginning of the declaration specifiers in a declaration is an obsolescent feature." +// +// 3) ISO/IEC 9899:1999 Section 6.11.6(1) : "The use of function declarators with empty parentheses (not +// prototype-format parameter type declarators) is an obsolescent feature." +// +// 4) ISO/IEC 9899:1999 Section 6.11.7(1) : "The use of function definitions with separate parameter +// identifier and declaration lists (not prototype-format parameter type and identifier declarators) is an +// obsolescent feature. + +//************************* MISCELLANEOUS ******************************** + +comma_opt: // redundant comma + // empty + | ',' + ; + +assignment_opt: + // empty + { $$ = 0; } + | '=' assignment_expression + { $$ = $2; } + ; + +%% +// ----end of grammar---- + +void yyerror( char *string ) { + using std::cout; + using std::endl; + cout << "Error "; + if ( yyfilename ) { + cout << "in file " << yyfilename << " "; + } + cout << "at line " << yylineno << " reading token \"" << *(yylval.tok.str) << "\"" << endl; +} + +// Local Variables: // +// fill-column: 110 // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: //