Index: src/CodeGen/CodeGenerator.cc =================================================================== --- src/CodeGen/CodeGenerator.cc (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/CodeGen/CodeGenerator.cc (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Feb 16 14:56:29 2017 -// Update Count : 418 +// Last Modified On : Sun Mar 5 17:13:33 2017 +// Update Count : 475 // @@ -134,10 +134,6 @@ handleStorageClass( functionDecl ); - if ( functionDecl->get_isInline() ) { - output << "inline "; - } // if - if ( functionDecl->get_isNoreturn() ) { - output << "_Noreturn "; - } // if + DeclarationNode::print_FuncSpec( output, functionDecl->get_funcSpec() ); + output << genType( functionDecl->get_functionType(), mangleName( functionDecl ), pretty ); @@ -835,5 +831,4 @@ } - void CodeGenerator::visit( ReturnStmt * returnStmt ) { output << "return "; @@ -899,34 +894,9 @@ } - void CodeGenerator::handleStorageClass( Declaration * decl ) { - switch ( decl->get_storageClass() ) { - case DeclarationNode::Extern: - output << "extern "; - break; - case DeclarationNode::Static: - output << "static "; - break; - case DeclarationNode::Auto: - // silently drop storage class - break; - case DeclarationNode::Register: - output << "register "; - break; - case DeclarationNode::Inline: - output << "inline "; - break; - case DeclarationNode::Fortran: - output << "fortran "; - break; - case DeclarationNode::Noreturn: - output << "_Noreturn "; - break; - case DeclarationNode::Threadlocal: - output << "_Thread_local "; - break; - case DeclarationNode::NoStorageClass: - break; - } // switch - } + void CodeGenerator::handleStorageClass( DeclarationWithType * decl ) { + if ( decl->get_storageClasses().any() ) { + DeclarationNode::print_StorageClass( output, decl->get_storageClasses() ); + } // if + } // CodeGenerator::handleStorageClass std::string genName( DeclarationWithType * decl ) { Index: src/CodeGen/CodeGenerator.h =================================================================== --- src/CodeGen/CodeGenerator.h (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/CodeGen/CodeGenerator.h (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Feb 9 15:06:21 2017 -// Update Count : 49 +// Last Modified On : Wed Mar 1 16:20:04 2017 +// Update Count : 50 // @@ -123,5 +123,5 @@ void printDesignators( std::list< Expression * > & ); - void handleStorageClass( Declaration *decl ); + void handleStorageClass( DeclarationWithType *decl ); void handleAggregate( AggregateDecl *aggDecl ); void handleTypedef( NamedTypeDecl *namedType ); Index: src/CodeGen/FixNames.cc =================================================================== --- src/CodeGen/FixNames.cc (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/CodeGen/FixNames.cc (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Mon May 18 07:44:20 2015 -// Last Modified By : Rob Schluntz -// Last Modified On : Mon Apr 11 15:38:10 2016 -// Update Count : 1 +// Last Modified By : Peter A. Buhr +// Last Modified On : Mon Mar 6 23:32:08 2017 +// Update Count : 15 // @@ -39,16 +39,12 @@ std::string mangle_main() { FunctionType* main_type; - std::unique_ptr mainDecl { new FunctionDecl( - "main", - DeclarationNode::NoStorageClass, - LinkageSpec::Cforall, - main_type = new FunctionType( Type::Qualifiers(), true ), - nullptr, false, false - ) }; + std::unique_ptr mainDecl { new FunctionDecl( "main", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, + main_type = new FunctionType( Type::Qualifiers(), true ), nullptr ) + }; main_type->get_returnVals().push_back( - new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) + new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) ); - auto&& name = SymTab::Mangler::mangle( mainDecl.get() ); + auto && name = SymTab::Mangler::mangle( mainDecl.get() ); // std::cerr << name << std::endl; return name; @@ -56,21 +52,17 @@ std::string mangle_main_args() { FunctionType* main_type; - std::unique_ptr mainDecl { new FunctionDecl( - "main", - DeclarationNode::NoStorageClass, - LinkageSpec::Cforall, - main_type = new FunctionType( Type::Qualifiers(), false ), - nullptr, false, false - ) }; + std::unique_ptr mainDecl { new FunctionDecl( "main", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, + main_type = new FunctionType( Type::Qualifiers(), false ), nullptr ) + }; main_type->get_returnVals().push_back( - new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) + new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) ); mainDecl->get_functionType()->get_parameters().push_back( - new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) + new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) ); mainDecl->get_functionType()->get_parameters().push_back( - new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, + new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::Char ) ) ), nullptr ) Index: src/GenPoly/Box.cc =================================================================== --- src/GenPoly/Box.cc (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/GenPoly/Box.cc (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Feb 16 14:57:16 2017 -// Update Count : 297 +// Last Modified On : Mon Mar 6 23:45:59 2017 +// Update Count : 330 // @@ -289,6 +289,6 @@ TypeInstType paramType( Type::Qualifiers(), (*param)->get_name(), *param ); std::string paramName = mangleType( ¶mType ); - layoutFnType->get_parameters().push_back( new ObjectDecl( sizeofName( paramName ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) ); - layoutFnType->get_parameters().push_back( new ObjectDecl( alignofName( paramName ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) ); + layoutFnType->get_parameters().push_back( new ObjectDecl( sizeofName( paramName ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) ); + layoutFnType->get_parameters().push_back( new ObjectDecl( alignofName( paramName ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) ); } } @@ -298,6 +298,8 @@ // Routines at global scope marked "static" to prevent multiple definitions is separate translation units // because each unit generates copies of the default routines for each aggregate. - FunctionDecl *layoutDecl = new FunctionDecl( - layoutofName( typeDecl ), functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, layoutFnType, new CompoundStmt( noLabels ), true, false ); + FunctionDecl *layoutDecl = new FunctionDecl( layoutofName( typeDecl ), + functionNesting > 0 ? DeclarationNode::StorageClasses() : DeclarationNode::StorageClasses( DeclarationNode::StaticClass ), + LinkageSpec::AutoGen, layoutFnType, new CompoundStmt( noLabels ), + std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::InlineSpec ) ); layoutDecl->fixUniqueId(); return layoutDecl; @@ -366,9 +368,9 @@ PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType ); - ObjectDecl *sizeParam = new ObjectDecl( sizeofName( structDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType, 0 ); + ObjectDecl *sizeParam = new ObjectDecl( sizeofName( structDecl->get_name() ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType, 0 ); layoutFnType->get_parameters().push_back( sizeParam ); - ObjectDecl *alignParam = new ObjectDecl( alignofName( structDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 ); + ObjectDecl *alignParam = new ObjectDecl( alignofName( structDecl->get_name() ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 ); layoutFnType->get_parameters().push_back( alignParam ); - ObjectDecl *offsetParam = new ObjectDecl( offsetofName( structDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 ); + ObjectDecl *offsetParam = new ObjectDecl( offsetofName( structDecl->get_name() ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 ); layoutFnType->get_parameters().push_back( offsetParam ); addOtypeParams( layoutFnType, otypeParams ); @@ -427,7 +429,7 @@ PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType ); - ObjectDecl *sizeParam = new ObjectDecl( sizeofName( unionDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType, 0 ); + ObjectDecl *sizeParam = new ObjectDecl( sizeofName( unionDecl->get_name() ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType, 0 ); layoutFnType->get_parameters().push_back( sizeParam ); - ObjectDecl *alignParam = new ObjectDecl( alignofName( unionDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 ); + ObjectDecl *alignParam = new ObjectDecl( alignofName( unionDecl->get_name() ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 ); layoutFnType->get_parameters().push_back( alignParam ); addOtypeParams( layoutFnType, otypeParams ); @@ -535,5 +537,5 @@ if ( adapters.find( mangleName ) == adapters.end() ) { std::string adapterName = makeAdapterName( mangleName ); - adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, new ObjectDecl( adapterName, DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), nullptr ) ) ); + adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, new ObjectDecl( adapterName, DeclarationNode::StorageClasses(), LinkageSpec::C, nullptr, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), nullptr ) ) ); } // if } // for @@ -654,5 +656,5 @@ ObjectDecl *Pass1::makeTemporary( Type *type ) { - ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, type, 0 ); + ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, type, 0 ); stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) ); return newObj; @@ -763,5 +765,5 @@ Type * newType = param->clone(); if ( env ) env->apply( newType ); - ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, newType, 0 ); + ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, newType, 0 ); newObj->get_type()->get_qualifiers() = Type::Qualifiers(); // TODO: is this right??? stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) ); @@ -829,5 +831,5 @@ makeRetParm( adapter ); } // if - adapter->get_parameters().push_front( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 ) ); + adapter->get_parameters().push_front( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 ) ); return adapter; } @@ -910,5 +912,5 @@ adapterBody->get_kids().push_back( bodyStmt ); std::string adapterName = makeAdapterName( mangleName ); - return new FunctionDecl( adapterName, DeclarationNode::NoStorageClass, LinkageSpec::C, adapterType, adapterBody, false, false ); + return new FunctionDecl( adapterName, DeclarationNode::StorageClasses(), LinkageSpec::C, adapterType, adapterBody ); } @@ -1271,5 +1273,5 @@ if ( adaptersDone.find( mangleName ) == adaptersDone.end() ) { std::string adapterName = makeAdapterName( mangleName ); - paramList.push_front( new ObjectDecl( adapterName, DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), 0 ) ); + paramList.push_front( new ObjectDecl( adapterName, DeclarationNode::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), 0 ) ); adaptersDone.insert( adaptersDone.begin(), mangleName ); } @@ -1377,6 +1379,6 @@ std::list< DeclarationWithType *>::iterator last = funcType->get_parameters().begin(); std::list< DeclarationWithType *> inferredParams; - ObjectDecl newObj( "", DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0 ); - ObjectDecl newPtr( "", DeclarationNode::NoStorageClass, LinkageSpec::C, 0, + ObjectDecl newObj( "", DeclarationNode::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0 ); + ObjectDecl newPtr( "", DeclarationNode::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) ), 0 ); for ( Type::ForallList::const_iterator tyParm = funcType->get_forall().begin(); tyParm != funcType->get_forall().end(); ++tyParm ) { @@ -1632,5 +1634,5 @@ ObjectDecl *PolyGenericCalculator::makeVar( const std::string &name, Type *type, Initializer *init ) { - ObjectDecl *newObj = new ObjectDecl( name, DeclarationNode::NoStorageClass, LinkageSpec::C, 0, type, init ); + ObjectDecl *newObj = new ObjectDecl( name, DeclarationNode::StorageClasses(), LinkageSpec::C, 0, type, init ); stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) ); return newObj; @@ -1816,5 +1818,5 @@ memberDecl = origMember->clone(); } else { - memberDecl = new ObjectDecl( (*member)->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, offsetType->clone(), 0 ); + memberDecl = new ObjectDecl( (*member)->get_name(), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, offsetType->clone(), 0 ); } inits.push_back( new SingleInit( new OffsetofExpr( ty->clone(), memberDecl ) ) ); Index: src/GenPoly/Specialize.cc =================================================================== --- src/GenPoly/Specialize.cc (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/GenPoly/Specialize.cc (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Mon May 18 07:44:20 2015 -// Last Modified By : Rob Schluntz -// Last Modified On : Thu Apr 28 15:17:45 2016 -// Update Count : 24 +// Last Modified By : Peter A. Buhr +// Last Modified On : Mon Mar 6 23:13:00 2017 +// Update Count : 30 // @@ -155,5 +155,5 @@ } // if // create new thunk with same signature as formal type (C linkage, empty body) - FunctionDecl *thunkFunc = new FunctionDecl( thunkNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, newType, new CompoundStmt( noLabels ), false, false ); + FunctionDecl *thunkFunc = new FunctionDecl( thunkNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, newType, new CompoundStmt( noLabels ) ); thunkFunc->fixUniqueId(); Index: src/InitTweak/FixGlobalInit.cc =================================================================== --- src/InitTweak/FixGlobalInit.cc (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/InitTweak/FixGlobalInit.cc (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Mon May 04 15:14:56 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Jun 29 22:33:15 2016 -// Update Count : 4 +// Last Modified On : Mon Mar 6 23:14:19 2017 +// Update Count : 14 // @@ -87,7 +87,7 @@ dtorParameters.push_back( new ConstantExpr( Constant::from_int( 102 ) ) ); } - initFunction = new FunctionDecl( "_init_" + fixedName, DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ), false, false ); + initFunction = new FunctionDecl( "_init_" + fixedName, DeclarationNode::StorageClasses( DeclarationNode::StaticClass ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) ); initFunction->get_attributes().push_back( new Attribute( "constructor", ctorParameters ) ); - destroyFunction = new FunctionDecl( "_destroy_" + fixedName, DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ), false, false ); + destroyFunction = new FunctionDecl( "_destroy_" + fixedName, DeclarationNode::StorageClasses( DeclarationNode::StaticClass ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) ); destroyFunction->get_attributes().push_back( new Attribute( "destructor", dtorParameters ) ); } Index: src/InitTweak/FixInit.cc =================================================================== --- src/InitTweak/FixInit.cc (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/InitTweak/FixInit.cc (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Wed Jan 13 16:29:30 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Feb 16 14:58:43 2017 -// Update Count : 35 +// Last Modified On : Tue Mar 7 07:51:40 2017 +// Update Count : 59 // @@ -437,5 +437,5 @@ result = result->clone(); env->apply( result ); - ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result, 0 ); + ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, result, 0 ); tmp->get_type()->set_isConst( false ); @@ -483,5 +483,5 @@ result = result->clone(); env->apply( result ); - ObjectDecl * ret = new ObjectDecl( retNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result, 0 ); + ObjectDecl * ret = new ObjectDecl( retNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, result, 0 ); ret->get_type()->set_isConst( false ); impCpCtorExpr->get_returnDecls().push_back( ret ); @@ -506,5 +506,5 @@ result = result->clone(); env->apply( result ); - ObjectDecl * ret = new ObjectDecl( retNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result, 0 ); + ObjectDecl * ret = new ObjectDecl( retNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, result, 0 ); ret->get_type()->set_isConst( false ); stmtExpr->get_returnDecls().push_front( ret ); @@ -538,5 +538,5 @@ } else { // expr isn't a call expr, so create a new temporary variable to use to hold the value of the unique expression - unqExpr->set_object( new ObjectDecl( toString("_unq_expr_", unqExpr->get_id()), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, unqExpr->get_result()->clone(), nullptr ) ); + unqExpr->set_object( new ObjectDecl( toString("_unq_expr_", unqExpr->get_id()), DeclarationNode::StorageClasses(), LinkageSpec::C, nullptr, unqExpr->get_result()->clone(), nullptr ) ); unqExpr->set_var( new VariableExpr( unqExpr->get_object() ) ); } @@ -678,5 +678,5 @@ assert( ! ctorInit->get_ctor() || ! ctorInit->get_init() ); if ( Statement * ctor = ctorInit->get_ctor() ) { - if ( objDecl->get_storageClass() == DeclarationNode::Static ) { + if ( objDecl->get_storageClasses()[ DeclarationNode::Static ] ) { // originally wanted to take advantage of gcc nested functions, but // we get memory errors with this approach. To remedy this, the static @@ -704,5 +704,5 @@ BasicType * boolType = new BasicType( Type::Qualifiers(), BasicType::Bool ); SingleInit * boolInitExpr = new SingleInit( new ConstantExpr( Constant( boolType->clone(), "1" ) ), noDesignators ); - ObjectDecl * isUninitializedVar = new ObjectDecl( objDecl->get_mangleName() + "_uninitialized", DeclarationNode::Static, LinkageSpec::Cforall, 0, boolType, boolInitExpr ); + ObjectDecl * isUninitializedVar = new ObjectDecl( objDecl->get_mangleName() + "_uninitialized", DeclarationNode::StorageClasses( DeclarationNode::StaticClass ), LinkageSpec::Cforall, 0, boolType, boolInitExpr ); isUninitializedVar->fixUniqueId(); @@ -731,5 +731,5 @@ // void __objName_dtor_atexitN(...) {...} - FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + dtorCallerNamer.newName(), DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ), false, false ); + FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + dtorCallerNamer.newName(), DeclarationNode::StorageClasses( DeclarationNode::StaticClass ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) ); dtorCaller->fixUniqueId(); dtorCaller->get_statements()->push_back( dtorStmt ); @@ -764,5 +764,5 @@ // create a new object which is never used static UniqueName dummyNamer( "_dummy" ); - ObjectDecl * dummy = new ObjectDecl( dummyNamer.newName(), DeclarationNode::Static, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), 0, std::list< Attribute * >{ new Attribute("unused") } ); + ObjectDecl * dummy = new ObjectDecl( dummyNamer.newName(), DeclarationNode::StorageClasses( DeclarationNode::StaticClass ), LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), 0, std::list< Attribute * >{ new Attribute("unused") } ); return dummy; } @@ -821,5 +821,5 @@ void InsertDtors::visit( ObjectDecl * objDecl ) { // remember non-static destructed objects so that their destructors can be inserted later - if ( objDecl->get_storageClass() != DeclarationNode::Static ) { + if ( ! objDecl->get_storageClasses()[ DeclarationNode::Static ] ) { if ( ConstructorInit * ctorInit = dynamic_cast< ConstructorInit * >( objDecl->get_init() ) ) { // a decision should have been made by the resolver, so ctor and init are not both non-NULL @@ -1118,5 +1118,5 @@ // xxx - ideally we would reuse the temporary generated from the copy constructor passes from within firstArg if it exists and not generate a temporary if it's unnecessary. - ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, ctorExpr->get_result()->clone(), nullptr ); + ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, nullptr, ctorExpr->get_result()->clone(), nullptr ); addDeclaration( tmp ); Index: src/InitTweak/GenInit.cc =================================================================== --- src/InitTweak/GenInit.cc (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/InitTweak/GenInit.cc (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Feb 16 14:57:53 2017 -// Update Count : 167 +// Last Modified On : Tue Mar 7 07:51:38 2017 +// Update Count : 179 // @@ -120,5 +120,5 @@ void hoist( Type * type ); - DeclarationNode::StorageClass storageclass = DeclarationNode::NoStorageClass; + DeclarationNode::StorageClasses storageClasses; bool inFunction = false; }; @@ -174,8 +174,7 @@ DeclarationWithType * HoistArrayDimension::mutate( ObjectDecl * objectDecl ) { - storageclass = objectDecl->get_storageClass(); + storageClasses = objectDecl->get_storageClasses(); DeclarationWithType * temp = Parent::mutate( objectDecl ); hoist( objectDecl->get_type() ); - storageclass = DeclarationNode::NoStorageClass; return temp; } @@ -185,17 +184,15 @@ static UniqueName dimensionName( "_array_dim" ); - // C doesn't allow variable sized arrays at global scope or for static variables, - // so don't hoist dimension. + // C doesn't allow variable sized arrays at global scope or for static variables, so don't hoist dimension. if ( ! inFunction ) return; - if ( storageclass == DeclarationNode::Static ) return; + if ( storageClasses[ DeclarationNode::StaticClass] ) return; if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) { if ( ! arrayType->get_dimension() ) return; // xxx - recursive call to hoist? - // don't need to hoist dimension if it's a constexpr - only need to if there's potential - // for side effects. + // don't need to hoist dimension if it's a constexpr - only need to if there's potential for side effects. if ( isConstExpr( arrayType->get_dimension() ) ) return; - ObjectDecl * arrayDimension = new ObjectDecl( dimensionName.newName(), storageclass, LinkageSpec::C, 0, SymTab::SizeType->clone(), new SingleInit( arrayType->get_dimension() ) ); + ObjectDecl * arrayDimension = new ObjectDecl( dimensionName.newName(), storageClasses, LinkageSpec::C, 0, SymTab::SizeType->clone(), new SingleInit( arrayType->get_dimension() ) ); arrayDimension->get_type()->set_isConst( true ); Index: src/InitTweak/InitTweak.cc =================================================================== --- src/InitTweak/InitTweak.cc (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/InitTweak/InitTweak.cc (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -260,5 +260,5 @@ (objDecl->get_init() == NULL || ( objDecl->get_init() != NULL && objDecl->get_init()->get_maybeConstructed() )) - && objDecl->get_storageClass() != DeclarationNode::Extern; + && ! objDecl->get_storageClasses()[ DeclarationNode::Extern ]; } Index: src/Makefile.am =================================================================== --- src/Makefile.am (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/Makefile.am (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -38,5 +38,5 @@ # put into lib for now -cfa_cpplibdir = ${libdir} +cfa_cpplibdir = ${CFA_LIBDIR} cfa_cpplib_PROGRAMS = driver/cfa-cpp driver_cfa_cpp_SOURCES = ${SRC} Index: src/Makefile.in =================================================================== --- src/Makefile.in (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/Makefile.in (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -276,4 +276,5 @@ CFA_INCDIR = @CFA_INCDIR@ CFA_LIBDIR = @CFA_LIBDIR@ +CFA_NAME = @CFA_NAME@ CFA_PREFIX = @CFA_PREFIX@ CFLAGS = @CFLAGS@ @@ -436,5 +437,5 @@ # put into lib for now -cfa_cpplibdir = ${libdir} +cfa_cpplibdir = ${CFA_LIBDIR} driver_cfa_cpp_SOURCES = ${SRC} driver_cfa_cpp_LDADD = ${LEXLIB} -ldl # yywrap Index: src/Parser/DeclarationNode.cc =================================================================== --- src/Parser/DeclarationNode.cc (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/Parser/DeclarationNode.cc (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Sat May 16 12:34:05 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Feb 23 22:21:06 2017 -// Update Count : 775 +// Last Modified On : Tue Mar 7 08:02:09 2017 +// Update Count : 936 // @@ -19,4 +19,5 @@ #include #include +#include // ffs #include "TypeData.h" @@ -32,13 +33,14 @@ // These must remain in the same order as the corresponding DeclarationNode enumerations. -const char * DeclarationNode::storageName[] = { "extern", "static", "auto", "register", "inline", "fortran", "_Noreturn", "_Thread_local", "NoStorageClass" }; -const char * DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic", "NoQualifier" }; -const char * DeclarationNode::basicTypeName[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicType" }; -const char * DeclarationNode::complexTypeName[] = { "_Complex", "_Imaginary", "NoComplexType" }; -const char * DeclarationNode::signednessName[] = { "signed", "unsigned", "NoSignedness" }; -const char * DeclarationNode::lengthName[] = { "short", "long", "long long", "NoLength" }; -const char * DeclarationNode::aggregateName[] = { "struct", "union", "context" }; -const char * DeclarationNode::typeClassName[] = { "otype", "dtype", "ftype" }; -const char * DeclarationNode::builtinTypeName[] = { "__builtin_va_list" }; +const char * DeclarationNode::storageClassNames[] = { "extern", "static", "auto", "register", "_Thread_local", "NoStorageClassNames" }; +const char * DeclarationNode::funcSpecifierNames[] = { "inline", "fortran", "_Noreturn", "NoFunctionSpecifierNames" }; +const char * DeclarationNode::typeQualifierNames[] = { "const", "restrict", "volatile", "lvalue", "mutex", "_Atomic", "NoTypeQualifierNames" }; +const char * DeclarationNode::basicTypeNames[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicTypeNames" }; +const char * DeclarationNode::complexTypeNames[] = { "_Complex", "_Imaginary", "NoComplexTypeNames" }; +const char * DeclarationNode::signednessNames[] = { "signed", "unsigned", "NoSignednessNames" }; +const char * DeclarationNode::lengthNames[] = { "short", "long", "long long", "NoLengthNames" }; +const char * DeclarationNode::aggregateNames[] = { "struct", "union", "context", "NoAggregateNames" }; +const char * DeclarationNode::typeClassNames[] = { "otype", "dtype", "ftype", "NoTypeClassNames" }; +const char * DeclarationNode::builtinTypeNames[] = { "__builtin_va_list", "NoBuiltinTypeNames" }; UniqueName DeclarationNode::anonymous( "__anonymous" ); @@ -48,8 +50,5 @@ DeclarationNode::DeclarationNode() : type( nullptr ), - storageClass( NoStorageClass ), bitfieldWidth( nullptr ), - isInline( false ), - isNoreturn( false ), hasEllipsis( false ), linkage( ::linkage ), @@ -90,8 +89,7 @@ newnode->type = maybeClone( type ); - newnode->storageClass = storageClass; + newnode->storageClasses = storageClasses; newnode->bitfieldWidth = maybeClone( bitfieldWidth ); - newnode->isInline = isInline; - newnode->isNoreturn = isNoreturn; + newnode->funcSpecs = funcSpecs; newnode->enumeratorValue.reset( maybeClone( enumeratorValue.get() ) ); newnode->hasEllipsis = hasEllipsis; @@ -118,4 +116,24 @@ } +void DeclarationNode::print_StorageClass( std::ostream & output, StorageClasses storageClasses ) { + if ( storageClasses.any() ) { // function specifiers? + for ( unsigned int i = 0; i < DeclarationNode::NoStorageClass; i += 1 ) { + if ( storageClasses[i] ) { + output << DeclarationNode::storageClassNames[i] << ' '; + } // if + } // for + } // if +} // print_StorageClass + +void DeclarationNode::print_FuncSpec( std::ostream & output, DeclarationNode::FuncSpecifiers funcSpec ) { + if ( funcSpec.any() ) { // function specifiers? + for ( unsigned int i = 0; i < DeclarationNode::NoFuncSpecifier; i += 1 ) { + if ( funcSpec[i] ) { + output << DeclarationNode::funcSpecifierNames[i] << ' '; + } // if + } // for + } // if +} // print_FuncSpec + void DeclarationNode::print( std::ostream &os, int indent ) const { os << string( indent, ' ' ); @@ -130,7 +148,7 @@ } // if - if ( storageClass != NoStorageClass ) os << DeclarationNode::storageName[storageClass] << ' '; - if ( isInline ) os << DeclarationNode::storageName[Inline] << ' '; - if ( isNoreturn ) os << DeclarationNode::storageName[Noreturn] << ' '; + print_StorageClass( os, storageClasses ); + print_FuncSpec( os, funcSpecs ); + if ( type ) { type->print( os, indent ); @@ -183,10 +201,51 @@ } // DeclarationNode::newFunction -DeclarationNode * DeclarationNode::newQualifier( Qualifier q ) { + +DeclarationNode * DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) { + DeclarationNode * newnode = new DeclarationNode; + newnode->storageClasses[ sc ] = true; + return newnode; +} // DeclarationNode::newStorageClass + +DeclarationNode * DeclarationNode::newFuncSpecifier( DeclarationNode::FuncSpecifier fs ) { + DeclarationNode * newnode = new DeclarationNode; + newnode->funcSpecs[ fs ] = true; + return newnode; +} // DeclarationNode::newFuncSpecifier + +DeclarationNode * DeclarationNode::newTypeQualifier( TypeQualifier tq ) { DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData(); - newnode->type->qualifiers[ q ] = 1; + newnode->type->typeQualifiers[ tq ] = true; return newnode; } // DeclarationNode::newQualifier + +DeclarationNode * DeclarationNode::newBasicType( BasicType bt ) { + DeclarationNode * newnode = new DeclarationNode; + newnode->type = new TypeData( TypeData::Basic ); + newnode->type->basictype = bt; + return newnode; +} // DeclarationNode::newBasicType + +DeclarationNode * DeclarationNode::newComplexType( ComplexType ct ) { + DeclarationNode * newnode = new DeclarationNode; + newnode->type = new TypeData( TypeData::Basic ); + newnode->type->complextype = ct; + return newnode; +} // DeclarationNode::newComplexType + +DeclarationNode * DeclarationNode::newSignedNess( Signedness sn ) { + DeclarationNode * newnode = new DeclarationNode; + newnode->type = new TypeData( TypeData::Basic ); + newnode->type->signedness = sn; + return newnode; +} // DeclarationNode::newSignedNess + +DeclarationNode * DeclarationNode::newLength( Length lnth ) { + DeclarationNode * newnode = new DeclarationNode; + newnode->type = new TypeData( TypeData::Basic ); + newnode->type->length = lnth; + return newnode; +} // DeclarationNode::newLength DeclarationNode * DeclarationNode::newForall( DeclarationNode * forall ) { @@ -196,38 +255,4 @@ return newnode; } // DeclarationNode::newForall - -DeclarationNode * DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) { - DeclarationNode * newnode = new DeclarationNode; - newnode->storageClass = sc; - return newnode; -} // DeclarationNode::newStorageClass - -DeclarationNode * DeclarationNode::newBasicType( BasicType bt ) { - DeclarationNode * newnode = new DeclarationNode; - newnode->type = new TypeData( TypeData::Basic ); - newnode->type->basictype = bt; - return newnode; -} // DeclarationNode::newBasicType - -DeclarationNode * DeclarationNode::newComplexType( ComplexType ct ) { - DeclarationNode * newnode = new DeclarationNode; - newnode->type = new TypeData( TypeData::Basic ); - newnode->type->complextype = ct; - return newnode; -} // DeclarationNode::newComplexType - -DeclarationNode * DeclarationNode::newSignedNess( Signedness sn ) { - DeclarationNode * newnode = new DeclarationNode; - newnode->type = new TypeData( TypeData::Basic ); - newnode->type->signedness = sn; - return newnode; -} // DeclarationNode::newSignedNess - -DeclarationNode * DeclarationNode::newLength( Length lnth ) { - DeclarationNode * newnode = new DeclarationNode; - newnode->type = new TypeData( TypeData::Basic ); - newnode->type->length = lnth; - return newnode; -} // DeclarationNode::newLength DeclarationNode * DeclarationNode::newFromTypedef( string * name ) { @@ -428,35 +453,45 @@ void DeclarationNode::checkQualifiers( const TypeData * src, const TypeData * dst ) { - TypeData::Qualifiers qsrc = src->qualifiers, qdst = dst->qualifiers; // optimization + const TypeData::TypeQualifiers qsrc = src->typeQualifiers, qdst = dst->typeQualifiers; // optimization if ( (qsrc & qdst).any() ) { // common qualifier ? - for ( int i = 0; i < NoQualifier; i += 1 ) { // find common qualifiers + for ( unsigned int i = 0; i < NoTypeQualifier; i += 1 ) { // find common qualifiers if ( qsrc[i] && qdst[i] ) { - appendError( error, string( "duplicate " ) + DeclarationNode::qualifierName[i] ); + appendError( error, string( "duplicate " ) + DeclarationNode::typeQualifierNames[i] ); } // if } // for - } // if + } // for } // DeclarationNode::checkQualifiers -void DeclarationNode::checkStorageClasses( DeclarationNode * q ) { - if ( storageClass != NoStorageClass && q->storageClass != NoStorageClass ) { - if ( storageClass == q->storageClass ) { // duplicate qualifier - appendError( error, string( "duplicate " ) + storageName[ storageClass ] ); - } else { // only one storage class - appendError( error, string( "conflicting " ) + storageName[ storageClass ] + " & " + storageName[ q->storageClass ] ); - q->storageClass = storageClass; // FIX ERROR, prevent assertions from triggering - } // if - } // if - appendError( error, q->error ); -} // DeclarationNode::checkStorageClasses - -DeclarationNode * DeclarationNode::copyStorageClasses( DeclarationNode * q ) { - isInline = isInline || q->isInline; - isNoreturn = isNoreturn || q->isNoreturn; - // do not overwrite an existing value with NoStorageClass - if ( q->storageClass != NoStorageClass ) { - assert( storageClass == NoStorageClass || storageClass == q->storageClass ); - storageClass = q->storageClass; - } // if +void DeclarationNode::checkSpecifiers( DeclarationNode * src ) { + if ( (funcSpecs & src->funcSpecs).any() ) { // common specifier ? + for ( unsigned int i = 0; i < NoFuncSpecifier; i += 1 ) { // find common specifier + if ( funcSpecs[i] && src->funcSpecs[i] ) { + appendError( error, string( "duplicate " ) + DeclarationNode::funcSpecifierNames[i] ); + } // if + } // for + } // if + + if ( storageClasses != 0 && src->storageClasses != 0 ) { // any reason to check ? + if ( (storageClasses & src->storageClasses).any() ) { // duplicates ? + for ( unsigned int i = 0; i < NoStorageClass; i += 1 ) { // find duplicates + if ( storageClasses[i] && src->storageClasses[i] ) { + appendError( error, string( "duplicate " ) + storageClassNames[i] ); + } // if + } // for + // src is the new item being added and has a single bit + } else if ( ! src->storageClasses[ Threadlocal ] ) { // conflict ? + appendError( error, string( "conflicting " ) + storageClassNames[ffs( storageClasses.to_ulong() ) - 1] + + " & " + storageClassNames[ffs( src->storageClasses.to_ulong() ) - 1] ); + src->storageClasses.reset(); // FIX to preserve invariant of one basic storage specifier + } // if + } // if + + appendError( error, src->error ); +} // DeclarationNode::checkSpecifiers + +DeclarationNode * DeclarationNode::copySpecifiers( DeclarationNode * q ) { + funcSpecs = funcSpecs | q->funcSpecs; + storageClasses = storageClasses | q->storageClasses; for ( Attribute *attr: reverseIterate( q->attributes ) ) { @@ -464,5 +499,5 @@ } // for return this; -} // DeclarationNode::copyStorageClasses +} // DeclarationNode::copySpecifiers static void addQualifiersToType( TypeData *&src, TypeData * dst ) { @@ -481,5 +516,5 @@ src = nullptr; } else { - dst->qualifiers |= src->qualifiers; + dst->typeQualifiers |= src->typeQualifiers; } // if } // addQualifiersToType @@ -488,6 +523,6 @@ if ( ! q ) { delete q; return this; } - checkStorageClasses( q ); - copyStorageClasses( q ); + checkSpecifiers( q ); + copySpecifiers( q ); if ( ! q->type ) { @@ -518,5 +553,5 @@ } // if - checkQualifiers( q->type, type ); + checkQualifiers( type, q->type ); addQualifiersToType( q->type, type ); @@ -539,10 +574,10 @@ switch ( dst->kind ) { case TypeData::Unknown: - src->qualifiers |= dst->qualifiers; + src->typeQualifiers |= dst->typeQualifiers; dst = src; src = nullptr; break; case TypeData::Basic: - dst->qualifiers |= src->qualifiers; + dst->typeQualifiers |= src->typeQualifiers; if ( src->kind != TypeData::Unknown ) { assert( src->kind == TypeData::Basic ); @@ -551,15 +586,15 @@ dst->basictype = src->basictype; } else if ( src->basictype != DeclarationNode::NoBasicType ) - throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::basicTypeName[ src->basictype ] + " in type: ", src ); + throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::basicTypeNames[ src->basictype ] + " in type: ", src ); if ( dst->complextype == DeclarationNode::NoComplexType ) { dst->complextype = src->complextype; } else if ( src->complextype != DeclarationNode::NoComplexType ) - throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::complexTypeName[ src->complextype ] + " in type: ", src ); + throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::complexTypeNames[ src->complextype ] + " in type: ", src ); if ( dst->signedness == DeclarationNode::NoSignedness ) { dst->signedness = src->signedness; } else if ( src->signedness != DeclarationNode::NoSignedness ) - throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::signednessName[ src->signedness ] + " in type: ", src ); + throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::signednessNames[ src->signedness ] + " in type: ", src ); if ( dst->length == DeclarationNode::NoLength ) { @@ -568,5 +603,5 @@ dst->length = DeclarationNode::LongLong; } else if ( src->length != DeclarationNode::NoLength ) - throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::lengthName[ src->length ] + " in type: ", src ); + throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::lengthNames[ src->length ] + " in type: ", src ); } // if break; @@ -580,5 +615,5 @@ dst->base->aggInst.params = maybeClone( src->aggregate.actuals ); } // if - dst->base->qualifiers |= src->qualifiers; + dst->base->typeQualifiers |= src->typeQualifiers; src = nullptr; break; @@ -599,6 +634,6 @@ DeclarationNode * DeclarationNode::addType( DeclarationNode * o ) { if ( o ) { - checkStorageClasses( o ); - copyStorageClasses( o ); + checkSpecifiers( o ); + copySpecifiers( o ); if ( o->type ) { if ( ! type ) { @@ -612,5 +647,5 @@ type->aggInst.hoistType = o->type->enumeration.body; } // if - type->qualifiers |= o->type->qualifiers; + type->typeQualifiers |= o->type->typeQualifiers; } else { type = o->type; @@ -768,5 +803,5 @@ p->type->base->aggInst.params = maybeClone( type->aggregate.actuals ); } // if - p->type->base->qualifiers |= type->qualifiers; + p->type->base->typeQualifiers |= type->typeQualifiers; break; @@ -805,5 +840,5 @@ lastArray->base->aggInst.params = maybeClone( type->aggregate.actuals ); } // if - lastArray->base->qualifiers |= type->qualifiers; + lastArray->base->typeQualifiers |= type->typeQualifiers; break; default: @@ -854,6 +889,5 @@ DeclarationNode * newnode = new DeclarationNode; newnode->type = maybeClone( type ); - assert( storageClass == NoStorageClass ); - newnode->copyStorageClasses( this ); + newnode->copySpecifiers( this ); assert( newName ); newnode->name = newName; @@ -864,5 +898,5 @@ if ( ! o ) return nullptr; - o->copyStorageClasses( this ); + o->copySpecifiers( this ); if ( type ) { TypeData * srcType = type; @@ -956,5 +990,5 @@ } else if ( StructDecl * agg = dynamic_cast< StructDecl * >( decl ) ) { StructInstType * inst = new StructInstType( Type::Qualifiers(), agg->get_name() ); - auto obj = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, nullptr, inst, nullptr ); + auto obj = new ObjectDecl( "", DeclarationNode::StorageClasses(), linkage, nullptr, inst, nullptr ); obj->location = cur->location; * out++ = obj; @@ -962,5 +996,5 @@ } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) { UnionInstType * inst = new UnionInstType( Type::Qualifiers(), agg->get_name() ); - auto obj = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, nullptr, inst, nullptr ); + auto obj = new ObjectDecl( "", DeclarationNode::StorageClasses(), linkage, nullptr, inst, nullptr ); obj->location = cur->location; * out++ = obj; @@ -1005,11 +1039,9 @@ } // if -// if ( variable.name ) { if ( variable.tyClass != NoTypeClass ) { static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Dtype, TypeDecl::Ftype, TypeDecl::Ttype }; assertf( sizeof(kindMap)/sizeof(kindMap[0] == NoTypeClass-1), "DeclarationNode::build: kindMap is out of sync." ); assertf( variable.tyClass < sizeof(kindMap)/sizeof(kindMap[0]), "Variable's tyClass is out of bounds." ); -// TypeDecl * ret = new TypeDecl( *variable.name, DeclarationNode::NoStorageClass, nullptr, kindMap[ variable.tyClass ] ); - TypeDecl * ret = new TypeDecl( *name, DeclarationNode::NoStorageClass, nullptr, kindMap[ variable.tyClass ] ); + TypeDecl * ret = new TypeDecl( *name, DeclarationNode::StorageClasses(), nullptr, kindMap[ variable.tyClass ] ); buildList( variable.assertions, ret->get_assertions() ); return ret; @@ -1017,13 +1049,24 @@ if ( type ) { - return buildDecl( type, name ? *name : string( "" ), storageClass, maybeBuild< Expression >( bitfieldWidth ), isInline, isNoreturn, linkage, asmName, maybeBuild< Initializer >(initializer), attributes )->set_extension( extension ); - } // if - - if ( ! isInline && ! isNoreturn ) { - assertf( name, "ObjectDecl are assumed to have names\n" ); - return (new ObjectDecl( *name, storageClass, linkage, maybeBuild< Expression >( bitfieldWidth ), nullptr, maybeBuild< Initializer >( initializer ) ))->set_asmName( asmName )->set_extension( extension ); - } // if - - throw SemanticError( "invalid function specifier ", this ); + // Function specifiers can only appear on a function definition/declaration. + // + // inline _Noreturn int f(); // allowed + // inline _Noreturn int g( int i ); // allowed + // inline _Noreturn int i; // disallowed + if ( type->kind != TypeData::Function && funcSpecs.any() ) { + throw SemanticError( "invalid function specifier for ", this ); + } // if + return buildDecl( type, name ? *name : string( "" ), storageClasses, maybeBuild< Expression >( bitfieldWidth ), funcSpecs, linkage, asmName, maybeBuild< Initializer >(initializer), attributes )->set_extension( extension ); + } // if + + // SUE's cannot have function specifiers, either + // + // inlne _Noreturn struct S { ... }; // disallowed + // inlne _Noreturn enum E { ... }; // disallowed + if ( funcSpecs.any() ) { + throw SemanticError( "invalid function specifier for ", this ); + } // if + assertf( name, "ObjectDecl must a have name\n" ); + return (new ObjectDecl( *name, storageClasses, linkage, maybeBuild< Expression >( bitfieldWidth ), nullptr, maybeBuild< Initializer >( initializer ) ))->set_asmName( asmName )->set_extension( extension ); } @@ -1032,8 +1075,6 @@ if ( attr.expr ) { -// return new AttrType( buildQualifiers( type ), *attr.name, attr.expr->build() ); return new AttrType( buildQualifiers( type ), *name, attr.expr->build(), attributes ); } else if ( attr.type ) { -// return new AttrType( buildQualifiers( type ), *attr.name, attr.type->buildType() ); return new AttrType( buildQualifiers( type ), *name, attr.type->buildType(), attributes ); } // if Index: src/Parser/ExpressionNode.cc =================================================================== --- src/Parser/ExpressionNode.cc (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/Parser/ExpressionNode.cc (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:17:07 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Sep 16 16:27:44 2016 -// Update Count : 508 +// Last Modified On : Sat Mar 4 06:58:47 2017 +// Update Count : 509 // @@ -173,5 +173,5 @@ Expression *build_constantZeroOne( const std::string & str ) { - Expression * ret = new ConstantExpr( Constant( str == "0" ? (Type*)new ZeroType( emptyQualifiers ) : (Type*)new OneType( emptyQualifiers ), str ) ); + Expression * ret = new ConstantExpr( Constant( str == "0" ? (Type *)new ZeroType( emptyQualifiers ) : (Type*)new OneType( emptyQualifiers ), str ) ); delete &str; // created by lex return ret; @@ -275,5 +275,5 @@ } Expression *build_offsetOf( DeclarationNode *decl_node, NameExpr *member ) { - Expression* ret = new UntypedOffsetofExpr( maybeMoveBuildType( decl_node ), member->get_name() ); + Expression * ret = new UntypedOffsetofExpr( maybeMoveBuildType( decl_node ), member->get_name() ); delete member; return ret; Index: src/Parser/ParseNode.h =================================================================== --- src/Parser/ParseNode.h (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/Parser/ParseNode.h (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:28:16 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Feb 23 15:22:10 2017 -// Update Count : 662 +// Last Modified On : Tue Mar 7 08:10:53 2017 +// Update Count : 726 // @@ -19,4 +19,5 @@ #include #include +#include #include #include @@ -39,5 +40,5 @@ //############################################################################## -extern char* yyfilename; +extern char * yyfilename; extern int yylineno; @@ -122,5 +123,5 @@ } - Expression * build() const { return const_cast(this)->expr.release(); } + Expression * build() const { return const_cast(this)->expr.release(); } private: bool extension = false; @@ -203,10 +204,9 @@ // These must remain in the same order as the corresponding DeclarationNode names. - // enum StorageClass { Extern, Static, Auto, Register, NoStorageClass }; - // enum FunctionSpec { Inline, Fortran, Noreturn, NoFunctionSpec }; - // enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic, Threadlocal, Mutex, NoQualifier }; - - enum StorageClass { Extern, Static, Auto, Register, Inline, Fortran, Noreturn, Threadlocal, NoStorageClass, }; - enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic, NoQualifier }; + enum StorageClass { Extern, Static, Auto, Register, Threadlocal, NoStorageClass, + ExternClass = 1 << Extern, StaticClass = 1 << Static, AutoClass = 1 << Auto, RegisterClass = 1 << Register, ThreadlocalClass = 1 << Threadlocal }; + enum FuncSpecifier { Inline, Noreturn, Fortran, NoFuncSpecifier, + InlineSpec = 1 << Inline, NoreturnSpec = 1 << Noreturn, FortranSpec = 1 << Fortran }; + enum TypeQualifier { Const, Restrict, Volatile, Lvalue, Mutex, Atomic, NoTypeQualifier }; enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, NoBasicType }; enum ComplexType { Complex, Imaginary, NoComplexType }; @@ -217,24 +217,26 @@ enum BuiltinType { Valist, Zero, One, NoBuiltinType }; - static const char * storageName[]; - static const char * qualifierName[]; - static const char * basicTypeName[]; - static const char * complexTypeName[]; - static const char * signednessName[]; - static const char * lengthName[]; - static const char * aggregateName[]; - static const char * typeClassName[]; - static const char * builtinTypeName[]; - - static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false ); - static DeclarationNode * newQualifier( Qualifier ); - static DeclarationNode * newForall( DeclarationNode * ); + static const char * storageClassNames[]; + static const char * funcSpecifierNames[]; + static const char * typeQualifierNames[]; + static const char * basicTypeNames[]; + static const char * complexTypeNames[]; + static const char * signednessNames[]; + static const char * lengthNames[]; + static const char * aggregateNames[]; + static const char * typeClassNames[]; + static const char * builtinTypeNames[]; + static DeclarationNode * newStorageClass( StorageClass ); + static DeclarationNode * newFuncSpecifier( FuncSpecifier ); + static DeclarationNode * newTypeQualifier( TypeQualifier ); static DeclarationNode * newBasicType( BasicType ); static DeclarationNode * newComplexType( ComplexType ); - static DeclarationNode * newSignedNess( Signedness sn ); - static DeclarationNode * newLength( Length lnth ); + static DeclarationNode * newSignedNess( Signedness ); + static DeclarationNode * newLength( Length ); static DeclarationNode * newBuiltinType( BuiltinType ); + static DeclarationNode * newForall( DeclarationNode * ); static DeclarationNode * newFromTypedef( std::string * ); + static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false ); static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ); static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants, bool body ); @@ -263,6 +265,6 @@ DeclarationNode * addQualifiers( DeclarationNode * ); void checkQualifiers( const TypeData *, const TypeData * ); - void checkStorageClasses( DeclarationNode * ); - DeclarationNode * copyStorageClasses( DeclarationNode * ); + void checkSpecifiers( DeclarationNode * ); + DeclarationNode * copySpecifiers( DeclarationNode * ); DeclarationNode * addType( DeclarationNode * ); DeclarationNode * addTypedef(); @@ -295,5 +297,5 @@ Declaration * build() const; - ::Type * buildType() const; + Type * buildType() const; bool get_hasEllipsis() const; @@ -301,5 +303,5 @@ DeclarationNode * extractAggregate() const; bool has_enumeratorValue() const { return (bool)enumeratorValue; } - ExpressionNode * consume_enumeratorValue() const { return const_cast(this)->enumeratorValue.release(); } + ExpressionNode * consume_enumeratorValue() const { return const_cast(this)->enumeratorValue.release(); } bool get_extension() const { return extension; } @@ -323,7 +325,14 @@ TypeData * type; - StorageClass storageClass; + + typedef std::bitset< DeclarationNode::NoStorageClass > StorageClasses; + StorageClasses storageClasses; + static void print_StorageClass( std::ostream & output, StorageClasses storageClasses ); + + typedef std::bitset< DeclarationNode::NoFuncSpecifier > FuncSpecifiers; + FuncSpecifiers funcSpecs; + static void print_FuncSpec( std::ostream & output, FuncSpecifiers funcSpecs ); + ExpressionNode * bitfieldWidth; - bool isInline, isNoreturn; std::unique_ptr enumeratorValue; bool hasEllipsis; @@ -342,5 +351,5 @@ static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) { - Type* ret = orig ? orig->buildType() : nullptr; + Type * ret = orig ? orig->buildType() : nullptr; delete orig; return ret; @@ -357,5 +366,5 @@ virtual StatementNode * clone() const final { assert( false ); return nullptr; } - Statement * build() const { return const_cast(this)->stmt.release(); } + Statement * build() const { return const_cast(this)->stmt.release(); } virtual StatementNode * add_label( const std::string * name, DeclarationNode * attr = nullptr ) { Index: src/Parser/TypeData.cc =================================================================== --- src/Parser/TypeData.cc (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/Parser/TypeData.cc (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Sat May 16 15:12:51 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Feb 23 21:48:55 2017 -// Update Count : 485 +// Last Modified On : Tue Mar 7 08:08:21 2017 +// Update Count : 538 // @@ -157,5 +157,5 @@ TypeData * TypeData::clone() const { TypeData * newtype = new TypeData( kind ); - newtype->qualifiers = qualifiers; + newtype->typeQualifiers = typeQualifiers; newtype->base = maybeClone( base ); newtype->forall = maybeClone( forall ); @@ -226,6 +226,6 @@ void TypeData::print( ostream &os, int indent ) const { - for ( int i = 0; i < DeclarationNode::NoQualifier; i += 1 ) { - if ( qualifiers[i] ) os << DeclarationNode::qualifierName[ i ] << ' '; + for ( int i = 0; i < DeclarationNode::NoTypeQualifier; i += 1 ) { + if ( typeQualifiers[i] ) os << DeclarationNode::typeQualifierNames[ i ] << ' '; } // for @@ -250,9 +250,9 @@ break; case Basic: - if ( signedness != DeclarationNode::NoSignedness ) os << DeclarationNode::signednessName[ signedness ] << " "; - if ( length != DeclarationNode::NoLength ) os << DeclarationNode::lengthName[ length ] << " "; + if ( signedness != DeclarationNode::NoSignedness ) os << DeclarationNode::signednessNames[ signedness ] << " "; + if ( length != DeclarationNode::NoLength ) os << DeclarationNode::lengthNames[ length ] << " "; assert( basictype != DeclarationNode::NoBasicType ); - os << DeclarationNode::basicTypeName[ basictype ] << " "; - if ( complextype != DeclarationNode::NoComplexType ) os << DeclarationNode::complexTypeName[ complextype ] << " "; + os << DeclarationNode::basicTypeNames[ basictype ] << " "; + if ( complextype != DeclarationNode::NoComplexType ) os << DeclarationNode::complexTypeNames[ complextype ] << " "; break; case Array: @@ -301,5 +301,5 @@ break; case Aggregate: - os << DeclarationNode::aggregateName[ aggregate.kind ] << ' ' << *aggregate.name << endl; + os << DeclarationNode::aggregateNames[ aggregate.kind ] << ' ' << *aggregate.name << endl; if ( aggregate.params ) { os << string( indent + 2, ' ' ) << "with type parameters " << endl; @@ -393,29 +393,29 @@ buildList( firstNode, outputList ); for ( typename ForallList::iterator i = outputList.begin(); i != outputList.end(); ++i ) { - TypeDecl * td = static_cast(*i); + TypeDecl * td = static_cast(*i); if ( td->get_kind() == TypeDecl::Any ) { // add assertion parameters to `type' tyvars in reverse order // add dtor: void ^?{}(T *) FunctionType * dtorType = new FunctionType( Type::Qualifiers(), false ); - dtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); - td->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, nullptr, false, false ) ); + dtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); + td->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, dtorType, nullptr ) ); // add copy ctor: void ?{}(T *, T) FunctionType * copyCtorType = new FunctionType( Type::Qualifiers(), false ); - copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); - copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) ); - td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, copyCtorType, nullptr, false, false ) ); + copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); + copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) ); + td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, copyCtorType, nullptr ) ); // add default ctor: void ?{}(T *) FunctionType * ctorType = new FunctionType( Type::Qualifiers(), false ); - ctorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); - td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, nullptr, false, false ) ); + ctorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); + td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, ctorType, nullptr ) ); // add assignment operator: T * ?=?(T *, T) FunctionType * assignType = new FunctionType( Type::Qualifiers(), false ); - assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); - assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) ); - assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) ); - td->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, nullptr, false, false ) ); + assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); + assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) ); + assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) ); + td->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, assignType, nullptr ) ); } // if } // for @@ -494,9 +494,9 @@ Type::Qualifiers buildQualifiers( const TypeData * td ) { Type::Qualifiers q; - q.isConst = td->qualifiers[ DeclarationNode::Const ]; - q.isVolatile = td->qualifiers[ DeclarationNode::Volatile ]; - q.isRestrict = td->qualifiers[ DeclarationNode::Restrict ]; - q.isLvalue = td->qualifiers[ DeclarationNode::Lvalue ]; - q.isAtomic = td->qualifiers[ DeclarationNode::Atomic ];; + q.isConst = td->typeQualifiers[ DeclarationNode::Const ]; + q.isVolatile = td->typeQualifiers[ DeclarationNode::Volatile ]; + q.isRestrict = td->typeQualifiers[ DeclarationNode::Restrict ]; + q.isLvalue = td->typeQualifiers[ DeclarationNode::Lvalue ]; + q.isAtomic = td->typeQualifiers[ DeclarationNode::Atomic ];; return q; } // buildQualifiers @@ -516,8 +516,8 @@ case DeclarationNode::Bool: if ( td->signedness != DeclarationNode::NoSignedness ) { - throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td ); + throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessNames[ td->signedness ] + " in type: ", td ); } // if if ( td->length != DeclarationNode::NoLength ) { - throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td ); + throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td ); } // if @@ -532,5 +532,5 @@ if ( td->length != DeclarationNode::NoLength ) { - throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td ); + throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td ); } // if @@ -562,8 +562,8 @@ FloatingPoint: ; if ( td->signedness != DeclarationNode::NoSignedness ) { - throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td ); + throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessNames[ td->signedness ] + " in type: ", td ); } // if if ( td->length == DeclarationNode::Short || td->length == DeclarationNode::LongLong ) { - throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td ); + throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td ); } // if if ( td->basictype == DeclarationNode::Float && td->length == DeclarationNode::Long ) { @@ -732,12 +732,12 @@ } // buildAggInst -NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, DeclarationNode::StorageClass sc ) { +NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, DeclarationNode::StorageClasses scs ) { assert( td->kind == TypeData::Symbolic ); NamedTypeDecl * ret; assert( td->base ); if ( td->symbolic.isTypedef ) { - ret = new TypedefDecl( name, sc, typebuild( td->base ) ); + ret = new TypedefDecl( name, scs, typebuild( td->base ) ); } else { - ret = new TypeDecl( name, sc, typebuild( td->base ), TypeDecl::Any ); + ret = new TypeDecl( name, scs, typebuild( td->base ), TypeDecl::Any ); } // if buildList( td->symbolic.params, ret->get_parameters() ); @@ -784,5 +784,5 @@ } // buildTypeof -Declaration * buildDecl( const TypeData * td, const string &name, DeclarationNode::StorageClass sc, Expression * bitfieldWidth, bool isInline, bool isNoreturn, LinkageSpec::Spec linkage, ConstantExpr *asmName, Initializer * init, std::list< Attribute * > attributes ) { +Declaration * buildDecl( const TypeData * td, const string &name, DeclarationNode::StorageClasses scs, Expression * bitfieldWidth, DeclarationNode::FuncSpecifiers funcSpec, LinkageSpec::Spec linkage, ConstantExpr *asmName, Initializer * init, std::list< Attribute * > attributes ) { if ( td->kind == TypeData::Function ) { if ( td->function.idList ) { // KR function ? @@ -792,6 +792,6 @@ FunctionDecl * decl; Statement * stmt = maybeBuild( td->function.body ); - CompoundStmt * body = dynamic_cast< CompoundStmt* >( stmt ); - decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), body, isInline, isNoreturn, attributes ); + CompoundStmt * body = dynamic_cast< CompoundStmt * >( stmt ); + decl = new FunctionDecl( name, scs, linkage, buildFunction( td ), body, attributes, funcSpec ); return decl->set_asmName( asmName ); } else if ( td->kind == TypeData::Aggregate ) { @@ -800,7 +800,7 @@ return buildEnum( td, attributes ); } else if ( td->kind == TypeData::Symbolic ) { - return buildSymbolic( td, name, sc ); + return buildSymbolic( td, name, scs ); } else { - return (new ObjectDecl( name, sc, linkage, bitfieldWidth, typebuild( td ), init, attributes, isInline, isNoreturn ))->set_asmName( asmName ); + return (new ObjectDecl( name, scs, linkage, bitfieldWidth, typebuild( td ), init, attributes ))->set_asmName( asmName ); } // if return nullptr; @@ -820,8 +820,8 @@ break; default: - ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( buildDecl( td->base, "", DeclarationNode::NoStorageClass, nullptr, false, false, LinkageSpec::Cforall, nullptr ) ) ); + ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType * >( buildDecl( td->base, "", DeclarationNode::StorageClasses(), nullptr, DeclarationNode::FuncSpecifiers(), LinkageSpec::Cforall, nullptr ) ) ); } // switch } else { - ft->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) ); + ft->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) ); } // if return ft; @@ -846,5 +846,5 @@ for ( DeclarationNode * decl = function.oldDeclList; decl != nullptr; decl = dynamic_cast< DeclarationNode * >( decl->get_next() ) ) { // scan ALL parameter names for each declaration name to check for duplicates - for ( DeclarationNode * param = function.idList; param != nullptr; param = dynamic_cast< DeclarationNode* >( param->get_next() ) ) { + for ( DeclarationNode * param = function.idList; param != nullptr; param = dynamic_cast< DeclarationNode * >( param->get_next() ) ) { if ( *decl->name == *param->name ) { // type set => parameter name already transformed by a declaration names so there is a duplicate @@ -867,5 +867,5 @@ // rtb( a, b, c ) const char * b; {} => int rtn( int a, const char * b, int c ) {} - for ( DeclarationNode * param = function.idList; param != nullptr; param = dynamic_cast< DeclarationNode* >( param->get_next() ) ) { + for ( DeclarationNode * param = function.idList; param != nullptr; param = dynamic_cast< DeclarationNode * >( param->get_next() ) ) { if ( ! param->type ) { // generate type int for empty parameter type param->type = new TypeData( TypeData::Basic ); Index: src/Parser/TypeData.h =================================================================== --- src/Parser/TypeData.h (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/Parser/TypeData.h (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Sat May 16 15:18:36 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Feb 23 17:14:46 2017 -// Update Count : 158 +// Last Modified On : Tue Mar 7 08:03:53 2017 +// Update Count : 173 // @@ -76,6 +76,6 @@ DeclarationNode::Length length = DeclarationNode::NoLength; DeclarationNode::BuiltinType builtintype = DeclarationNode::NoBuiltinType; - typedef std::bitset< DeclarationNode::NoQualifier > Qualifiers; - Qualifiers qualifiers; + typedef std::bitset< DeclarationNode::NoTypeQualifier > TypeQualifiers; + TypeQualifiers typeQualifiers; DeclarationNode * forall; @@ -107,5 +107,4 @@ ReferenceToType * buildComAggInst( const TypeData *, std::list< Attribute * > attributes ); ReferenceToType * buildAggInst( const TypeData * ); -NamedTypeDecl * buildSymbolic( const TypeData *, const std::string &name, DeclarationNode::StorageClass sc ); TypeDecl * buildVariable( const TypeData * ); EnumDecl * buildEnum( const TypeData *, std::list< Attribute * > ); @@ -113,5 +112,5 @@ TupleType * buildTuple( const TypeData * ); TypeofType * buildTypeof( const TypeData * ); -Declaration * buildDecl( const TypeData *, const std::string &, DeclarationNode::StorageClass, Expression *, bool isInline, bool isNoreturn, LinkageSpec::Spec, ConstantExpr *asmName, Initializer * init = nullptr, std::list< class Attribute * > attributes = std::list< class Attribute * >() ); +Declaration * buildDecl( const TypeData *, const std::string &, DeclarationNode::StorageClasses, Expression *, DeclarationNode::FuncSpecifiers funcSpec, LinkageSpec::Spec, ConstantExpr *asmName, Initializer * init = nullptr, std::list< class Attribute * > attributes = std::list< class Attribute * >() ); FunctionType * buildFunction( const TypeData * ); void buildKRFunction( const TypeData::Function_t & function ); Index: src/Parser/lex.cc =================================================================== --- src/Parser/lex.cc (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ (revision ) @@ -1,3832 +1,0 @@ - -#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 186 -#define YY_END_OF_BUFFER 187 -/* 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[909] = - { 0, - 0, 0, 0, 0, 0, 0, 121, 121, 124, 124, - 187, 185, 7, 9, 8, 144, 123, 106, 149, 152, - 120, 131, 132, 147, 145, 135, 146, 138, 148, 111, - 112, 113, 136, 137, 154, 156, 155, 157, 185, 106, - 129, 185, 130, 150, 106, 108, 106, 106, 106, 106, - 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, - 106, 106, 106, 133, 153, 134, 151, 7, 185, 4, - 4, 186, 109, 186, 110, 121, 122, 128, 124, 125, - 7, 9, 0, 8, 161, 180, 106, 0, 173, 143, - 166, 174, 171, 158, 169, 159, 170, 168, 0, 117, - - 3, 0, 172, 116, 114, 0, 0, 114, 114, 0, - 0, 114, 113, 113, 113, 0, 113, 141, 142, 140, - 162, 164, 160, 165, 163, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 107, 179, 0, 123, 120, 106, 0, 0, 176, 0, - 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, - 106, 106, 106, 106, 106, 106, 106, 38, 106, 106, - 106, 106, 106, 106, 106, 106, 106, 106, 57, 106, - 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, - 106, 106, 106, 106, 106, 106, 106, 106, 175, 167, - - 7, 0, 0, 0, 2, 0, 5, 109, 0, 0, - 0, 121, 0, 127, 126, 126, 0, 0, 0, 124, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 139, 117, 118, 0, 118, - 118, 0, 0, 6, 118, 114, 0, 0, 0, 118, - 0, 114, 114, 114, 114, 0, 115, 0, 0, 113, - 113, 113, 113, 0, 177, 178, 0, 183, 181, 0, - 0, 0, 107, 0, 0, 0, 0, 0, 0, 0, - 0, 106, 17, 106, 106, 106, 106, 106, 106, 106, - 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, - - 106, 14, 106, 106, 106, 106, 106, 106, 106, 106, - 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, - 51, 106, 106, 106, 64, 106, 106, 106, 106, 106, - 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, - 91, 106, 106, 106, 106, 106, 106, 106, 106, 106, - 0, 0, 0, 0, 0, 0, 0, 0, 126, 0, - 0, 0, 0, 0, 126, 0, 0, 184, 0, 0, - 0, 0, 0, 0, 0, 118, 0, 118, 0, 118, - 0, 118, 0, 0, 118, 0, 114, 114, 0, 0, - 115, 115, 0, 115, 0, 115, 113, 113, 0, 0, - - 0, 0, 0, 0, 0, 0, 0, 0, 182, 106, - 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, - 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, - 106, 106, 21, 106, 24, 106, 27, 106, 106, 106, - 106, 106, 106, 106, 41, 106, 43, 106, 106, 106, - 106, 106, 106, 106, 56, 106, 67, 106, 106, 106, - 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, - 106, 106, 106, 106, 106, 100, 106, 106, 106, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 126, 0, 0, 0, 0, 0, 118, - - 0, 0, 0, 0, 0, 0, 0, 115, 115, 0, - 119, 0, 115, 115, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 106, 106, 22, - 106, 106, 106, 106, 106, 106, 106, 15, 106, 106, - 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, - 106, 106, 23, 25, 106, 32, 106, 106, 106, 106, - 40, 106, 106, 106, 106, 49, 106, 106, 54, 106, - 106, 71, 72, 106, 106, 106, 78, 106, 106, 106, - 106, 106, 88, 90, 92, 106, 106, 97, 106, 106, - 104, 106, 0, 0, 0, 0, 0, 0, 0, 0, - - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 119, 0, 0, 115, 119, 119, 119, 119, 0, - 115, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 106, 0, 106, 106, 106, 106, 106, 106, 106, - 106, 106, 106, 106, 106, 106, 106, 106, 106, 59, - 106, 106, 106, 106, 106, 106, 106, 106, 28, 106, - 106, 106, 39, 42, 45, 106, 106, 52, 106, 61, - 68, 106, 106, 77, 79, 82, 83, 85, 86, 106, - 106, 94, 106, 106, 105, 0, 1, 0, 0, 0, - 0, 0, 0, 109, 0, 0, 0, 126, 0, 0, - - 0, 0, 119, 0, 119, 119, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 106, 106, 18, 106, 106, - 106, 106, 106, 106, 106, 16, 106, 106, 106, 33, - 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, - 106, 106, 36, 37, 106, 48, 53, 106, 106, 106, - 93, 106, 106, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 10, 11, 29, 55, - 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, - 106, 60, 62, 65, 106, 106, 80, 95, 106, 106, - 35, 106, 47, 73, 74, 106, 98, 101, 0, 0, - - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 106, 69, 106, 106, 12, 106, 106, 30, 34, 106, - 106, 106, 66, 106, 106, 106, 106, 106, 106, 106, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 58, 106, 106, 106, 106, 106, 106, - 106, 50, 63, 75, 81, 96, 102, 106, 106, 106, - 0, 0, 0, 0, 0, 0, 0, 0, 106, 106, - 13, 19, 106, 106, 31, 106, 106, 106, 26, 46, - 89, 0, 0, 106, 106, 106, 106, 106, 106, 76, - 103, 106, 87, 20, 106, 106, 44, 84, 106, 106, - - 106, 106, 106, 106, 106, 99, 70, 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, 47, 48, 49, 50, 11, 11, 51, 11, 11, - 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, - - 62, 63, 64, 65, 66, 11, 67, 68, 69, 70, - 71, 72, 11, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 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[86] = - { 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, 7, 7, 1, 1, - 1, 8, 1, 1, 1, 9, 9, 9, 9, 9, - 9, 4, 4, 10, 4, 11, 4, 4, 4, 10, - 4, 1, 12, 1, 1, 13, 1, 9, 9, 9, - 9, 9, 9, 4, 4, 4, 4, 10, 4, 4, - 4, 11, 4, 4, 4, 10, 4, 4, 4, 4, - 4, 1, 1, 1, 1 - } ; - -static yyconst flex_int16_t yy_base[1083] = - { 0, - 0, 84, 2330, 2327, 94, 0, 177, 178, 179, 180, - 2341, 2877, 191, 2877, 197, 55, 2877, 2287, 60, 173, - 2877, 2877, 2877, 56, 188, 2877, 191, 189, 204, 216, - 275, 0, 2306, 2877, 216, 2305, 152, 344, 155, 220, - 2877, 159, 2877, 217, 226, 2877, 185, 154, 212, 251, - 237, 270, 235, 257, 241, 279, 193, 305, 314, 351, - 238, 228, 227, 2877, 225, 2877, 2300, 406, 412, 2877, - 2309, 2877, 2277, 235, 2877, 0, 2877, 439, 0, 2877, - 426, 2877, 452, 464, 2877, 511, 2276, 264, 2877, 2877, - 2877, 2877, 2877, 2293, 2877, 2290, 2877, 2877, 2300, 572, - - 2877, 2317, 2877, 451, 457, 524, 547, 298, 253, 197, - 312, 279, 0, 342, 325, 198, 322, 2877, 2877, 2877, - 2287, 2877, 2877, 2877, 2285, 2282, 218, 312, 2295, 350, - 363, 368, 369, 391, 411, 417, 2276, 452, 2225, 453, - 2254, 2877, 274, 2877, 2877, 438, 2248, 2245, 2877, 2218, - 435, 282, 353, 277, 391, 419, 442, 320, 583, 451, - 446, 443, 479, 469, 364, 472, 481, 454, 458, 484, - 503, 493, 352, 506, 486, 453, 507, 509, 2246, 539, - 532, 524, 516, 528, 556, 530, 540, 552, 553, 564, - 574, 538, 576, 613, 573, 597, 602, 571, 2877, 2877, - - 668, 674, 2294, 680, 2877, 686, 2877, 2241, 603, 2235, - 2234, 0, 683, 2877, 2877, 692, 2233, 2231, 2211, 0, - 2233, 556, 627, 630, 662, 699, 688, 692, 693, 696, - 2230, 700, 703, 2205, 2202, 2877, 0, 695, 726, 693, - 701, 2201, 2253, 2877, 747, 742, 700, 753, 760, 793, - 815, 746, 2877, 2210, 2183, 0, 802, 2227, 801, 754, - 2877, 2203, 2178, 839, 2877, 2877, 2210, 2877, 2877, 709, - 723, 2187, 2185, 755, 2181, 2180, 2178, 0, 2175, 0, - 2144, 694, 736, 737, 741, 614, 739, 738, 742, 798, - 807, 792, 802, 797, 746, 816, 748, 791, 824, 819, - - 826, 2174, 827, 830, 831, 440, 834, 838, 836, 843, - 847, 849, 841, 850, 861, 853, 862, 851, 863, 865, - 872, 864, 873, 874, 2173, 749, 875, 876, 878, 880, - 881, 882, 884, 885, 886, 888, 889, 892, 898, 896, - 2171, 899, 906, 944, 901, 907, 913, 917, 908, 911, - 976, 977, 2165, 2164, 2163, 0, 2161, 0, 964, 968, - 2158, 0, 2157, 0, 2156, 0, 2176, 2877, 964, 967, - 2153, 2147, 0, 2143, 0, 2877, 979, 998, 990, 2877, - 1004, 1044, 2141, 1020, 1066, 2139, 2877, 2877, 963, 1006, - 1052, 1005, 1091, 968, 1083, 1006, 2877, 2877, 2136, 2134, - - 2132, 0, 2129, 0, 2126, 0, 2125, 0, 2877, 931, - 981, 985, 928, 1024, 987, 1068, 958, 1070, 1060, 1010, - 1005, 1072, 1083, 1022, 1078, 1082, 1088, 1042, 1084, 1081, - 1089, 1097, 2127, 1090, 2125, 1095, 2122, 1093, 1091, 1109, - 1101, 1111, 1115, 1116, 2119, 1118, 2118, 1119, 1120, 1121, - 1123, 1126, 1127, 1128, 2117, 1129, 2115, 1131, 1134, 1135, - 1132, 1138, 1140, 1143, 1148, 1149, 1150, 1152, 1155, 1151, - 1161, 1164, 1166, 1168, 1169, 2112, 1170, 1172, 1175, 1221, - 2106, 0, 2105, 0, 2104, 0, 2102, 0, 1216, 2099, - 0, 2096, 0, 2095, 2094, 2092, 0, 2089, 0, 1223, - - 2086, 1229, 1245, 1231, 1270, 1236, 1186, 1185, 2877, 1286, - 1304, 1297, 2097, 2072, 2082, 2079, 0, 2076, 0, 2075, - 0, 2074, 0, 2072, 0, 2069, 0, 1190, 1210, 2069, - 1191, 1227, 1212, 1230, 1253, 1246, 1254, 1280, 1281, 1282, - 1284, 1228, 1287, 1286, 1288, 1285, 234, 1293, 1289, 1304, - 1300, 1305, 2068, 1322, 1306, 2067, 1308, 1313, 1318, 1320, - 2065, 1323, 1324, 1326, 1327, 2062, 1330, 1331, 2061, 1334, - 1335, 2060, 2058, 1337, 1339, 1340, 2055, 1004, 1346, 1347, - 1348, 1349, 1364, 2054, 2053, 1351, 1353, 2051, 1350, 1355, - 2018, 1362, 2066, 2012, 0, 2009, 0, 2006, 0, 2005, - - 0, 2004, 0, 2002, 0, 1999, 0, 1996, 0, 1401, - 1407, 1435, 1418, 1995, 2877, 1424, 1411, 1421, 1427, 1994, - 2877, 1992, 0, 1989, 0, 1988, 0, 1987, 0, 0, - 0, 1988, 0, 1412, 1422, 1419, 1387, 1369, 1416, 1433, - 1436, 1403, 1446, 1441, 1431, 1432, 1451, 1452, 1455, 1456, - 1457, 1486, 1460, 1461, 1462, 1464, 1463, 1467, 1985, 1465, - 1468, 1470, 1984, 1983, 1981, 1472, 1466, 1974, 1478, 1972, - 1971, 1480, 1484, 1968, 1964, 1960, 1956, 1953, 1952, 1487, - 1494, 1951, 1497, 1483, 1949, 1996, 2877, 1942, 0, 1941, - 0, 0, 0, 1942, 0, 0, 0, 2877, 0, 0, - - 0, 0, 1537, 1936, 2877, 2877, 1543, 1935, 0, 1934, - 0, 0, 0, 0, 1932, 1499, 1519, 1932, 1500, 1524, - 1530, 1501, 1502, 1533, 1537, 1931, 1532, 1541, 1534, 1539, - 1544, 599, 1548, 1549, 1579, 1556, 1557, 1560, 1561, 1562, - 1563, 1564, 1930, 1928, 1567, 1925, 1924, 1566, 1569, 1572, - 1923, 1574, 1578, 0, 0, 0, 1918, 1915, 1914, 1624, - 0, 1913, 1911, 1908, 1907, 1906, 1907, 1904, 1903, 1902, - 1580, 1588, 1576, 1577, 1601, 1583, 1602, 1589, 1604, 1603, - 1636, 1900, 1609, 1897, 1610, 1614, 1617, 1622, 1618, 1623, - 1896, 1624, 1895, 1893, 1886, 1626, 1884, 1883, 1877, 1876, - - 1875, 1873, 1856, 1847, 1846, 1843, 1836, 1833, 1826, 1824, - 1628, 1826, 1629, 1630, 1631, 1632, 1635, 1637, 1805, 1639, - 1667, 1642, 1804, 1643, 1653, 1658, 1651, 1652, 1659, 1662, - 1800, 1793, 1791, 1790, 1748, 1745, 1744, 1742, 1741, 1737, - 1735, 1733, 1732, 1734, 1663, 1664, 1666, 1672, 1673, 1674, - 1675, 1731, 1689, 1676, 1644, 1522, 1680, 1685, 1686, 1687, - 1500, 1411, 1363, 1362, 1260, 1219, 1218, 1047, 1690, 1688, - 1046, 1700, 1695, 1701, 924, 1704, 1708, 1709, 839, 794, - 759, 702, 636, 1682, 1710, 1713, 1714, 1715, 1717, 638, - 536, 1719, 488, 441, 1721, 1722, 408, 281, 1723, 1726, - - 1727, 1729, 1728, 1730, 1733, 233, 137, 2877, 1805, 1818, - 1831, 1841, 1851, 1864, 1874, 1887, 1900, 1913, 1921, 1931, - 1938, 1945, 1952, 1959, 1966, 1973, 1980, 1987, 1994, 2001, - 2005, 2013, 2019, 2026, 2033, 2040, 2047, 2050, 2057, 2063, - 2076, 2089, 2096, 2103, 2110, 2117, 2120, 2127, 2130, 2137, - 2140, 2147, 2150, 2157, 2160, 2167, 2170, 2177, 2180, 2187, - 2195, 2202, 2209, 2216, 2223, 2226, 2233, 2236, 2243, 2246, - 2253, 2259, 2272, 2279, 2286, 2289, 2296, 2299, 2306, 2309, - 2316, 2319, 2326, 2329, 2336, 2339, 2346, 2353, 2356, 2363, - 2366, 2373, 2380, 2387, 2390, 2397, 2400, 2407, 2410, 2417, - - 2420, 2427, 2430, 2437, 2443, 2456, 2463, 2470, 2473, 2480, - 2483, 2490, 2493, 2500, 2503, 2510, 2513, 2520, 2523, 2530, - 2533, 2540, 2543, 2550, 2557, 2560, 2567, 2570, 2577, 2580, - 2587, 2590, 2593, 2599, 2606, 2615, 2622, 2629, 2632, 2639, - 2642, 2645, 2651, 2658, 2661, 2664, 2667, 2670, 2673, 2676, - 2679, 2686, 2689, 2696, 2699, 2702, 2705, 2708, 2718, 2725, - 2728, 2731, 2734, 2741, 2748, 2755, 2758, 2765, 2772, 2779, - 2786, 2793, 2800, 2807, 2814, 2821, 2828, 2835, 2842, 2849, - 2856, 2863 - } ; - -static yyconst flex_int16_t yy_def[1083] = - { 0, - 908, 1, 909, 909, 908, 5, 910, 910, 911, 911, - 908, 908, 908, 908, 908, 908, 908, 912, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 31, 908, 908, 908, 908, 908, 908, 913, 912, - 908, 908, 908, 908, 912, 908, 912, 912, 912, 912, - 912, 912, 912, 912, 912, 912, 912, 912, 912, 912, - 912, 912, 912, 908, 908, 908, 908, 908, 914, 908, - 908, 908, 915, 908, 908, 916, 908, 908, 917, 908, - 908, 908, 908, 908, 908, 908, 912, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - - 908, 918, 908, 908, 30, 908, 908, 908, 908, 919, - 30, 908, 31, 908, 908, 31, 908, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 920, 908, 908, 908, 908, 912, 921, 922, 908, 908, - 912, 912, 912, 912, 912, 912, 912, 912, 912, 912, - 912, 912, 912, 912, 912, 912, 912, 912, 912, 912, - 912, 912, 912, 912, 912, 912, 912, 912, 912, 912, - 912, 912, 912, 912, 912, 912, 912, 912, 912, 912, - 912, 912, 912, 912, 912, 912, 912, 912, 908, 908, - - 908, 914, 914, 914, 908, 914, 908, 915, 908, 923, - 924, 916, 908, 908, 908, 908, 925, 926, 927, 917, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908, 908, 928, 929, 908, 100, 908, 908, 908, - 908, 100, 918, 908, 100, 111, 246, 908, 908, 908, - 908, 908, 908, 908, 908, 930, 931, 932, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908, 933, 908, 934, 935, 936, 937, 938, 939, - 908, 940, 940, 940, 940, 940, 940, 940, 940, 940, - 940, 940, 940, 940, 940, 940, 940, 940, 940, 940, - - 940, 940, 940, 940, 940, 940, 940, 940, 940, 940, - 940, 940, 940, 940, 940, 940, 940, 940, 940, 940, - 940, 940, 940, 940, 940, 940, 940, 940, 940, 940, - 940, 940, 940, 940, 940, 940, 940, 940, 940, 940, - 940, 940, 940, 940, 940, 940, 940, 940, 940, 940, - 941, 942, 943, 944, 945, 946, 947, 948, 908, 908, - 949, 950, 951, 952, 953, 954, 908, 908, 908, 908, - 908, 955, 956, 957, 958, 908, 908, 908, 908, 908, - 908, 908, 382, 908, 378, 385, 908, 908, 959, 960, - 961, 908, 908, 908, 961, 908, 908, 908, 962, 963, - - 964, 965, 966, 967, 968, 969, 970, 971, 908, 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, 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, 975, 976, 977, 978, 979, 980, 981, 908, 982, - 983, 984, 985, 986, 986, 987, 988, 989, 990, 908, - - 500, 908, 908, 991, 908, 991, 908, 908, 908, 908, - 908, 908, 908, 908, 992, 993, 994, 995, 996, 997, - 998, 999, 1000, 1001, 1002, 1003, 1004, 1005, 1005, 1005, - 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, - 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, - 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, - 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, - 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, - 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, - 1005, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, - - 1014, 1015, 1016, 1017, 1018, 1019, 1020, 1021, 1022, 908, - 908, 908, 908, 1023, 908, 612, 908, 908, 908, 616, - 908, 1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031, 1032, - 1033, 1034, 1035, 1034, 1034, 1034, 1034, 1034, 1034, 1034, - 1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034, - 1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034, - 1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034, - 1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034, - 1034, 1034, 1034, 1034, 1034, 1036, 908, 1037, 1038, 1039, - 1040, 1041, 1042, 1043, 1044, 1045, 1046, 908, 1047, 1048, - - 1049, 1050, 908, 703, 908, 908, 908, 1051, 1052, 1053, - 1054, 1055, 1056, 1057, 1058, 1059, 1059, 1059, 1059, 1059, - 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, - 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, - 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, - 1059, 1059, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 908, - 1066, 1051, 1053, 1067, 1068, 1058, 1059, 1059, 1059, 1059, - 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, - 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, - 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1069, 1070, - - 1063, 1071, 1064, 1072, 1065, 1073, 1074, 1067, 1075, 1068, - 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, - 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, - 1076, 1069, 1077, 1070, 1078, 1071, 1079, 1072, 1080, 1073, - 1081, 1074, 1075, 1059, 1059, 1059, 1059, 1059, 1059, 1059, - 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, - 1082, 1076, 1077, 1078, 1079, 1053, 1080, 1081, 1059, 1059, - 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, - 1059, 1082, 1053, 1059, 1059, 1059, 1059, 1059, 1059, 1059, - 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, - - 1059, 1059, 1059, 1059, 1059, 1059, 1059, 0, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908 - } ; - -static yyconst flex_int16_t yy_nxt[2963] = - { 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, 40, - 18, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 18, 54, 18, 55, 18, 18, - 56, 18, 57, 58, 59, 60, 61, 62, 18, 18, - 63, 64, 65, 66, 67, 68, 85, 93, 86, 86, - 68, 89, 90, 69, 72, 72, 72, 72, 72, 72, - - 72, 72, 72, 72, 73, 72, 72, 72, 72, 72, - 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, - 72, 72, 72, 72, 72, 72, 72, 72, 72, 73, - 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, - 73, 73, 73, 73, 73, 72, 74, 72, 72, 73, - 75, 73, 73, 73, 73, 73, 73, 73, 73, 73, - 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, - 73, 73, 73, 73, 73, 72, 72, 72, 72, 77, - 77, 80, 80, 124, 125, 91, 142, 80, 80, 88, - 77, 77, 81, 82, 83, 83, 83, 81, 83, 82, - - 84, 84, 84, 83, 92, 94, 88, 143, 147, 99, - 96, 100, 100, 100, 100, 100, 100, 256, 908, 95, - 101, 86, 97, 98, 86, 102, 162, 119, 144, 78, - 78, 78, 78, 145, 148, 103, 104, 88, 105, 105, - 105, 105, 106, 106, 120, 88, 121, 122, 149, 267, - 150, 268, 258, 264, 185, 107, 199, 652, 160, 108, - 161, 151, 152, 153, 88, 109, 110, 154, 155, 163, - 156, 111, 88, 157, 158, 146, 164, 107, 88, 88, - 88, 159, 165, 112, 210, 88, 88, 88, 198, 88, - 88, 109, 197, 88, 110, 104, 254, 113, 113, 113, - - 113, 113, 113, 88, 170, 178, 171, 200, 196, 88, - 211, 181, 166, 234, 107, 172, 167, 182, 114, 179, - 255, 168, 88, 275, 115, 169, 180, 173, 253, 88, - 116, 88, 908, 88, 88, 174, 107, 175, 286, 235, - 176, 252, 117, 267, 177, 268, 252, 253, 183, 276, - 115, 126, 284, 184, 253, 127, 128, 88, 129, 144, - 130, 131, 908, 132, 145, 133, 88, 259, 262, 186, - 187, 261, 88, 253, 134, 135, 136, 194, 190, 188, - 269, 267, 189, 268, 290, 260, 191, 269, 192, 260, - 908, 261, 263, 193, 267, 137, 268, 261, 138, 267, - - 267, 268, 268, 88, 88, 88, 146, 201, 82, 83, - 83, 83, 201, 204, 205, 202, 88, 261, 204, 318, - 195, 270, 267, 285, 268, 139, 140, 81, 82, 83, - 83, 83, 81, 309, 206, 206, 206, 206, 206, 206, - 213, 214, 267, 88, 268, 213, 144, 215, 267, 271, - 268, 145, 215, 83, 82, 83, 83, 83, 83, 287, - 88, 216, 216, 216, 216, 83, 82, 84, 84, 84, - 83, 88, 215, 245, 245, 245, 245, 245, 245, 246, - 246, 246, 246, 267, 267, 268, 268, 88, 217, 288, - 88, 215, 88, 88, 88, 88, 215, 215, 88, 436, - - 215, 215, 282, 88, 304, 88, 88, 908, 215, 283, - 88, 215, 247, 215, 218, 215, 289, 219, 221, 302, - 303, 88, 222, 223, 88, 321, 307, 224, 225, 312, - 226, 88, 227, 88, 310, 908, 88, 313, 88, 308, - 88, 228, 229, 230, 104, 88, 106, 106, 106, 106, - 106, 106, 305, 306, 311, 88, 320, 314, 88, 88, - 315, 88, 231, 107, 249, 232, 249, 317, 88, 250, - 250, 250, 250, 250, 250, 319, 88, 328, 316, 248, - 88, 327, 88, 323, 88, 107, 322, 367, 88, 368, - 88, 88, 88, 233, 237, 237, 237, 237, 237, 237, - - 333, 326, 251, 334, 88, 88, 324, 329, 88, 336, - 238, 239, 240, 325, 241, 240, 88, 342, 338, 330, - 335, 144, 781, 88, 337, 88, 88, 242, 88, 331, - 332, 340, 240, 239, 240, 88, 339, 241, 345, 240, - 291, 292, 293, 350, 294, 295, 346, 343, 296, 88, - 297, 88, 353, 341, 88, 298, 299, 300, 367, 301, - 368, 367, 347, 368, 348, 88, 88, 349, 344, 201, - 82, 83, 83, 83, 201, 204, 205, 202, 354, 368, - 204, 204, 205, 414, 213, 214, 204, 351, 205, 213, - 88, 908, 351, 367, 352, 368, 206, 206, 206, 206, - - 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, - 206, 206, 206, 206, 359, 359, 359, 359, 368, 367, - 908, 368, 369, 367, 367, 368, 368, 367, 370, 368, - 367, 367, 368, 368, 367, 376, 368, 376, 376, 380, - 267, 380, 268, 377, 380, 377, 88, 360, 378, 378, - 378, 378, 378, 378, 267, 384, 268, 908, 376, 410, - 376, 380, 104, 380, 246, 246, 246, 246, 380, 382, - 382, 382, 382, 382, 382, 106, 106, 106, 106, 106, - 106, 379, 250, 250, 250, 250, 250, 250, 88, 88, - 88, 88, 107, 88, 88, 387, 415, 247, 88, 417, - - 88, 88, 383, 397, 399, 428, 411, 412, 259, 413, - 416, 88, 457, 425, 107, 385, 385, 385, 385, 385, - 385, 387, 390, 106, 106, 106, 106, 106, 106, 397, - 400, 238, 249, 240, 249, 241, 240, 250, 250, 250, - 250, 250, 250, 88, 88, 392, 88, 393, 386, 88, - 88, 394, 429, 240, 88, 240, 259, 395, 241, 88, - 240, 113, 113, 113, 113, 113, 113, 422, 88, 396, - 418, 88, 423, 393, 419, 424, 88, 394, 88, 88, - 420, 421, 88, 88, 426, 427, 88, 434, 88, 430, - 88, 88, 435, 88, 264, 88, 432, 433, 431, 88, - - 441, 88, 88, 88, 442, 88, 437, 443, 438, 439, - 440, 445, 444, 88, 88, 88, 88, 88, 449, 446, - 450, 447, 451, 448, 88, 88, 88, 88, 88, 452, - 88, 459, 88, 88, 88, 454, 88, 88, 88, 456, - 88, 88, 458, 455, 88, 461, 453, 466, 88, 460, - 88, 88, 144, 88, 465, 462, 464, 463, 88, 88, - 88, 471, 467, 88, 468, 88, 469, 473, 470, 88, - 472, 474, 475, 476, 477, 478, 88, 351, 205, 205, - 88, 479, 351, 88, 352, 203, 215, 215, 215, 215, - 359, 359, 359, 359, 528, 367, 88, 368, 367, 531, - - 368, 378, 378, 378, 378, 378, 378, 377, 505, 377, - 88, 513, 378, 378, 378, 378, 378, 378, 506, 489, - 500, 500, 500, 500, 500, 500, 237, 237, 237, 237, - 237, 237, 535, 88, 505, 514, 238, 88, 240, 88, - 241, 240, 246, 246, 246, 246, 106, 106, 508, 529, - 533, 505, 530, 501, 509, 509, 88, 88, 240, 381, - 240, 507, 88, 241, 675, 240, 382, 382, 382, 382, - 382, 382, 390, 508, 88, 384, 88, 505, 538, 539, - 509, 509, 238, 239, 240, 532, 241, 240, 385, 385, - 385, 385, 385, 385, 88, 392, 543, 393, 88, 383, - - 548, 394, 908, 908, 240, 239, 240, 395, 510, 241, - 510, 240, 88, 511, 511, 511, 511, 511, 511, 396, - 88, 386, 88, 393, 88, 537, 392, 394, 393, 534, - 88, 536, 394, 88, 88, 88, 88, 540, 515, 545, - 88, 88, 88, 88, 550, 88, 512, 88, 544, 88, - 396, 541, 542, 88, 393, 546, 553, 549, 394, 554, - 551, 88, 547, 88, 552, 556, 555, 88, 88, 559, - 88, 88, 88, 88, 557, 88, 558, 561, 88, 88, - 88, 88, 560, 88, 88, 562, 88, 88, 565, 569, - 88, 563, 88, 567, 564, 88, 573, 566, 570, 568, - - 88, 88, 88, 88, 88, 574, 571, 88, 572, 578, - 575, 581, 576, 88, 582, 580, 88, 577, 88, 579, - 88, 88, 88, 205, 88, 585, 586, 88, 583, 593, - 592, 505, 589, 591, 615, 584, 587, 588, 215, 215, - 215, 215, 88, 88, 590, 500, 500, 500, 500, 500, - 500, 382, 382, 382, 382, 382, 382, 505, 636, 634, - 615, 238, 88, 240, 88, 241, 240, 385, 385, 385, - 385, 385, 385, 908, 883, 635, 505, 638, 501, 88, - 88, 505, 88, 240, 502, 240, 506, 611, 241, 611, - 240, 614, 612, 612, 612, 612, 612, 612, 88, 637, - - 503, 647, 505, 641, 639, 88, 88, 505, 511, 511, - 511, 511, 511, 511, 510, 908, 510, 642, 640, 511, - 511, 511, 511, 511, 511, 613, 616, 616, 616, 616, - 616, 616, 88, 88, 88, 643, 88, 88, 88, 88, - 88, 88, 617, 649, 618, 88, 619, 618, 648, 645, - 651, 650, 88, 644, 653, 646, 88, 88, 88, 620, - 88, 656, 657, 654, 618, 88, 618, 659, 658, 619, - 88, 618, 88, 655, 88, 88, 88, 660, 88, 88, - 661, 663, 88, 88, 664, 662, 88, 88, 669, 88, - 666, 88, 88, 665, 667, 670, 671, 668, 88, 88, - - 88, 88, 88, 88, 673, 88, 677, 88, 676, 674, - 680, 672, 681, 679, 88, 682, 88, 908, 908, 683, - 684, 88, 678, 500, 500, 500, 500, 500, 500, 612, - 612, 612, 612, 612, 612, 611, 685, 611, 721, 88, - 612, 612, 612, 612, 612, 612, 616, 616, 616, 616, - 616, 616, 720, 705, 705, 88, 610, 703, 703, 703, - 703, 703, 703, 705, 88, 706, 908, 706, 88, 716, - 706, 88, 725, 617, 88, 618, 705, 619, 618, 620, - 719, 718, 717, 88, 88, 88, 705, 706, 88, 706, - 704, 722, 723, 88, 706, 618, 724, 618, 88, 729, - - 619, 726, 618, 88, 88, 728, 727, 88, 88, 88, - 735, 733, 88, 88, 88, 88, 88, 88, 88, 88, - 88, 731, 88, 738, 88, 730, 734, 736, 741, 732, - 88, 744, 88, 737, 739, 88, 88, 740, 88, 88, - 742, 748, 743, 749, 745, 746, 88, 747, 750, 88, - 753, 88, 88, 88, 88, 882, 751, 773, 752, 703, - 703, 703, 703, 703, 703, 616, 616, 616, 616, 616, - 616, 88, 767, 772, 88, 617, 88, 618, 769, 619, - 618, 768, 88, 770, 88, 88, 88, 771, 774, 88, - 776, 88, 704, 88, 779, 778, 88, 618, 707, 618, - - 88, 88, 619, 782, 618, 784, 777, 775, 88, 88, - 783, 785, 88, 88, 88, 88, 88, 780, 88, 88, - 787, 88, 786, 788, 88, 791, 88, 789, 88, 88, - 88, 88, 88, 813, 797, 88, 790, 792, 794, 798, - 88, 88, 793, 795, 814, 796, 703, 703, 703, 703, - 703, 703, 811, 88, 88, 88, 88, 812, 816, 819, - 821, 88, 88, 815, 822, 823, 88, 818, 820, 88, - 88, 817, 825, 824, 88, 88, 88, 826, 88, 760, - 88, 88, 88, 88, 88, 827, 847, 88, 88, 88, - 849, 88, 850, 852, 88, 88, 88, 853, 828, 829, - - 846, 830, 845, 88, 88, 88, 848, 844, 855, 851, - 88, 88, 857, 856, 88, 88, 88, 854, 88, 88, - 858, 871, 859, 870, 88, 88, 88, 88, 88, 875, - 860, 877, 88, 872, 88, 878, 869, 88, 88, 88, - 88, 88, 88, 873, 876, 885, 879, 88, 881, 874, - 880, 884, 88, 88, 892, 886, 88, 887, 888, 889, - 88, 88, 88, 890, 891, 88, 88, 88, 894, 88, - 896, 88, 897, 88, 88, 88, 895, 893, 88, 88, - 88, 88, 88, 88, 901, 88, 88, 908, 908, 900, - 868, 902, 908, 898, 899, 907, 867, 908, 905, 865, - - 908, 903, 904, 864, 906, 70, 70, 70, 70, 70, - 70, 70, 70, 70, 70, 70, 70, 70, 76, 76, - 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, - 76, 79, 79, 79, 79, 79, 79, 79, 79, 79, - 79, 79, 79, 79, 87, 908, 863, 87, 908, 87, - 87, 87, 87, 87, 141, 862, 88, 88, 141, 141, - 141, 141, 141, 141, 203, 203, 203, 203, 203, 203, - 203, 203, 203, 203, 203, 203, 203, 208, 88, 908, - 208, 843, 208, 208, 208, 208, 208, 212, 908, 212, - 212, 842, 212, 212, 212, 212, 212, 212, 840, 212, - - 220, 908, 838, 220, 220, 220, 220, 220, 220, 220, - 220, 908, 220, 243, 243, 243, 243, 243, 243, 243, - 243, 243, 243, 243, 243, 243, 257, 257, 836, 257, - 908, 834, 832, 257, 273, 88, 88, 273, 88, 273, - 273, 273, 273, 273, 277, 88, 277, 88, 88, 88, - 277, 279, 88, 279, 88, 88, 88, 279, 355, 88, - 355, 908, 810, 808, 355, 357, 908, 357, 908, 805, - 803, 357, 361, 801, 361, 88, 88, 88, 361, 363, - 88, 363, 88, 88, 88, 363, 365, 766, 365, 763, - 762, 760, 365, 372, 209, 372, 756, 755, 687, 372, - - 374, 88, 374, 88, 88, 88, 374, 389, 88, 389, - 391, 391, 88, 391, 391, 391, 88, 391, 257, 257, - 88, 257, 273, 88, 88, 273, 88, 273, 273, 273, - 273, 273, 401, 88, 401, 88, 88, 88, 401, 403, - 88, 403, 714, 713, 711, 403, 405, 709, 405, 707, - 614, 702, 405, 277, 701, 277, 407, 699, 407, 697, - 695, 693, 407, 279, 691, 279, 87, 689, 687, 87, - 88, 87, 87, 87, 87, 87, 203, 203, 203, 203, - 203, 203, 203, 203, 203, 203, 203, 203, 203, 480, - 480, 480, 480, 480, 480, 480, 480, 480, 480, 480, - - 480, 480, 481, 88, 481, 88, 88, 88, 481, 483, - 88, 483, 88, 88, 88, 483, 485, 88, 485, 88, - 88, 88, 485, 355, 633, 355, 487, 631, 487, 629, - 627, 625, 487, 357, 623, 357, 490, 515, 490, 621, - 621, 610, 490, 361, 609, 361, 492, 607, 492, 495, - 495, 605, 492, 363, 603, 363, 494, 601, 494, 599, - 597, 595, 494, 365, 88, 365, 496, 88, 496, 88, - 88, 88, 496, 372, 88, 372, 498, 88, 498, 88, - 527, 525, 498, 374, 523, 374, 504, 521, 504, 519, - 504, 517, 504, 389, 503, 389, 502, 389, 499, 389, - - 391, 391, 497, 391, 391, 391, 368, 391, 516, 368, - 516, 495, 493, 491, 516, 518, 488, 518, 486, 484, - 482, 518, 520, 88, 520, 88, 88, 409, 520, 401, - 408, 401, 522, 406, 522, 404, 402, 274, 522, 403, - 269, 403, 524, 268, 524, 398, 398, 256, 524, 405, - 388, 405, 526, 388, 526, 244, 381, 375, 526, 407, - 373, 407, 87, 371, 367, 87, 366, 87, 87, 87, - 87, 87, 480, 480, 480, 480, 480, 480, 480, 480, - 480, 480, 480, 480, 480, 594, 364, 594, 362, 358, - 356, 594, 481, 209, 481, 596, 205, 596, 88, 281, - - 280, 596, 483, 278, 483, 598, 274, 598, 269, 272, - 269, 598, 485, 267, 485, 600, 266, 600, 265, 244, - 236, 600, 487, 86, 487, 602, 86, 602, 88, 209, - 207, 602, 490, 86, 490, 604, 123, 604, 118, 88, - 908, 604, 492, 71, 492, 494, 71, 494, 908, 908, - 908, 494, 606, 908, 606, 908, 908, 908, 606, 496, - 908, 496, 608, 908, 608, 908, 908, 908, 608, 498, - 908, 498, 504, 908, 504, 908, 504, 908, 504, 391, - 908, 391, 908, 908, 908, 391, 622, 908, 622, 908, - 908, 908, 622, 516, 908, 516, 624, 908, 624, 908, - - 908, 908, 624, 518, 908, 518, 626, 908, 626, 908, - 908, 908, 626, 520, 908, 520, 628, 908, 628, 908, - 908, 908, 628, 522, 908, 522, 630, 908, 630, 908, - 908, 908, 630, 524, 908, 524, 632, 908, 632, 908, - 908, 908, 632, 526, 908, 526, 87, 908, 908, 87, - 908, 87, 87, 87, 87, 87, 686, 686, 686, 686, - 686, 686, 686, 686, 686, 686, 686, 686, 686, 688, - 908, 688, 908, 908, 908, 688, 594, 908, 594, 690, - 908, 690, 908, 908, 908, 690, 596, 908, 596, 692, - 908, 692, 908, 908, 908, 692, 598, 908, 598, 694, - - 908, 694, 908, 908, 908, 694, 600, 908, 600, 696, - 908, 696, 908, 908, 908, 696, 602, 908, 602, 698, - 908, 698, 908, 908, 908, 698, 604, 908, 604, 700, - 908, 700, 908, 908, 908, 700, 606, 908, 606, 87, - 908, 87, 908, 908, 908, 87, 608, 908, 608, 504, - 908, 504, 908, 908, 908, 504, 708, 908, 708, 908, - 908, 908, 708, 622, 908, 622, 710, 908, 710, 908, - 908, 908, 710, 624, 908, 624, 712, 908, 712, 908, - 908, 908, 712, 626, 908, 626, 141, 908, 141, 908, - 908, 908, 141, 628, 908, 628, 715, 908, 715, 630, - - 908, 630, 87, 908, 908, 87, 908, 87, 87, 87, - 87, 87, 632, 908, 632, 686, 686, 686, 686, 686, - 686, 686, 686, 686, 686, 686, 686, 686, 754, 908, - 754, 908, 908, 908, 754, 688, 908, 688, 208, 908, - 208, 908, 908, 908, 208, 690, 908, 690, 757, 908, - 757, 692, 908, 692, 208, 908, 908, 208, 908, 208, - 208, 208, 208, 208, 694, 908, 694, 758, 908, 758, - 696, 908, 696, 698, 908, 698, 759, 908, 759, 700, - 908, 700, 87, 908, 87, 761, 908, 761, 908, 908, - 908, 761, 708, 908, 708, 273, 908, 273, 908, 908, - - 908, 273, 710, 908, 710, 764, 908, 764, 712, 908, - 712, 141, 908, 141, 765, 908, 765, 908, 908, 908, - 765, 87, 908, 908, 87, 908, 87, 87, 87, 87, - 87, 799, 908, 799, 754, 908, 754, 208, 908, 208, - 800, 908, 800, 908, 908, 908, 800, 802, 908, 802, - 908, 908, 908, 802, 804, 908, 804, 908, 908, 908, - 804, 806, 908, 806, 807, 908, 807, 908, 908, 908, - 807, 809, 908, 809, 908, 908, 908, 809, 831, 908, - 831, 908, 908, 908, 831, 833, 908, 833, 908, 908, - 908, 833, 835, 908, 835, 908, 908, 908, 835, 837, - - 908, 837, 908, 908, 908, 837, 839, 908, 839, 908, - 908, 908, 839, 841, 908, 841, 908, 908, 908, 841, - 632, 908, 632, 908, 908, 908, 632, 861, 908, 861, - 908, 908, 908, 861, 694, 908, 694, 908, 908, 908, - 694, 698, 908, 698, 908, 908, 908, 698, 87, 908, - 87, 908, 908, 908, 87, 866, 908, 866, 908, 908, - 908, 866, 141, 908, 141, 908, 908, 908, 141, 208, - 908, 208, 908, 908, 908, 208, 11, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908 - } ; - -static yyconst flex_int16_t yy_chk[2963] = - { 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, 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, 5, 7, - 8, 9, 10, 37, 37, 20, 39, 9, 10, 907, - 7, 8, 13, 13, 13, 13, 13, 13, 15, 15, - - 15, 15, 15, 15, 20, 25, 48, 39, 42, 28, - 27, 28, 28, 28, 28, 28, 28, 110, 116, 25, - 29, 25, 27, 27, 27, 29, 48, 35, 40, 7, - 8, 9, 10, 40, 42, 29, 30, 47, 30, 30, - 30, 30, 30, 30, 35, 57, 35, 35, 44, 127, - 44, 127, 110, 116, 57, 30, 65, 547, 47, 30, - 47, 45, 45, 45, 49, 30, 30, 45, 45, 49, - 45, 30, 40, 45, 45, 40, 49, 30, 45, 63, - 62, 45, 49, 30, 74, 906, 547, 53, 63, 51, - 61, 30, 62, 55, 30, 31, 109, 31, 31, 31, - - 31, 31, 31, 50, 51, 53, 51, 65, 61, 54, - 74, 55, 50, 88, 31, 51, 50, 55, 31, 54, - 109, 50, 52, 143, 31, 50, 54, 52, 112, 154, - 31, 56, 111, 898, 152, 52, 31, 52, 154, 88, - 52, 108, 31, 128, 52, 128, 112, 108, 56, 143, - 31, 38, 152, 56, 112, 38, 38, 58, 38, 60, - 38, 38, 111, 38, 60, 38, 59, 111, 115, 58, - 58, 117, 158, 108, 38, 38, 38, 60, 59, 58, - 131, 130, 58, 130, 158, 114, 59, 132, 59, 117, - 111, 114, 115, 59, 131, 38, 131, 117, 38, 132, - - 133, 132, 133, 60, 173, 153, 60, 68, 68, 68, - 68, 68, 68, 69, 69, 68, 165, 114, 69, 173, - 60, 134, 134, 153, 134, 38, 38, 81, 81, 81, - 81, 81, 81, 165, 69, 69, 69, 69, 69, 69, - 78, 78, 135, 155, 135, 78, 146, 78, 136, 136, - 136, 146, 78, 83, 83, 83, 83, 83, 83, 155, - 897, 78, 78, 78, 78, 84, 84, 84, 84, 84, - 84, 156, 78, 104, 104, 104, 104, 104, 104, 105, - 105, 105, 105, 138, 140, 138, 140, 151, 78, 156, - 146, 78, 306, 894, 157, 162, 78, 78, 161, 306, - - 78, 78, 151, 160, 162, 176, 168, 105, 78, 151, - 169, 78, 105, 78, 78, 78, 157, 78, 86, 160, - 161, 164, 86, 86, 166, 176, 164, 86, 86, 168, - 86, 163, 86, 167, 166, 105, 170, 169, 175, 164, - 893, 86, 86, 86, 106, 172, 106, 106, 106, 106, - 106, 106, 163, 163, 167, 171, 175, 170, 174, 177, - 171, 178, 86, 106, 107, 86, 107, 172, 183, 107, - 107, 107, 107, 107, 107, 174, 182, 183, 171, 106, - 184, 182, 186, 178, 181, 106, 177, 222, 891, 222, - 192, 180, 187, 86, 100, 100, 100, 100, 100, 100, - - 186, 181, 107, 187, 188, 189, 180, 184, 185, 188, - 100, 100, 100, 180, 100, 100, 190, 192, 189, 185, - 187, 194, 732, 198, 188, 195, 191, 100, 193, 185, - 185, 191, 100, 100, 100, 159, 190, 100, 195, 100, - 159, 159, 159, 198, 159, 159, 195, 193, 159, 196, - 159, 732, 209, 191, 197, 159, 159, 159, 223, 159, - 223, 224, 196, 224, 196, 194, 286, 197, 194, 201, - 201, 201, 201, 201, 201, 202, 202, 201, 209, 225, - 202, 204, 204, 286, 213, 213, 204, 206, 206, 213, - 890, 883, 206, 225, 206, 225, 202, 202, 202, 202, - - 202, 202, 204, 204, 204, 204, 204, 204, 206, 206, - 206, 206, 206, 206, 216, 216, 216, 216, 226, 227, - 247, 227, 228, 228, 229, 228, 229, 230, 230, 230, - 226, 232, 226, 232, 233, 240, 233, 238, 238, 241, - 270, 241, 270, 239, 241, 239, 282, 216, 239, 239, - 239, 239, 239, 239, 271, 247, 271, 882, 240, 282, - 238, 241, 246, 241, 246, 246, 246, 246, 241, 245, - 245, 245, 245, 245, 245, 248, 248, 248, 248, 248, - 248, 239, 249, 249, 249, 249, 249, 249, 283, 284, - 288, 287, 248, 285, 289, 252, 287, 246, 295, 289, - - 297, 326, 245, 260, 274, 297, 283, 284, 248, 285, - 288, 881, 326, 295, 248, 250, 250, 250, 250, 250, - 250, 252, 257, 259, 259, 259, 259, 259, 259, 260, - 274, 250, 251, 250, 251, 250, 250, 251, 251, 251, - 251, 251, 251, 298, 292, 257, 880, 257, 250, 294, - 290, 257, 298, 250, 293, 250, 259, 257, 250, 291, - 250, 264, 264, 264, 264, 264, 264, 292, 296, 257, - 290, 300, 293, 257, 291, 294, 299, 257, 301, 303, - 291, 291, 304, 305, 296, 296, 307, 304, 309, 299, - 308, 879, 305, 313, 264, 310, 301, 303, 300, 311, - - 310, 312, 314, 318, 311, 316, 307, 312, 308, 309, - 309, 314, 313, 315, 317, 319, 322, 320, 318, 315, - 319, 316, 320, 317, 321, 323, 324, 327, 328, 321, - 329, 328, 330, 331, 332, 322, 333, 334, 335, 324, - 336, 337, 327, 323, 338, 330, 321, 335, 340, 329, - 339, 342, 344, 345, 334, 331, 333, 332, 343, 346, - 349, 340, 336, 350, 337, 347, 338, 343, 339, 348, - 342, 345, 346, 347, 348, 349, 875, 351, 351, 352, - 413, 350, 351, 410, 351, 352, 359, 359, 359, 359, - 360, 360, 360, 360, 410, 369, 344, 369, 370, 413, - - 370, 377, 377, 377, 377, 377, 377, 379, 389, 379, - 417, 394, 379, 379, 379, 379, 379, 379, 389, 359, - 378, 378, 378, 378, 378, 378, 381, 381, 381, 381, - 381, 381, 417, 411, 389, 394, 378, 412, 378, 415, - 378, 378, 384, 384, 384, 384, 384, 384, 392, 411, - 415, 390, 412, 378, 392, 396, 578, 421, 378, 381, - 378, 390, 420, 378, 578, 378, 382, 382, 382, 382, - 382, 382, 391, 396, 424, 384, 414, 390, 420, 421, - 392, 396, 382, 382, 382, 414, 382, 382, 385, 385, - 385, 385, 385, 385, 428, 391, 424, 391, 871, 382, - - 428, 391, 868, 395, 382, 382, 382, 391, 393, 382, - 393, 382, 419, 393, 393, 393, 393, 393, 393, 391, - 416, 385, 418, 391, 422, 419, 395, 391, 395, 416, - 425, 418, 395, 430, 426, 423, 429, 422, 395, 426, - 427, 431, 434, 439, 430, 438, 393, 436, 425, 432, - 395, 423, 423, 441, 395, 427, 434, 429, 395, 436, - 431, 440, 427, 442, 432, 439, 438, 443, 444, 442, - 446, 448, 449, 450, 440, 451, 441, 444, 452, 453, - 454, 456, 443, 458, 461, 446, 459, 460, 450, 454, - 462, 448, 463, 452, 449, 464, 460, 451, 456, 453, - - 465, 466, 467, 470, 468, 461, 458, 469, 459, 465, - 462, 468, 463, 471, 469, 467, 472, 464, 473, 466, - 474, 475, 477, 480, 478, 472, 473, 479, 470, 480, - 479, 507, 475, 478, 508, 471, 473, 474, 489, 489, - 489, 489, 528, 531, 477, 500, 500, 500, 500, 500, - 500, 502, 502, 502, 502, 502, 502, 507, 531, 528, - 508, 500, 529, 500, 533, 500, 500, 503, 503, 503, - 503, 503, 503, 867, 866, 529, 504, 533, 500, 532, - 542, 506, 534, 500, 502, 500, 504, 505, 500, 505, - 500, 506, 505, 505, 505, 505, 505, 505, 536, 532, - - 503, 542, 504, 536, 534, 535, 537, 506, 510, 510, - 510, 510, 510, 510, 512, 865, 512, 537, 535, 512, - 512, 512, 512, 512, 512, 505, 511, 511, 511, 511, - 511, 511, 538, 539, 540, 538, 541, 546, 544, 543, - 545, 549, 511, 544, 511, 548, 511, 511, 543, 540, - 546, 545, 551, 539, 548, 541, 550, 552, 555, 511, - 557, 551, 552, 549, 511, 558, 511, 555, 554, 511, - 559, 511, 560, 550, 554, 562, 563, 557, 564, 565, - 558, 560, 567, 568, 562, 559, 570, 571, 568, 574, - 564, 575, 576, 563, 565, 570, 571, 567, 579, 580, - - 581, 582, 589, 586, 575, 587, 580, 590, 579, 576, - 583, 574, 586, 582, 592, 587, 583, 864, 863, 589, - 590, 638, 581, 610, 610, 610, 610, 610, 610, 611, - 611, 611, 611, 611, 611, 613, 592, 613, 638, 637, - 613, 613, 613, 613, 613, 613, 616, 616, 616, 616, - 616, 616, 637, 617, 617, 642, 610, 612, 612, 612, - 612, 612, 612, 618, 634, 619, 862, 619, 639, 634, - 619, 636, 642, 612, 635, 612, 617, 612, 612, 616, - 636, 635, 634, 645, 646, 640, 618, 619, 641, 619, - 612, 639, 640, 644, 619, 612, 641, 612, 643, 646, - - 612, 643, 612, 647, 648, 645, 644, 649, 650, 651, - 652, 650, 653, 654, 655, 657, 656, 660, 667, 658, - 661, 648, 662, 655, 666, 647, 651, 653, 658, 649, - 669, 662, 672, 654, 656, 684, 673, 657, 652, 680, - 660, 672, 661, 673, 666, 667, 681, 669, 680, 683, - 684, 716, 719, 722, 723, 861, 681, 723, 683, 703, - 703, 703, 703, 703, 703, 707, 707, 707, 707, 707, - 707, 717, 716, 722, 856, 703, 720, 703, 719, 703, - 703, 717, 721, 720, 727, 724, 729, 721, 724, 725, - 727, 730, 703, 728, 730, 729, 731, 703, 707, 703, - - 733, 734, 703, 733, 703, 735, 728, 725, 736, 737, - 734, 736, 738, 739, 740, 741, 742, 731, 748, 745, - 738, 749, 737, 739, 750, 742, 752, 740, 773, 774, - 753, 735, 771, 773, 752, 776, 741, 745, 748, 753, - 772, 778, 745, 749, 774, 750, 760, 760, 760, 760, - 760, 760, 771, 775, 777, 780, 779, 772, 776, 779, - 781, 783, 785, 775, 783, 785, 786, 778, 780, 787, - 789, 777, 787, 786, 788, 790, 792, 788, 796, 760, - 811, 813, 814, 815, 816, 789, 815, 817, 781, 818, - 817, 820, 818, 821, 822, 824, 855, 822, 790, 792, - - 814, 796, 813, 827, 828, 825, 816, 811, 825, 820, - 826, 829, 827, 826, 830, 845, 846, 824, 847, 821, - 828, 847, 829, 846, 848, 849, 850, 851, 854, 850, - 830, 854, 857, 848, 884, 857, 845, 858, 859, 860, - 870, 853, 869, 849, 851, 870, 858, 873, 860, 849, - 859, 869, 872, 874, 884, 872, 876, 873, 874, 876, - 877, 878, 885, 877, 878, 886, 887, 888, 886, 889, - 888, 892, 889, 895, 896, 899, 887, 885, 900, 901, - 903, 902, 904, 852, 899, 905, 844, 843, 842, 896, - 841, 900, 840, 892, 895, 905, 839, 838, 903, 837, - - 836, 901, 902, 835, 904, 909, 909, 909, 909, 909, - 909, 909, 909, 909, 909, 909, 909, 909, 910, 910, - 910, 910, 910, 910, 910, 910, 910, 910, 910, 910, - 910, 911, 911, 911, 911, 911, 911, 911, 911, 911, - 911, 911, 911, 911, 912, 834, 833, 912, 832, 912, - 912, 912, 912, 912, 913, 831, 823, 819, 913, 913, - 913, 913, 913, 913, 914, 914, 914, 914, 914, 914, - 914, 914, 914, 914, 914, 914, 914, 915, 812, 810, - 915, 809, 915, 915, 915, 915, 915, 916, 808, 916, - 916, 807, 916, 916, 916, 916, 916, 916, 806, 916, - - 917, 805, 804, 917, 917, 917, 917, 917, 917, 917, - 917, 803, 917, 918, 918, 918, 918, 918, 918, 918, - 918, 918, 918, 918, 918, 918, 919, 919, 802, 919, - 801, 800, 799, 919, 920, 798, 797, 920, 795, 920, - 920, 920, 920, 920, 921, 794, 921, 793, 791, 784, - 921, 922, 782, 922, 770, 769, 768, 922, 923, 767, - 923, 766, 765, 764, 923, 924, 763, 924, 762, 759, - 758, 924, 925, 757, 925, 751, 747, 746, 925, 926, - 744, 926, 743, 726, 718, 926, 927, 715, 927, 710, - 708, 704, 927, 928, 694, 928, 690, 688, 686, 928, - - 929, 685, 929, 682, 679, 678, 929, 930, 677, 930, - 931, 931, 676, 931, 931, 931, 675, 931, 932, 932, - 674, 932, 933, 671, 670, 933, 668, 933, 933, 933, - 933, 933, 934, 665, 934, 664, 663, 659, 934, 935, - 632, 935, 628, 626, 624, 935, 936, 622, 936, 620, - 614, 608, 936, 937, 606, 937, 938, 604, 938, 602, - 600, 598, 938, 939, 596, 939, 940, 594, 593, 940, - 591, 940, 940, 940, 940, 940, 941, 941, 941, 941, - 941, 941, 941, 941, 941, 941, 941, 941, 941, 942, - 942, 942, 942, 942, 942, 942, 942, 942, 942, 942, - - 942, 942, 943, 588, 943, 585, 584, 577, 943, 944, - 573, 944, 572, 569, 566, 944, 945, 561, 945, 556, - 553, 530, 945, 946, 526, 946, 947, 524, 947, 522, - 520, 518, 947, 948, 516, 948, 949, 515, 949, 514, - 513, 501, 949, 950, 498, 950, 951, 496, 951, 495, - 494, 492, 951, 952, 490, 952, 953, 487, 953, 485, - 483, 481, 953, 954, 476, 954, 955, 457, 955, 455, - 447, 445, 955, 956, 437, 956, 957, 435, 957, 433, - 407, 405, 957, 958, 403, 958, 959, 401, 959, 400, - 959, 399, 959, 960, 386, 960, 383, 960, 374, 960, - - 961, 961, 372, 961, 961, 961, 371, 961, 962, 367, - 962, 365, 363, 361, 962, 963, 357, 963, 355, 354, - 353, 963, 964, 341, 964, 325, 302, 281, 964, 965, - 279, 965, 966, 277, 966, 276, 275, 273, 966, 967, - 272, 967, 968, 267, 968, 263, 262, 258, 968, 969, - 255, 969, 970, 254, 970, 243, 242, 235, 970, 971, - 234, 971, 972, 231, 221, 972, 219, 972, 972, 972, - 972, 972, 973, 973, 973, 973, 973, 973, 973, 973, - 973, 973, 973, 973, 973, 974, 218, 974, 217, 211, - 210, 974, 975, 208, 975, 976, 203, 976, 179, 150, - - 148, 976, 977, 147, 977, 978, 141, 978, 139, 137, - 129, 978, 979, 126, 979, 980, 125, 980, 121, 102, - 99, 980, 981, 96, 981, 982, 94, 982, 87, 73, - 71, 982, 983, 67, 983, 984, 36, 984, 33, 18, - 11, 984, 985, 4, 985, 986, 3, 986, 0, 0, - 0, 986, 987, 0, 987, 0, 0, 0, 987, 988, - 0, 988, 989, 0, 989, 0, 0, 0, 989, 990, - 0, 990, 991, 0, 991, 0, 991, 0, 991, 992, - 0, 992, 0, 0, 0, 992, 993, 0, 993, 0, - 0, 0, 993, 994, 0, 994, 995, 0, 995, 0, - - 0, 0, 995, 996, 0, 996, 997, 0, 997, 0, - 0, 0, 997, 998, 0, 998, 999, 0, 999, 0, - 0, 0, 999, 1000, 0, 1000, 1001, 0, 1001, 0, - 0, 0, 1001, 1002, 0, 1002, 1003, 0, 1003, 0, - 0, 0, 1003, 1004, 0, 1004, 1005, 0, 0, 1005, - 0, 1005, 1005, 1005, 1005, 1005, 1006, 1006, 1006, 1006, - 1006, 1006, 1006, 1006, 1006, 1006, 1006, 1006, 1006, 1007, - 0, 1007, 0, 0, 0, 1007, 1008, 0, 1008, 1009, - 0, 1009, 0, 0, 0, 1009, 1010, 0, 1010, 1011, - 0, 1011, 0, 0, 0, 1011, 1012, 0, 1012, 1013, - - 0, 1013, 0, 0, 0, 1013, 1014, 0, 1014, 1015, - 0, 1015, 0, 0, 0, 1015, 1016, 0, 1016, 1017, - 0, 1017, 0, 0, 0, 1017, 1018, 0, 1018, 1019, - 0, 1019, 0, 0, 0, 1019, 1020, 0, 1020, 1021, - 0, 1021, 0, 0, 0, 1021, 1022, 0, 1022, 1023, - 0, 1023, 0, 0, 0, 1023, 1024, 0, 1024, 0, - 0, 0, 1024, 1025, 0, 1025, 1026, 0, 1026, 0, - 0, 0, 1026, 1027, 0, 1027, 1028, 0, 1028, 0, - 0, 0, 1028, 1029, 0, 1029, 1030, 0, 1030, 0, - 0, 0, 1030, 1031, 0, 1031, 1032, 0, 1032, 1033, - - 0, 1033, 1034, 0, 0, 1034, 0, 1034, 1034, 1034, - 1034, 1034, 1035, 0, 1035, 1036, 1036, 1036, 1036, 1036, - 1036, 1036, 1036, 1036, 1036, 1036, 1036, 1036, 1037, 0, - 1037, 0, 0, 0, 1037, 1038, 0, 1038, 1039, 0, - 1039, 0, 0, 0, 1039, 1040, 0, 1040, 1041, 0, - 1041, 1042, 0, 1042, 1043, 0, 0, 1043, 0, 1043, - 1043, 1043, 1043, 1043, 1044, 0, 1044, 1045, 0, 1045, - 1046, 0, 1046, 1047, 0, 1047, 1048, 0, 1048, 1049, - 0, 1049, 1050, 0, 1050, 1051, 0, 1051, 0, 0, - 0, 1051, 1052, 0, 1052, 1053, 0, 1053, 0, 0, - - 0, 1053, 1054, 0, 1054, 1055, 0, 1055, 1056, 0, - 1056, 1057, 0, 1057, 1058, 0, 1058, 0, 0, 0, - 1058, 1059, 0, 0, 1059, 0, 1059, 1059, 1059, 1059, - 1059, 1060, 0, 1060, 1061, 0, 1061, 1062, 0, 1062, - 1063, 0, 1063, 0, 0, 0, 1063, 1064, 0, 1064, - 0, 0, 0, 1064, 1065, 0, 1065, 0, 0, 0, - 1065, 1066, 0, 1066, 1067, 0, 1067, 0, 0, 0, - 1067, 1068, 0, 1068, 0, 0, 0, 1068, 1069, 0, - 1069, 0, 0, 0, 1069, 1070, 0, 1070, 0, 0, - 0, 1070, 1071, 0, 1071, 0, 0, 0, 1071, 1072, - - 0, 1072, 0, 0, 0, 1072, 1073, 0, 1073, 0, - 0, 0, 1073, 1074, 0, 1074, 0, 0, 0, 1074, - 1075, 0, 1075, 0, 0, 0, 1075, 1076, 0, 1076, - 0, 0, 0, 1076, 1077, 0, 1077, 0, 0, 0, - 1077, 1078, 0, 1078, 0, 0, 0, 1078, 1079, 0, - 1079, 0, 0, 0, 1079, 1080, 0, 1080, 0, 0, - 0, 1080, 1081, 0, 1081, 0, 0, 0, 1081, 1082, - 0, 1082, 0, 0, 0, 1082, 908, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908 - } ; - -/* Table of booleans, true if rule could match eol. */ -static yyconst flex_int32_t yy_rule_can_match_eol[187] = - { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1, 0, 0, 1, 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, }; - -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 : Tue Nov 29 11:32:00 2016 - * Update Count : 501 - */ -#line 20 "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 // FILENAME_MAX - -#include "lex.h" -#include "parser.h" // YACC generated definitions based on C++ grammar -#include "ParseNode.h" -#include "TypedefTable.h" - -char *yyfilename; -std::string *strtext; // accumulate parts of character and string constant value - -#define RETURN_LOCN(x) yylval.tok.loc.file = yyfilename; yylval.tok.loc.line = yylineno; return( x ) -#define RETURN_VAL(x) yylval.tok.str = new std::string( yytext ); RETURN_LOCN( x ) -#define RETURN_CHAR(x) yylval.tok.str = nullptr; RETURN_LOCN( x ) -#define RETURN_STR(x) yylval.tok.str = strtext; RETURN_LOCN( x ) - -#define WHITE_RETURN(x) // do nothing -#define NEWLINE_RETURN() WHITE_RETURN( '\n' ) -#define ASCIIOP_RETURN() RETURN_CHAR( (int)yytext[0] ) // single character operator -#define NAMEDOP_RETURN(x) RETURN_CHAR( x ) // multichar operator, with a name -#define NUMERIC_RETURN(x) rm_underscore(); RETURN_VAL( x ) // numeric constant -#define KEYWORD_RETURN(x) RETURN_CHAR( x ) // keyword -#define IDENTIFIER_RETURN() RETURN_VAL( typedefTable.isKind( yytext ) ) -#define ATTRIBUTE_RETURN() RETURN_VAL( ATTR_IDENTIFIER ) - -void rm_underscore() { - // Remove underscores in numeric constant by copying the non-underscore characters to the front of the string. - yyleng = 0; - for ( int i = 0; yytext[i] != '\0'; i += 1 ) { - if ( yytext[i] != '_' ) { - yytext[yyleng] = yytext[i]; - yyleng += 1; - } // if - } // for - yytext[yyleng] = '\0'; -} - -// identifier, GCC: $ in identifier -// attribute identifier, GCC: $ in identifier -// numeric constants, CFA: '_' in constant -// GCC: D (double), DL (long double) and iI (imaginary) suffixes -//floating_suffix "_"?([fFdD]|[lL]|[D][L])|([iI][lLfFdD])|([lLfFdD][iI])) -// character escape sequence, GCC: \e => esc character -// ' stop highlighting -// display/white-space characters -// overloadable operators -// op_binary_not_over "?"|"->"|"."|"&&"|"||"|"@=" -// operator {op_unary_pre_post}|{op_binary_over}|{op_binary_not_over} - - - - -#line 1551 "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 - -#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 138 "lex.ll" - - /* line directives */ -#line 1746 "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 >= 909 ) - 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] != 2877 ); - -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 140 "lex.ll" -{ - /* " stop highlighting */ - static char filename[FILENAME_MAX]; // temporarily store current source-file name - char *end_num; - char *begin_string, *end_string; - long lineno, length; - lineno = strtol( yytext + 1, &end_num, 0 ); - begin_string = strchr( end_num, '"' ); - if ( begin_string ) { // file name ? - end_string = strchr( begin_string + 1, '"' ); // look for ending delimiter - assert( end_string ); // closing quote ? - length = end_string - begin_string - 1; // file-name length without quotes or sentinel - assert( length < FILENAME_MAX ); // room for sentinel ? - memcpy( &filename, begin_string + 1, length ); // copy file name from yytext - filename[ length ] = '\0'; // terminate string with sentinel - //std::cout << "file " << filename << " line " << lineno << std::endl; - yylineno = lineno; - yyfilename = filename; - } // if -} - YY_BREAK -/* ignore preprocessor directives (for now) */ -case 2: -/* rule 2 can match eol */ -YY_RULE_SETUP -#line 162 "lex.ll" -; - YY_BREAK -/* ignore C style comments (ALSO HANDLED BY CPP) */ -case 3: -YY_RULE_SETUP -#line 165 "lex.ll" -{ BEGIN COMMENT; } - YY_BREAK -case 4: -/* rule 4 can match eol */ -YY_RULE_SETUP -#line 166 "lex.ll" -; - YY_BREAK -case 5: -YY_RULE_SETUP -#line 167 "lex.ll" -{ BEGIN 0; } - YY_BREAK -/* ignore C++ style comments (ALSO HANDLED BY CPP) */ -case 6: -/* rule 6 can match eol */ -YY_RULE_SETUP -#line 170 "lex.ll" -; - YY_BREAK -/* ignore whitespace */ -case 7: -YY_RULE_SETUP -#line 173 "lex.ll" -{ WHITE_RETURN(' '); } - YY_BREAK -case 8: -YY_RULE_SETUP -#line 174 "lex.ll" -{ WHITE_RETURN(' '); } - YY_BREAK -case 9: -/* rule 9 can match eol */ -YY_RULE_SETUP -#line 175 "lex.ll" -{ NEWLINE_RETURN(); } - YY_BREAK -/* keywords */ -case 10: -YY_RULE_SETUP -#line 178 "lex.ll" -{ KEYWORD_RETURN(ALIGNAS); } // C11 - YY_BREAK -case 11: -YY_RULE_SETUP -#line 179 "lex.ll" -{ KEYWORD_RETURN(ALIGNOF); } // C11 - YY_BREAK -case 12: -YY_RULE_SETUP -#line 180 "lex.ll" -{ KEYWORD_RETURN(ALIGNOF); } // GCC - YY_BREAK -case 13: -YY_RULE_SETUP -#line 181 "lex.ll" -{ KEYWORD_RETURN(ALIGNOF); } // GCC - YY_BREAK -case 14: -YY_RULE_SETUP -#line 182 "lex.ll" -{ KEYWORD_RETURN(ASM); } - YY_BREAK -case 15: -YY_RULE_SETUP -#line 183 "lex.ll" -{ KEYWORD_RETURN(ASM); } // GCC - YY_BREAK -case 16: -YY_RULE_SETUP -#line 184 "lex.ll" -{ KEYWORD_RETURN(ASM); } // GCC - YY_BREAK -case 17: -YY_RULE_SETUP -#line 185 "lex.ll" -{ KEYWORD_RETURN(AT); } // CFA - YY_BREAK -case 18: -YY_RULE_SETUP -#line 186 "lex.ll" -{ KEYWORD_RETURN(ATOMIC); } // C11 - YY_BREAK -case 19: -YY_RULE_SETUP -#line 187 "lex.ll" -{ KEYWORD_RETURN(ATTRIBUTE); } // GCC - YY_BREAK -case 20: -YY_RULE_SETUP -#line 188 "lex.ll" -{ KEYWORD_RETURN(ATTRIBUTE); } // GCC - YY_BREAK -case 21: -YY_RULE_SETUP -#line 189 "lex.ll" -{ KEYWORD_RETURN(AUTO); } - YY_BREAK -case 22: -YY_RULE_SETUP -#line 190 "lex.ll" -{ KEYWORD_RETURN(BOOL); } // C99 - YY_BREAK -case 23: -YY_RULE_SETUP -#line 191 "lex.ll" -{ KEYWORD_RETURN(BREAK); } - YY_BREAK -case 24: -YY_RULE_SETUP -#line 192 "lex.ll" -{ KEYWORD_RETURN(CASE); } - YY_BREAK -case 25: -YY_RULE_SETUP -#line 193 "lex.ll" -{ KEYWORD_RETURN(CATCH); } // CFA - YY_BREAK -case 26: -YY_RULE_SETUP -#line 194 "lex.ll" -{ KEYWORD_RETURN(CATCHRESUME); } // CFA - YY_BREAK -case 27: -YY_RULE_SETUP -#line 195 "lex.ll" -{ KEYWORD_RETURN(CHAR); } - YY_BREAK -case 28: -YY_RULE_SETUP -#line 196 "lex.ll" -{ KEYWORD_RETURN(CHOOSE); } // CFA - YY_BREAK -case 29: -YY_RULE_SETUP -#line 197 "lex.ll" -{ KEYWORD_RETURN(COMPLEX); } // C99 - YY_BREAK -case 30: -YY_RULE_SETUP -#line 198 "lex.ll" -{ KEYWORD_RETURN(COMPLEX); } // GCC - YY_BREAK -case 31: -YY_RULE_SETUP -#line 199 "lex.ll" -{ KEYWORD_RETURN(COMPLEX); } // GCC - YY_BREAK -case 32: -YY_RULE_SETUP -#line 200 "lex.ll" -{ KEYWORD_RETURN(CONST); } - YY_BREAK -case 33: -YY_RULE_SETUP -#line 201 "lex.ll" -{ KEYWORD_RETURN(CONST); } // GCC - YY_BREAK -case 34: -YY_RULE_SETUP -#line 202 "lex.ll" -{ KEYWORD_RETURN(CONST); } // GCC - YY_BREAK -case 35: -YY_RULE_SETUP -#line 203 "lex.ll" -{ KEYWORD_RETURN(CONTINUE); } - YY_BREAK -case 36: -YY_RULE_SETUP -#line 204 "lex.ll" -{ KEYWORD_RETURN(DEFAULT); } - YY_BREAK -case 37: -YY_RULE_SETUP -#line 205 "lex.ll" -{ KEYWORD_RETURN(DISABLE); } // CFA - YY_BREAK -case 38: -YY_RULE_SETUP -#line 206 "lex.ll" -{ KEYWORD_RETURN(DO); } - YY_BREAK -case 39: -YY_RULE_SETUP -#line 207 "lex.ll" -{ KEYWORD_RETURN(DOUBLE); } - YY_BREAK -case 40: -YY_RULE_SETUP -#line 208 "lex.ll" -{ KEYWORD_RETURN(DTYPE); } // CFA - YY_BREAK -case 41: -YY_RULE_SETUP -#line 209 "lex.ll" -{ KEYWORD_RETURN(ELSE); } - YY_BREAK -case 42: -YY_RULE_SETUP -#line 210 "lex.ll" -{ KEYWORD_RETURN(ENABLE); } // CFA - YY_BREAK -case 43: -YY_RULE_SETUP -#line 211 "lex.ll" -{ KEYWORD_RETURN(ENUM); } - YY_BREAK -case 44: -YY_RULE_SETUP -#line 212 "lex.ll" -{ KEYWORD_RETURN(EXTENSION); } // GCC - YY_BREAK -case 45: -YY_RULE_SETUP -#line 213 "lex.ll" -{ KEYWORD_RETURN(EXTERN); } - YY_BREAK -case 46: -YY_RULE_SETUP -#line 214 "lex.ll" -{ KEYWORD_RETURN(FALLTHRU); } // CFA - YY_BREAK -case 47: -YY_RULE_SETUP -#line 215 "lex.ll" -{ KEYWORD_RETURN(FALLTHRU); } // CFA - YY_BREAK -case 48: -YY_RULE_SETUP -#line 216 "lex.ll" -{ KEYWORD_RETURN(FINALLY); } // CFA - YY_BREAK -case 49: -YY_RULE_SETUP -#line 217 "lex.ll" -{ KEYWORD_RETURN(FLOAT); } - YY_BREAK -case 50: -YY_RULE_SETUP -#line 218 "lex.ll" -{ KEYWORD_RETURN(FLOAT); } // GCC - YY_BREAK -case 51: -YY_RULE_SETUP -#line 219 "lex.ll" -{ KEYWORD_RETURN(FOR); } - YY_BREAK -case 52: -YY_RULE_SETUP -#line 220 "lex.ll" -{ KEYWORD_RETURN(FORALL); } // CFA - YY_BREAK -case 53: -YY_RULE_SETUP -#line 221 "lex.ll" -{ KEYWORD_RETURN(FORTRAN); } - YY_BREAK -case 54: -YY_RULE_SETUP -#line 222 "lex.ll" -{ KEYWORD_RETURN(FTYPE); } // CFA - YY_BREAK -case 55: -YY_RULE_SETUP -#line 223 "lex.ll" -{ KEYWORD_RETURN(GENERIC); } // C11 - YY_BREAK -case 56: -YY_RULE_SETUP -#line 224 "lex.ll" -{ KEYWORD_RETURN(GOTO); } - YY_BREAK -case 57: -YY_RULE_SETUP -#line 225 "lex.ll" -{ KEYWORD_RETURN(IF); } - YY_BREAK -case 58: -YY_RULE_SETUP -#line 226 "lex.ll" -{ KEYWORD_RETURN(IMAGINARY); } // C99 - YY_BREAK -case 59: -YY_RULE_SETUP -#line 227 "lex.ll" -{ KEYWORD_RETURN(IMAGINARY); } // GCC - YY_BREAK -case 60: -YY_RULE_SETUP -#line 228 "lex.ll" -{ KEYWORD_RETURN(IMAGINARY); } // GCC - YY_BREAK -case 61: -YY_RULE_SETUP -#line 229 "lex.ll" -{ KEYWORD_RETURN(INLINE); } // C99 - YY_BREAK -case 62: -YY_RULE_SETUP -#line 230 "lex.ll" -{ KEYWORD_RETURN(INLINE); } // GCC - YY_BREAK -case 63: -YY_RULE_SETUP -#line 231 "lex.ll" -{ KEYWORD_RETURN(INLINE); } // GCC - YY_BREAK -case 64: -YY_RULE_SETUP -#line 232 "lex.ll" -{ KEYWORD_RETURN(INT); } - YY_BREAK -case 65: -YY_RULE_SETUP -#line 233 "lex.ll" -{ KEYWORD_RETURN(INT); } // GCC - YY_BREAK -case 66: -YY_RULE_SETUP -#line 234 "lex.ll" -{ KEYWORD_RETURN(LABEL); } // GCC - YY_BREAK -case 67: -YY_RULE_SETUP -#line 235 "lex.ll" -{ KEYWORD_RETURN(LONG); } - YY_BREAK -case 68: -YY_RULE_SETUP -#line 236 "lex.ll" -{ KEYWORD_RETURN(LVALUE); } // CFA - YY_BREAK -case 69: -YY_RULE_SETUP -#line 237 "lex.ll" -{ KEYWORD_RETURN(NORETURN); } // C11 - YY_BREAK -case 70: -YY_RULE_SETUP -#line 238 "lex.ll" -{ KEYWORD_RETURN(OFFSETOF); } // GCC - YY_BREAK -case 71: -YY_RULE_SETUP -#line 239 "lex.ll" -{ NUMERIC_RETURN(ONE_T); } // CFA - YY_BREAK -case 72: -YY_RULE_SETUP -#line 240 "lex.ll" -{ KEYWORD_RETURN(OTYPE); } // CFA - YY_BREAK -case 73: -YY_RULE_SETUP -#line 241 "lex.ll" -{ KEYWORD_RETURN(REGISTER); } - YY_BREAK -case 74: -YY_RULE_SETUP -#line 242 "lex.ll" -{ KEYWORD_RETURN(RESTRICT); } // C99 - YY_BREAK -case 75: -YY_RULE_SETUP -#line 243 "lex.ll" -{ KEYWORD_RETURN(RESTRICT); } // GCC - YY_BREAK -case 76: -YY_RULE_SETUP -#line 244 "lex.ll" -{ KEYWORD_RETURN(RESTRICT); } // GCC - YY_BREAK -case 77: -YY_RULE_SETUP -#line 245 "lex.ll" -{ KEYWORD_RETURN(RETURN); } - YY_BREAK -case 78: -YY_RULE_SETUP -#line 246 "lex.ll" -{ KEYWORD_RETURN(SHORT); } - YY_BREAK -case 79: -YY_RULE_SETUP -#line 247 "lex.ll" -{ KEYWORD_RETURN(SIGNED); } - YY_BREAK -case 80: -YY_RULE_SETUP -#line 248 "lex.ll" -{ KEYWORD_RETURN(SIGNED); } // GCC - YY_BREAK -case 81: -YY_RULE_SETUP -#line 249 "lex.ll" -{ KEYWORD_RETURN(SIGNED); } // GCC - YY_BREAK -case 82: -YY_RULE_SETUP -#line 250 "lex.ll" -{ KEYWORD_RETURN(SIZEOF); } - YY_BREAK -case 83: -YY_RULE_SETUP -#line 251 "lex.ll" -{ KEYWORD_RETURN(STATIC); } - YY_BREAK -case 84: -YY_RULE_SETUP -#line 252 "lex.ll" -{ KEYWORD_RETURN(STATICASSERT); } // C11 - YY_BREAK -case 85: -YY_RULE_SETUP -#line 253 "lex.ll" -{ KEYWORD_RETURN(STRUCT); } - YY_BREAK -case 86: -YY_RULE_SETUP -#line 254 "lex.ll" -{ KEYWORD_RETURN(SWITCH); } - YY_BREAK -case 87: -YY_RULE_SETUP -#line 255 "lex.ll" -{ KEYWORD_RETURN(THREADLOCAL); } // C11 - YY_BREAK -case 88: -YY_RULE_SETUP -#line 256 "lex.ll" -{ KEYWORD_RETURN(THROW); } // CFA - YY_BREAK -case 89: -YY_RULE_SETUP -#line 257 "lex.ll" -{ KEYWORD_RETURN(THROWRESUME); } // CFA - YY_BREAK -case 90: -YY_RULE_SETUP -#line 258 "lex.ll" -{ KEYWORD_RETURN(TRAIT); } // CFA - YY_BREAK -case 91: -YY_RULE_SETUP -#line 259 "lex.ll" -{ KEYWORD_RETURN(TRY); } // CFA - YY_BREAK -case 92: -YY_RULE_SETUP -#line 260 "lex.ll" -{ KEYWORD_RETURN(TTYPE); } // CFA - YY_BREAK -case 93: -YY_RULE_SETUP -#line 261 "lex.ll" -{ KEYWORD_RETURN(TYPEDEF); } - YY_BREAK -case 94: -YY_RULE_SETUP -#line 262 "lex.ll" -{ KEYWORD_RETURN(TYPEOF); } // GCC - YY_BREAK -case 95: -YY_RULE_SETUP -#line 263 "lex.ll" -{ KEYWORD_RETURN(TYPEOF); } // GCC - YY_BREAK -case 96: -YY_RULE_SETUP -#line 264 "lex.ll" -{ KEYWORD_RETURN(TYPEOF); } // GCC - YY_BREAK -case 97: -YY_RULE_SETUP -#line 265 "lex.ll" -{ KEYWORD_RETURN(UNION); } - YY_BREAK -case 98: -YY_RULE_SETUP -#line 266 "lex.ll" -{ KEYWORD_RETURN(UNSIGNED); } - YY_BREAK -case 99: -YY_RULE_SETUP -#line 267 "lex.ll" -{ KEYWORD_RETURN(VALIST); } // GCC - YY_BREAK -case 100: -YY_RULE_SETUP -#line 268 "lex.ll" -{ KEYWORD_RETURN(VOID); } - YY_BREAK -case 101: -YY_RULE_SETUP -#line 269 "lex.ll" -{ KEYWORD_RETURN(VOLATILE); } - YY_BREAK -case 102: -YY_RULE_SETUP -#line 270 "lex.ll" -{ KEYWORD_RETURN(VOLATILE); } // GCC - YY_BREAK -case 103: -YY_RULE_SETUP -#line 271 "lex.ll" -{ KEYWORD_RETURN(VOLATILE); } // GCC - YY_BREAK -case 104: -YY_RULE_SETUP -#line 272 "lex.ll" -{ KEYWORD_RETURN(WHILE); } - YY_BREAK -case 105: -YY_RULE_SETUP -#line 273 "lex.ll" -{ NUMERIC_RETURN(ZERO_T); } // CFA - YY_BREAK -/* identifier */ -case 106: -YY_RULE_SETUP -#line 276 "lex.ll" -{ IDENTIFIER_RETURN(); } - YY_BREAK -case 107: -YY_RULE_SETUP -#line 277 "lex.ll" -{ ATTRIBUTE_RETURN(); } - YY_BREAK -case 108: -YY_RULE_SETUP -#line 278 "lex.ll" -{ BEGIN BKQUOTE; } - YY_BREAK -case 109: -YY_RULE_SETUP -#line 279 "lex.ll" -{ IDENTIFIER_RETURN(); } - YY_BREAK -case 110: -YY_RULE_SETUP -#line 280 "lex.ll" -{ BEGIN 0; } - YY_BREAK -/* numeric constants */ -case 111: -YY_RULE_SETUP -#line 283 "lex.ll" -{ NUMERIC_RETURN(ZERO); } // CFA - YY_BREAK -case 112: -YY_RULE_SETUP -#line 284 "lex.ll" -{ NUMERIC_RETURN(ONE); } // CFA - YY_BREAK -case 113: -YY_RULE_SETUP -#line 285 "lex.ll" -{ NUMERIC_RETURN(INTEGERconstant); } - YY_BREAK -case 114: -YY_RULE_SETUP -#line 286 "lex.ll" -{ NUMERIC_RETURN(INTEGERconstant); } - YY_BREAK -case 115: -YY_RULE_SETUP -#line 287 "lex.ll" -{ NUMERIC_RETURN(INTEGERconstant); } - YY_BREAK -case 116: -YY_RULE_SETUP -#line 288 "lex.ll" -{ NUMERIC_RETURN(REALDECIMALconstant); } // must appear before floating_constant - YY_BREAK -case 117: -YY_RULE_SETUP -#line 289 "lex.ll" -{ NUMERIC_RETURN(REALFRACTIONconstant); } // must appear before floating_constant - YY_BREAK -case 118: -YY_RULE_SETUP -#line 290 "lex.ll" -{ NUMERIC_RETURN(FLOATINGconstant); } - YY_BREAK -case 119: -YY_RULE_SETUP -#line 291 "lex.ll" -{ NUMERIC_RETURN(FLOATINGconstant); } - YY_BREAK -/* character constant, allows empty value */ -case 120: -YY_RULE_SETUP -#line 294 "lex.ll" -{ BEGIN QUOTE; rm_underscore(); strtext = new std::string( yytext, yyleng ); } - YY_BREAK -case 121: -YY_RULE_SETUP -#line 295 "lex.ll" -{ strtext->append( yytext, yyleng ); } - YY_BREAK -case 122: -/* rule 122 can match eol */ -YY_RULE_SETUP -#line 296 "lex.ll" -{ BEGIN 0; strtext->append( yytext, yyleng ); RETURN_STR(CHARACTERconstant); } - YY_BREAK -/* ' stop highlighting */ -/* string constant */ -case 123: -YY_RULE_SETUP -#line 300 "lex.ll" -{ BEGIN STRING; rm_underscore(); strtext = new std::string( yytext, yyleng ); } - YY_BREAK -case 124: -YY_RULE_SETUP -#line 301 "lex.ll" -{ strtext->append( yytext, yyleng ); } - YY_BREAK -case 125: -/* rule 125 can match eol */ -YY_RULE_SETUP -#line 302 "lex.ll" -{ BEGIN 0; strtext->append( yytext, yyleng ); RETURN_STR(STRINGliteral); } - YY_BREAK -/* " stop highlighting */ -/* common character/string constant */ -case 126: -YY_RULE_SETUP -#line 306 "lex.ll" -{ rm_underscore(); strtext->append( yytext, yyleng ); } - YY_BREAK -case 127: -/* rule 127 can match eol */ -YY_RULE_SETUP -#line 307 "lex.ll" -{} // continuation (ALSO HANDLED BY CPP) - YY_BREAK -case 128: -YY_RULE_SETUP -#line 308 "lex.ll" -{ strtext->append( yytext, yyleng ); } // unknown escape character - YY_BREAK -/* punctuation */ -case 129: -YY_RULE_SETUP -#line 311 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 130: -YY_RULE_SETUP -#line 312 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 131: -YY_RULE_SETUP -#line 313 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 132: -YY_RULE_SETUP -#line 314 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 133: -YY_RULE_SETUP -#line 315 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 134: -YY_RULE_SETUP -#line 316 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 135: -YY_RULE_SETUP -#line 317 "lex.ll" -{ ASCIIOP_RETURN(); } // also operator - YY_BREAK -case 136: -YY_RULE_SETUP -#line 318 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 137: -YY_RULE_SETUP -#line 319 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 138: -YY_RULE_SETUP -#line 320 "lex.ll" -{ ASCIIOP_RETURN(); } // also operator - YY_BREAK -case 139: -YY_RULE_SETUP -#line 321 "lex.ll" -{ NAMEDOP_RETURN(ELLIPSIS); } - YY_BREAK -/* alternative C99 brackets, "<:" & "<:<:" handled by preprocessor */ -case 140: -YY_RULE_SETUP -#line 324 "lex.ll" -{ RETURN_VAL('['); } - YY_BREAK -case 141: -YY_RULE_SETUP -#line 325 "lex.ll" -{ RETURN_VAL(']'); } - YY_BREAK -case 142: -YY_RULE_SETUP -#line 326 "lex.ll" -{ RETURN_VAL('{'); } - YY_BREAK -case 143: -YY_RULE_SETUP -#line 327 "lex.ll" -{ RETURN_VAL('}'); } - YY_BREAK -/* operators */ -case 144: -YY_RULE_SETUP -#line 330 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 145: -YY_RULE_SETUP -#line 331 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 146: -YY_RULE_SETUP -#line 332 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 147: -YY_RULE_SETUP -#line 333 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 148: -YY_RULE_SETUP -#line 334 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 149: -YY_RULE_SETUP -#line 335 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 150: -YY_RULE_SETUP -#line 336 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 151: -YY_RULE_SETUP -#line 337 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 152: -YY_RULE_SETUP -#line 338 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 153: -YY_RULE_SETUP -#line 339 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 154: -YY_RULE_SETUP -#line 340 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 155: -YY_RULE_SETUP -#line 341 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 156: -YY_RULE_SETUP -#line 342 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 157: -YY_RULE_SETUP -#line 343 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 158: -YY_RULE_SETUP -#line 345 "lex.ll" -{ NAMEDOP_RETURN(ICR); } - YY_BREAK -case 159: -YY_RULE_SETUP -#line 346 "lex.ll" -{ NAMEDOP_RETURN(DECR); } - YY_BREAK -case 160: -YY_RULE_SETUP -#line 347 "lex.ll" -{ NAMEDOP_RETURN(EQ); } - YY_BREAK -case 161: -YY_RULE_SETUP -#line 348 "lex.ll" -{ NAMEDOP_RETURN(NE); } - YY_BREAK -case 162: -YY_RULE_SETUP -#line 349 "lex.ll" -{ NAMEDOP_RETURN(LS); } - YY_BREAK -case 163: -YY_RULE_SETUP -#line 350 "lex.ll" -{ NAMEDOP_RETURN(RS); } - YY_BREAK -case 164: -YY_RULE_SETUP -#line 351 "lex.ll" -{ NAMEDOP_RETURN(LE); } - YY_BREAK -case 165: -YY_RULE_SETUP -#line 352 "lex.ll" -{ NAMEDOP_RETURN(GE); } - YY_BREAK -case 166: -YY_RULE_SETUP -#line 353 "lex.ll" -{ NAMEDOP_RETURN(ANDAND); } - YY_BREAK -case 167: -YY_RULE_SETUP -#line 354 "lex.ll" -{ NAMEDOP_RETURN(OROR); } - YY_BREAK -case 168: -YY_RULE_SETUP -#line 355 "lex.ll" -{ NAMEDOP_RETURN(ARROW); } - YY_BREAK -case 169: -YY_RULE_SETUP -#line 356 "lex.ll" -{ NAMEDOP_RETURN(PLUSassign); } - YY_BREAK -case 170: -YY_RULE_SETUP -#line 357 "lex.ll" -{ NAMEDOP_RETURN(MINUSassign); } - YY_BREAK -case 171: -YY_RULE_SETUP -#line 358 "lex.ll" -{ NAMEDOP_RETURN(MULTassign); } - YY_BREAK -case 172: -YY_RULE_SETUP -#line 359 "lex.ll" -{ NAMEDOP_RETURN(DIVassign); } - YY_BREAK -case 173: -YY_RULE_SETUP -#line 360 "lex.ll" -{ NAMEDOP_RETURN(MODassign); } - YY_BREAK -case 174: -YY_RULE_SETUP -#line 361 "lex.ll" -{ NAMEDOP_RETURN(ANDassign); } - YY_BREAK -case 175: -YY_RULE_SETUP -#line 362 "lex.ll" -{ NAMEDOP_RETURN(ORassign); } - YY_BREAK -case 176: -YY_RULE_SETUP -#line 363 "lex.ll" -{ NAMEDOP_RETURN(ERassign); } - YY_BREAK -case 177: -YY_RULE_SETUP -#line 364 "lex.ll" -{ NAMEDOP_RETURN(LSassign); } - YY_BREAK -case 178: -YY_RULE_SETUP -#line 365 "lex.ll" -{ NAMEDOP_RETURN(RSassign); } - YY_BREAK -case 179: -YY_RULE_SETUP -#line 367 "lex.ll" -{ NAMEDOP_RETURN(ATassign); } // CFA - YY_BREAK -/* CFA, operator identifier */ -case 180: -YY_RULE_SETUP -#line 370 "lex.ll" -{ IDENTIFIER_RETURN(); } // unary - YY_BREAK -case 181: -YY_RULE_SETUP -#line 371 "lex.ll" -{ IDENTIFIER_RETURN(); } - YY_BREAK -case 182: -YY_RULE_SETUP -#line 372 "lex.ll" -{ IDENTIFIER_RETURN(); } - YY_BREAK -case 183: -YY_RULE_SETUP -#line 373 "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 184: -YY_RULE_SETUP -#line 400 "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 185: -YY_RULE_SETUP -#line 412 "lex.ll" -{ printf("unknown character(s):\"%s\" on line %d\n", yytext, yylineno); } - YY_BREAK -case 186: -YY_RULE_SETUP -#line 414 "lex.ll" -ECHO; - YY_BREAK -#line 2849 "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 >= 909 ) - 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 >= 909 ) - 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 == 908); - - return yy_is_jam ? 0 : yy_current_state; -} - -#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 414 "lex.ll" - - - -// Local Variables: // -// mode: c++ // -// tab-width: 4 // -// compile-command: "make install" // -// End: // - Index: src/Parser/lex.ll =================================================================== --- src/Parser/lex.ll (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/Parser/lex.ll (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ * Created On : Sat Sep 22 08:58:10 2001 * Last Modified By : Peter A. Buhr - * Last Modified On : Tue Nov 29 11:32:00 2016 - * Update Count : 501 + * Last Modified On : Fri Mar 3 22:18:00 2017 + * Update Count : 502 */ @@ -235,4 +235,5 @@ long { KEYWORD_RETURN(LONG); } lvalue { KEYWORD_RETURN(LVALUE); } // CFA +mutex { KEYWORD_RETURN(MUTEX); } // CFA _Noreturn { KEYWORD_RETURN(NORETURN); } // C11 __builtin_offsetof { KEYWORD_RETURN(OFFSETOF); } // GCC Index: src/Parser/parser.cc =================================================================== --- src/Parser/parser.cc (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ (revision ) @@ -1,9821 +1,0 @@ -/* 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 42 "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 "lex.h" -#include "parser.h" -#include "ParseNode.h" -#include "TypedefTable.h" -#include "TypeData.h" -#include "LinkageSpec.h" -using namespace std; - -extern DeclarationNode * parseTree; -extern LinkageSpec::Spec linkage; -extern TypedefTable typedefTable; - -stack< LinkageSpec::Spec > linkageStack; - -void appendStr( string *to, string *from ) { - // "abc" "def" "ghi" => "abcdefghi", remove new text from quotes and insert before last quote in old string. - to->insert( to->length() - 1, from->substr( 1, from->length() - 2 ) ); -} // appendStr - -DeclarationNode * distAttr( DeclarationNode * specifier, DeclarationNode * declList ) { - // distribute declaration_specifier across all declared variables, e.g., static, const, __attribute__. - DeclarationNode * cur = declList, * cl = (new DeclarationNode)->addType( specifier ); - //cur->addType( specifier ); - for ( cur = dynamic_cast< DeclarationNode * >( cur->get_next() ); cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ) ) { - cl->cloneBaseType( cur ); - } // for - declList->addType( cl ); -// delete cl; - return declList; -} // distAttr - -void distExt( DeclarationNode * declaration ) { - // distribute EXTENSION across all declarations - for ( DeclarationNode *iter = declaration; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) { - iter->set_extension( true ); - } // for -} // distExt - - -/* Line 268 of yacc.c */ -#line 119 "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, - ZERO_T = 279, - ONE_T = 280, - VALIST = 281, - BOOL = 282, - COMPLEX = 283, - IMAGINARY = 284, - TYPEOF = 285, - LABEL = 286, - ENUM = 287, - STRUCT = 288, - UNION = 289, - OTYPE = 290, - FTYPE = 291, - DTYPE = 292, - TTYPE = 293, - TRAIT = 294, - SIZEOF = 295, - OFFSETOF = 296, - ATTRIBUTE = 297, - EXTENSION = 298, - IF = 299, - ELSE = 300, - SWITCH = 301, - CASE = 302, - DEFAULT = 303, - DO = 304, - WHILE = 305, - FOR = 306, - BREAK = 307, - CONTINUE = 308, - GOTO = 309, - RETURN = 310, - CHOOSE = 311, - DISABLE = 312, - ENABLE = 313, - FALLTHRU = 314, - TRY = 315, - CATCH = 316, - CATCHRESUME = 317, - FINALLY = 318, - THROW = 319, - THROWRESUME = 320, - AT = 321, - ASM = 322, - ALIGNAS = 323, - ALIGNOF = 324, - ATOMIC = 325, - GENERIC = 326, - NORETURN = 327, - STATICASSERT = 328, - THREADLOCAL = 329, - IDENTIFIER = 330, - QUOTED_IDENTIFIER = 331, - TYPEDEFname = 332, - TYPEGENname = 333, - ATTR_IDENTIFIER = 334, - ATTR_TYPEDEFname = 335, - ATTR_TYPEGENname = 336, - INTEGERconstant = 337, - CHARACTERconstant = 338, - STRINGliteral = 339, - REALDECIMALconstant = 340, - REALFRACTIONconstant = 341, - FLOATINGconstant = 342, - ZERO = 343, - ONE = 344, - ARROW = 345, - ICR = 346, - DECR = 347, - LS = 348, - RS = 349, - LE = 350, - GE = 351, - EQ = 352, - NE = 353, - ANDAND = 354, - OROR = 355, - ELLIPSIS = 356, - MULTassign = 357, - DIVassign = 358, - MODassign = 359, - PLUSassign = 360, - MINUSassign = 361, - LSassign = 362, - RSassign = 363, - ANDassign = 364, - ERassign = 365, - ORassign = 366, - ATassign = 367, - THEN = 368 - }; -#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 ZERO_T 279 -#define ONE_T 280 -#define VALIST 281 -#define BOOL 282 -#define COMPLEX 283 -#define IMAGINARY 284 -#define TYPEOF 285 -#define LABEL 286 -#define ENUM 287 -#define STRUCT 288 -#define UNION 289 -#define OTYPE 290 -#define FTYPE 291 -#define DTYPE 292 -#define TTYPE 293 -#define TRAIT 294 -#define SIZEOF 295 -#define OFFSETOF 296 -#define ATTRIBUTE 297 -#define EXTENSION 298 -#define IF 299 -#define ELSE 300 -#define SWITCH 301 -#define CASE 302 -#define DEFAULT 303 -#define DO 304 -#define WHILE 305 -#define FOR 306 -#define BREAK 307 -#define CONTINUE 308 -#define GOTO 309 -#define RETURN 310 -#define CHOOSE 311 -#define DISABLE 312 -#define ENABLE 313 -#define FALLTHRU 314 -#define TRY 315 -#define CATCH 316 -#define CATCHRESUME 317 -#define FINALLY 318 -#define THROW 319 -#define THROWRESUME 320 -#define AT 321 -#define ASM 322 -#define ALIGNAS 323 -#define ALIGNOF 324 -#define ATOMIC 325 -#define GENERIC 326 -#define NORETURN 327 -#define STATICASSERT 328 -#define THREADLOCAL 329 -#define IDENTIFIER 330 -#define QUOTED_IDENTIFIER 331 -#define TYPEDEFname 332 -#define TYPEGENname 333 -#define ATTR_IDENTIFIER 334 -#define ATTR_TYPEDEFname 335 -#define ATTR_TYPEGENname 336 -#define INTEGERconstant 337 -#define CHARACTERconstant 338 -#define STRINGliteral 339 -#define REALDECIMALconstant 340 -#define REALFRACTIONconstant 341 -#define FLOATINGconstant 342 -#define ZERO 343 -#define ONE 344 -#define ARROW 345 -#define ICR 346 -#define DECR 347 -#define LS 348 -#define RS 349 -#define LE 350 -#define GE 351 -#define EQ 352 -#define NE 353 -#define ANDAND 354 -#define OROR 355 -#define ELLIPSIS 356 -#define MULTassign 357 -#define DIVassign 358 -#define MODassign 359 -#define PLUSassign 360 -#define MINUSassign 361 -#define LSassign 362 -#define RSassign 363 -#define ANDassign 364 -#define ERassign 365 -#define ORassign 366 -#define ATassign 367 -#define THEN 368 - - - - -#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED -typedef union YYSTYPE -{ - -/* Line 293 of yacc.c */ -#line 139 "parser.yy" - - Token tok; - ParseNode * pn; - ExpressionNode * en; - DeclarationNode * decl; - DeclarationNode::Aggregate aggKey; - DeclarationNode::TypeClass tclass; - StatementNode * sn; - ConstantExpr * constant; - ForCtl * fctl; - LabelNode * label; - InitializerNode * in; - OperKinds op; - std::string * str; - bool flag; - - - -/* Line 293 of yacc.c */ -#line 400 "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 412 "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 240 -/* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 11898 - -/* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 138 -/* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 249 -/* YYNRULES -- Number of rules. */ -#define YYNRULES 775 -/* YYNRULES -- Number of states. */ -#define YYNSTATES 1582 - -/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ -#define YYUNDEFTOK 2 -#define YYMAXUTOK 368 - -#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, 126, 2, 2, 2, 129, 123, 2, - 114, 115, 122, 124, 121, 125, 118, 128, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 135, 137, - 130, 136, 131, 134, 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, 116, 2, 117, 132, 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, 119, 133, 120, 127, 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, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113 -}; - -#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, 31, 33, 35, - 37, 40, 42, 44, 46, 50, 54, 56, 63, 68, - 72, 80, 83, 87, 95, 98, 101, 109, 114, 116, - 120, 121, 123, 125, 129, 131, 134, 141, 145, 153, - 157, 165, 168, 171, 174, 175, 178, 180, 182, 184, - 187, 190, 193, 196, 199, 202, 207, 210, 215, 222, - 224, 229, 234, 236, 238, 240, 242, 244, 246, 248, - 253, 255, 259, 263, 267, 269, 273, 277, 279, 283, - 287, 289, 293, 297, 301, 305, 307, 311, 315, 317, - 321, 323, 327, 329, 333, 335, 339, 341, 345, 347, - 353, 358, 360, 362, 366, 367, 369, 371, 373, 375, - 377, 379, 381, 383, 385, 387, 389, 391, 393, 400, - 408, 410, 414, 416, 420, 421, 423, 425, 427, 429, - 431, 433, 435, 437, 439, 446, 451, 454, 462, 464, - 468, 470, 473, 475, 478, 481, 483, 486, 489, 495, - 503, 509, 519, 525, 535, 537, 541, 543, 545, 549, - 553, 556, 558, 561, 564, 565, 567, 570, 574, 575, - 577, 580, 584, 588, 593, 594, 596, 598, 601, 607, - 615, 622, 629, 634, 638, 643, 646, 650, 653, 657, - 661, 665, 669, 675, 679, 683, 688, 690, 696, 703, - 709, 716, 726, 737, 747, 758, 761, 763, 766, 769, - 772, 774, 781, 790, 801, 814, 829, 830, 832, 833, - 835, 837, 841, 846, 854, 855, 857, 861, 863, 867, - 869, 871, 873, 877, 879, 881, 883, 887, 888, 890, - 894, 899, 901, 905, 907, 909, 913, 917, 921, 925, - 929, 932, 936, 943, 947, 951, 956, 958, 961, 964, - 968, 974, 982, 990, 996, 1006, 1009, 1012, 1018, 1022, - 1028, 1033, 1037, 1042, 1047, 1055, 1060, 1064, 1068, 1072, - 1076, 1083, 1085, 1087, 1089, 1091, 1093, 1095, 1097, 1099, - 1101, 1103, 1105, 1107, 1109, 1111, 1113, 1115, 1116, 1118, - 1120, 1123, 1125, 1127, 1129, 1131, 1133, 1135, 1137, 1138, - 1144, 1146, 1149, 1153, 1155, 1158, 1160, 1162, 1164, 1166, - 1168, 1170, 1172, 1174, 1176, 1178, 1180, 1182, 1184, 1186, - 1188, 1190, 1192, 1194, 1196, 1198, 1200, 1202, 1204, 1206, - 1209, 1212, 1216, 1220, 1222, 1226, 1228, 1231, 1234, 1237, - 1242, 1247, 1252, 1257, 1259, 1262, 1265, 1269, 1271, 1274, - 1277, 1279, 1282, 1285, 1289, 1291, 1294, 1297, 1299, 1302, - 1305, 1309, 1311, 1314, 1317, 1319, 1321, 1323, 1325, 1331, - 1332, 1340, 1349, 1351, 1355, 1359, 1361, 1363, 1364, 1367, - 1370, 1374, 1378, 1383, 1385, 1388, 1392, 1395, 1397, 1402, - 1403, 1405, 1408, 1411, 1413, 1414, 1416, 1419, 1426, 1427, - 1436, 1438, 1442, 1445, 1450, 1451, 1454, 1455, 1457, 1459, - 1461, 1467, 1473, 1479, 1481, 1487, 1493, 1503, 1505, 1511, - 1512, 1514, 1516, 1522, 1524, 1526, 1532, 1538, 1540, 1544, - 1548, 1553, 1555, 1557, 1559, 1561, 1564, 1566, 1570, 1574, - 1577, 1581, 1583, 1587, 1589, 1591, 1593, 1595, 1597, 1599, - 1601, 1603, 1605, 1607, 1609, 1612, 1614, 1616, 1617, 1620, - 1623, 1625, 1630, 1631, 1633, 1636, 1640, 1645, 1648, 1651, - 1653, 1656, 1659, 1665, 1671, 1679, 1686, 1688, 1691, 1694, - 1698, 1700, 1703, 1706, 1711, 1714, 1719, 1720, 1725, 1728, - 1730, 1732, 1734, 1736, 1737, 1740, 1746, 1752, 1766, 1768, - 1770, 1774, 1778, 1781, 1785, 1789, 1792, 1797, 1799, 1806, - 1816, 1817, 1829, 1831, 1835, 1839, 1843, 1845, 1847, 1853, - 1856, 1862, 1863, 1865, 1867, 1871, 1872, 1874, 1876, 1878, - 1884, 1885, 1892, 1895, 1897, 1900, 1905, 1908, 1912, 1916, - 1920, 1925, 1931, 1937, 1943, 1950, 1952, 1954, 1956, 1960, - 1961, 1967, 1968, 1970, 1972, 1975, 1982, 1984, 1988, 1989, - 1991, 1996, 1998, 2000, 2002, 2004, 2007, 2009, 2012, 2015, - 2017, 2021, 2024, 2028, 2033, 2036, 2041, 2046, 2050, 2059, - 2063, 2066, 2068, 2071, 2078, 2087, 2091, 2094, 2098, 2102, - 2107, 2112, 2116, 2118, 2120, 2122, 2127, 2136, 2140, 2143, - 2147, 2151, 2156, 2161, 2165, 2168, 2170, 2173, 2176, 2178, - 2182, 2185, 2189, 2194, 2197, 2202, 2207, 2211, 2218, 2227, - 2231, 2234, 2236, 2239, 2242, 2245, 2249, 2254, 2257, 2262, - 2267, 2271, 2278, 2287, 2291, 2294, 2296, 2299, 2302, 2304, - 2306, 2309, 2313, 2318, 2321, 2326, 2333, 2342, 2344, 2347, - 2350, 2352, 2355, 2358, 2362, 2367, 2369, 2374, 2379, 2383, - 2389, 2398, 2402, 2405, 2409, 2411, 2417, 2423, 2430, 2437, - 2439, 2442, 2445, 2447, 2450, 2453, 2457, 2462, 2464, 2469, - 2474, 2478, 2484, 2493, 2497, 2499, 2502, 2504, 2507, 2514, - 2520, 2527, 2535, 2543, 2545, 2548, 2551, 2553, 2556, 2559, - 2563, 2568, 2570, 2575, 2580, 2584, 2593, 2597, 2599, 2601, - 2604, 2606, 2608, 2611, 2615, 2618, 2622, 2625, 2629, 2633, - 2636, 2641, 2645, 2648, 2652, 2655, 2660, 2664, 2667, 2674, - 2681, 2688, 2696, 2698, 2701, 2703, 2705, 2707, 2710, 2714, - 2717, 2721, 2724, 2728, 2732, 2737, 2740, 2744, 2749, 2752, - 2758, 2765, 2772, 2773, 2775, 2776 -}; - -/* YYRHS -- A `-1'-separated list of the rules' RHS. */ -static const yytype_int16 yyrhs[] = -{ - 315, 0, -1, -1, -1, 82, -1, 85, -1, 86, - -1, 87, -1, 83, -1, 75, -1, 79, -1, 145, - -1, 75, -1, 79, -1, 75, -1, 145, -1, 88, - -1, 89, -1, 147, -1, 84, -1, 147, 84, -1, - 75, -1, 145, -1, 175, -1, 114, 177, 115, -1, - 114, 181, 115, -1, 148, -1, 149, 116, 139, 172, - 140, 117, -1, 149, 114, 150, 115, -1, 149, 118, - 144, -1, 149, 118, 116, 139, 152, 140, 117, -1, - 149, 86, -1, 149, 90, 144, -1, 149, 90, 116, - 139, 152, 140, 117, -1, 149, 91, -1, 149, 92, - -1, 114, 288, 115, 119, 292, 385, 120, -1, 149, - 119, 150, 120, -1, 151, -1, 150, 121, 151, -1, - -1, 172, -1, 153, -1, 152, 121, 153, -1, 154, - -1, 85, 153, -1, 85, 116, 139, 152, 140, 117, - -1, 154, 118, 153, -1, 154, 118, 116, 139, 152, - 140, 117, -1, 154, 90, 153, -1, 154, 90, 116, - 139, 152, 140, 117, -1, 82, 155, -1, 87, 155, - -1, 144, 155, -1, -1, 155, 86, -1, 149, -1, - 141, -1, 146, -1, 43, 159, -1, 157, 159, -1, - 158, 159, -1, 91, 156, -1, 92, 156, -1, 40, - 156, -1, 40, 114, 288, 115, -1, 69, 156, -1, - 69, 114, 288, 115, -1, 41, 114, 288, 121, 144, - 115, -1, 79, -1, 79, 114, 151, 115, -1, 79, - 114, 289, 115, -1, 122, -1, 123, -1, 124, -1, - 125, -1, 126, -1, 127, -1, 156, -1, 114, 288, - 115, 159, -1, 159, -1, 160, 122, 159, -1, 160, - 128, 159, -1, 160, 129, 159, -1, 160, -1, 161, - 124, 160, -1, 161, 125, 160, -1, 161, -1, 162, - 93, 161, -1, 162, 94, 161, -1, 162, -1, 163, - 130, 162, -1, 163, 131, 162, -1, 163, 95, 162, - -1, 163, 96, 162, -1, 163, -1, 164, 97, 163, - -1, 164, 98, 163, -1, 164, -1, 165, 123, 164, - -1, 165, -1, 166, 132, 165, -1, 166, -1, 167, - 133, 166, -1, 167, -1, 168, 99, 167, -1, 168, - -1, 169, 100, 168, -1, 169, -1, 169, 134, 177, - 135, 170, -1, 169, 134, 135, 170, -1, 170, -1, - 170, -1, 156, 174, 172, -1, -1, 172, -1, 136, - -1, 112, -1, 102, -1, 103, -1, 104, -1, 105, - -1, 106, -1, 107, -1, 108, -1, 109, -1, 110, - -1, 111, -1, 116, 139, 121, 176, 140, 117, -1, - 116, 139, 172, 121, 176, 140, 117, -1, 173, -1, - 176, 121, 173, -1, 172, -1, 177, 121, 172, -1, - -1, 177, -1, 180, -1, 181, -1, 185, -1, 186, - -1, 198, -1, 200, -1, 201, -1, 206, -1, 132, - 149, 119, 150, 120, 137, -1, 285, 135, 325, 179, - -1, 119, 120, -1, 119, 139, 139, 217, 182, 140, - 120, -1, 183, -1, 182, 139, 183, -1, 220, -1, - 43, 220, -1, 321, -1, 43, 321, -1, 179, 140, - -1, 179, -1, 184, 179, -1, 178, 137, -1, 44, - 114, 177, 115, 179, -1, 44, 114, 177, 115, 179, - 45, 179, -1, 46, 114, 177, 115, 191, -1, 46, - 114, 177, 115, 119, 139, 213, 192, 120, -1, 56, - 114, 177, 115, 191, -1, 56, 114, 177, 115, 119, - 139, 213, 194, 120, -1, 171, -1, 171, 101, 171, - -1, 323, -1, 187, -1, 188, 121, 187, -1, 47, - 188, 135, -1, 48, 135, -1, 189, -1, 190, 189, - -1, 190, 179, -1, -1, 193, -1, 190, 184, -1, - 193, 190, 184, -1, -1, 195, -1, 190, 197, -1, - 190, 184, 196, -1, 195, 190, 197, -1, 195, 190, - 184, 196, -1, -1, 197, -1, 59, -1, 59, 137, - -1, 50, 114, 177, 115, 179, -1, 49, 179, 50, - 114, 177, 115, 137, -1, 51, 114, 139, 199, 115, - 179, -1, 178, 140, 137, 178, 137, 178, -1, 220, - 178, 137, 178, -1, 54, 285, 137, -1, 54, 122, - 177, 137, -1, 53, 137, -1, 53, 285, 137, -1, - 52, 137, -1, 52, 285, 137, -1, 55, 178, 137, - -1, 64, 173, 137, -1, 65, 173, 137, -1, 65, - 173, 66, 172, 137, -1, 60, 181, 202, -1, 60, - 181, 204, -1, 60, 181, 202, 204, -1, 203, -1, - 61, 114, 101, 115, 181, -1, 203, 61, 114, 101, - 115, 181, -1, 62, 114, 101, 115, 181, -1, 203, - 62, 114, 101, 115, 181, -1, 61, 114, 139, 139, - 205, 140, 115, 181, 140, -1, 203, 61, 114, 139, - 139, 205, 140, 115, 181, 140, -1, 62, 114, 139, - 139, 205, 140, 115, 181, 140, -1, 203, 62, 114, - 139, 139, 205, 140, 115, 181, 140, -1, 63, 181, - -1, 235, -1, 235, 322, -1, 235, 370, -1, 379, - 144, -1, 379, -1, 67, 207, 114, 146, 115, 137, - -1, 67, 207, 114, 146, 135, 208, 115, 137, -1, - 67, 207, 114, 146, 135, 208, 135, 208, 115, 137, - -1, 67, 207, 114, 146, 135, 208, 135, 208, 135, - 211, 115, 137, -1, 67, 207, 54, 114, 146, 135, - 135, 208, 135, 211, 135, 212, 115, 137, -1, -1, - 11, -1, -1, 209, -1, 210, -1, 209, 121, 210, - -1, 146, 114, 171, 115, -1, 116, 171, 117, 146, - 114, 171, 115, -1, -1, 146, -1, 211, 121, 146, - -1, 144, -1, 212, 121, 144, -1, 140, -1, 214, - -1, 220, -1, 214, 139, 220, -1, 140, -1, 216, - -1, 230, -1, 216, 139, 230, -1, -1, 218, -1, - 31, 219, 137, -1, 218, 31, 219, 137, -1, 287, - -1, 219, 121, 287, -1, 221, -1, 230, -1, 222, - 140, 137, -1, 227, 140, 137, -1, 224, 140, 137, - -1, 306, 140, 137, -1, 309, 140, 137, -1, 223, - 290, -1, 241, 223, 290, -1, 222, 140, 121, 139, - 285, 290, -1, 380, 285, 324, -1, 383, 285, 324, - -1, 237, 383, 285, 324, -1, 225, -1, 237, 225, - -1, 241, 225, -1, 241, 237, 225, -1, 224, 140, - 121, 139, 285, -1, 383, 285, 114, 139, 273, 140, - 115, -1, 226, 285, 114, 139, 273, 140, 115, -1, - 116, 139, 275, 140, 117, -1, 116, 139, 275, 140, - 121, 139, 276, 140, 117, -1, 3, 223, -1, 3, - 225, -1, 227, 140, 121, 139, 144, -1, 3, 234, - 322, -1, 228, 140, 121, 139, 322, -1, 237, 3, - 234, 322, -1, 234, 3, 322, -1, 234, 3, 237, - 322, -1, 3, 144, 136, 172, -1, 229, 140, 121, - 139, 144, 136, 172, -1, 232, 231, 140, 137, -1, - 228, 140, 137, -1, 229, 140, 137, -1, 249, 140, - 137, -1, 322, 324, 290, -1, 231, 121, 325, 322, - 324, 290, -1, 245, -1, 249, -1, 253, -1, 296, - -1, 245, -1, 251, -1, 253, -1, 296, -1, 246, - -1, 250, -1, 254, -1, 297, -1, 246, -1, 252, - -1, 254, -1, 297, -1, -1, 237, -1, 238, -1, - 237, 238, -1, 239, -1, 327, -1, 10, -1, 12, - -1, 11, -1, 14, -1, 70, -1, -1, 13, 114, - 240, 299, 115, -1, 242, -1, 237, 242, -1, 241, - 237, 242, -1, 243, -1, 242, 243, -1, 5, -1, - 7, -1, 4, -1, 6, -1, 8, -1, 9, -1, - 72, -1, 74, -1, 16, -1, 21, -1, 20, -1, - 18, -1, 19, -1, 17, -1, 22, -1, 23, -1, - 15, -1, 27, -1, 28, -1, 29, -1, 26, -1, - 24, -1, 25, -1, 246, -1, 241, 246, -1, 245, - 243, -1, 245, 243, 237, -1, 245, 243, 246, -1, - 247, -1, 236, 248, 236, -1, 244, -1, 237, 244, - -1, 247, 238, -1, 247, 244, -1, 30, 114, 289, - 115, -1, 30, 114, 177, 115, -1, 81, 114, 289, - 115, -1, 81, 114, 177, 115, -1, 250, -1, 241, - 250, -1, 249, 243, -1, 249, 243, 237, -1, 255, - -1, 237, 255, -1, 250, 238, -1, 252, -1, 241, - 252, -1, 251, 243, -1, 251, 243, 237, -1, 256, - -1, 237, 256, -1, 252, 238, -1, 254, -1, 241, - 254, -1, 253, 243, -1, 253, 243, 237, -1, 77, - -1, 237, 77, -1, 254, 238, -1, 257, -1, 268, - -1, 259, -1, 270, -1, 260, 325, 119, 261, 120, - -1, -1, 260, 325, 287, 258, 119, 261, 120, -1, - 260, 325, 114, 305, 115, 119, 261, 120, -1, 259, - -1, 260, 325, 287, -1, 260, 325, 298, -1, 33, - -1, 34, -1, -1, 261, 262, -1, 263, 137, -1, - 43, 263, 137, -1, 234, 264, 137, -1, 43, 234, - 264, 137, -1, 379, -1, 379, 287, -1, 263, 121, - 287, -1, 263, 121, -1, 265, -1, 264, 121, 325, - 265, -1, -1, 267, -1, 331, 266, -1, 344, 266, - -1, 370, -1, -1, 267, -1, 135, 171, -1, 32, - 325, 119, 271, 385, 120, -1, -1, 32, 325, 287, - 269, 119, 271, 385, 120, -1, 270, -1, 32, 325, - 287, -1, 287, 272, -1, 271, 121, 287, 272, -1, - -1, 136, 171, -1, -1, 274, -1, 276, -1, 275, - -1, 275, 140, 121, 139, 276, -1, 276, 140, 121, - 139, 101, -1, 275, 140, 121, 139, 101, -1, 280, - -1, 276, 140, 121, 139, 280, -1, 275, 140, 121, - 139, 280, -1, 275, 140, 121, 139, 276, 140, 121, - 139, 280, -1, 281, -1, 276, 140, 121, 139, 281, - -1, -1, 278, -1, 279, -1, 279, 140, 121, 139, - 101, -1, 283, -1, 282, -1, 279, 140, 121, 139, - 283, -1, 279, 140, 121, 139, 282, -1, 282, -1, - 375, 285, 386, -1, 383, 285, 386, -1, 237, 383, - 285, 386, -1, 225, -1, 283, -1, 375, -1, 383, - -1, 237, 383, -1, 384, -1, 233, 349, 386, -1, - 233, 353, 386, -1, 233, 386, -1, 233, 364, 386, - -1, 144, -1, 284, 121, 144, -1, 142, -1, 77, - -1, 78, -1, 143, -1, 77, -1, 78, -1, 144, - -1, 77, -1, 78, -1, 379, -1, 234, -1, 234, - 358, -1, 288, -1, 384, -1, -1, 136, 291, -1, - 112, 291, -1, 172, -1, 119, 292, 385, 120, -1, - -1, 291, -1, 293, 291, -1, 292, 121, 291, -1, - 292, 121, 293, 291, -1, 294, 135, -1, 287, 135, - -1, 295, -1, 294, 295, -1, 118, 287, -1, 116, - 139, 172, 140, 117, -1, 116, 139, 323, 140, 117, - -1, 116, 139, 171, 101, 171, 140, 117, -1, 118, - 116, 139, 152, 140, 117, -1, 297, -1, 241, 297, - -1, 296, 243, -1, 296, 243, 237, -1, 298, -1, - 237, 298, -1, 297, 238, -1, 78, 114, 305, 115, - -1, 300, 386, -1, 299, 121, 300, 386, -1, -1, - 302, 287, 301, 303, -1, 234, 349, -1, 35, -1, - 37, -1, 36, -1, 38, -1, -1, 303, 304, -1, - 133, 287, 114, 305, 115, -1, 133, 119, 139, 311, - 120, -1, 133, 114, 139, 299, 140, 115, 119, 139, - 311, 120, 114, 305, 115, -1, 289, -1, 172, -1, - 305, 121, 289, -1, 305, 121, 172, -1, 35, 307, - -1, 242, 35, 307, -1, 306, 121, 307, -1, 308, - 303, -1, 308, 303, 136, 289, -1, 287, -1, 286, - 114, 139, 299, 140, 115, -1, 39, 287, 114, 139, - 299, 140, 115, 119, 120, -1, -1, 39, 287, 114, - 139, 299, 140, 115, 119, 310, 311, 120, -1, 312, - -1, 311, 139, 312, -1, 313, 140, 137, -1, 314, - 140, 137, -1, 223, -1, 225, -1, 313, 140, 121, - 139, 285, -1, 234, 322, -1, 314, 140, 121, 139, - 322, -1, -1, 316, -1, 318, -1, 316, 139, 318, - -1, -1, 316, -1, 220, -1, 320, -1, 67, 114, - 146, 115, 137, -1, -1, 5, 84, 319, 119, 317, - 120, -1, 43, 318, -1, 321, -1, 336, 181, -1, - 340, 139, 215, 181, -1, 224, 181, -1, 232, 336, - 181, -1, 237, 336, 181, -1, 241, 336, 181, -1, - 241, 237, 336, 181, -1, 232, 340, 139, 215, 181, - -1, 237, 340, 139, 215, 181, -1, 241, 340, 139, - 215, 181, -1, 241, 237, 340, 139, 215, 181, -1, - 331, -1, 344, -1, 336, -1, 171, 127, 171, -1, - -1, 67, 114, 146, 115, 325, -1, -1, 326, -1, - 327, -1, 326, 327, -1, 42, 114, 114, 328, 115, - 115, -1, 329, -1, 328, 121, 329, -1, -1, 330, - -1, 330, 114, 150, 115, -1, 75, -1, 77, -1, - 78, -1, 10, -1, 332, 325, -1, 333, -1, 334, - 325, -1, 335, 325, -1, 142, -1, 114, 332, 115, - -1, 157, 331, -1, 157, 237, 331, -1, 114, 333, - 115, 325, -1, 332, 362, -1, 114, 333, 115, 362, - -1, 114, 334, 115, 363, -1, 114, 334, 115, -1, - 114, 333, 115, 114, 139, 277, 140, 115, -1, 114, - 335, 115, -1, 337, 325, -1, 338, -1, 339, 325, - -1, 332, 114, 139, 277, 140, 115, -1, 114, 338, - 115, 114, 139, 277, 140, 115, -1, 114, 337, 115, - -1, 157, 336, -1, 157, 237, 336, -1, 114, 338, - 115, -1, 114, 338, 115, 362, -1, 114, 339, 115, - 363, -1, 114, 339, 115, -1, 341, -1, 342, -1, - 343, -1, 332, 114, 284, 115, -1, 114, 342, 115, - 114, 139, 277, 140, 115, -1, 114, 341, 115, -1, - 157, 340, -1, 157, 237, 340, -1, 114, 342, 115, - -1, 114, 342, 115, 362, -1, 114, 343, 115, 363, - -1, 114, 343, 115, -1, 345, 325, -1, 346, -1, - 347, 325, -1, 348, 325, -1, 354, -1, 114, 345, - 115, -1, 157, 344, -1, 157, 237, 344, -1, 114, - 346, 115, 325, -1, 345, 362, -1, 114, 346, 115, - 362, -1, 114, 347, 115, 363, -1, 114, 347, 115, - -1, 345, 114, 139, 277, 140, 115, -1, 114, 346, - 115, 114, 139, 277, 140, 115, -1, 114, 348, 115, - -1, 332, 325, -1, 350, -1, 351, 325, -1, 352, - 325, -1, 157, 349, -1, 157, 237, 349, -1, 114, - 350, 115, 325, -1, 332, 368, -1, 114, 350, 115, - 362, -1, 114, 351, 115, 363, -1, 114, 351, 115, - -1, 332, 114, 139, 277, 140, 115, -1, 114, 350, - 115, 114, 139, 277, 140, 115, -1, 114, 352, 115, - -1, 354, 325, -1, 355, -1, 356, 325, -1, 357, - 325, -1, 77, -1, 78, -1, 157, 353, -1, 157, - 237, 353, -1, 114, 355, 115, 325, -1, 354, 368, - -1, 114, 355, 115, 368, -1, 354, 114, 139, 277, - 140, 115, -1, 114, 355, 115, 114, 139, 277, 140, - 115, -1, 359, -1, 360, 325, -1, 361, 325, -1, - 157, -1, 157, 237, -1, 157, 358, -1, 157, 237, - 358, -1, 114, 359, 115, 325, -1, 362, -1, 114, - 359, 115, 362, -1, 114, 360, 115, 363, -1, 114, - 360, 115, -1, 114, 139, 277, 140, 115, -1, 114, - 359, 115, 114, 139, 277, 140, 115, -1, 114, 361, - 115, -1, 116, 117, -1, 116, 117, 363, -1, 363, - -1, 116, 139, 172, 140, 117, -1, 116, 139, 122, - 140, 117, -1, 363, 116, 139, 172, 140, 117, -1, - 363, 116, 139, 122, 140, 117, -1, 365, -1, 366, - 325, -1, 367, 325, -1, 157, -1, 157, 237, -1, - 157, 364, -1, 157, 237, 364, -1, 114, 365, 115, - 325, -1, 368, -1, 114, 365, 115, 368, -1, 114, - 366, 115, 363, -1, 114, 366, 115, -1, 114, 139, - 277, 140, 115, -1, 114, 365, 115, 114, 139, 277, - 140, 115, -1, 114, 367, 115, -1, 369, -1, 369, - 363, -1, 363, -1, 116, 117, -1, 116, 139, 237, - 122, 140, 117, -1, 116, 139, 237, 140, 117, -1, - 116, 139, 237, 172, 140, 117, -1, 116, 139, 7, - 236, 172, 140, 117, -1, 116, 139, 237, 7, 172, - 140, 117, -1, 371, -1, 372, 325, -1, 373, 325, - -1, 157, -1, 157, 237, -1, 157, 370, -1, 157, - 237, 370, -1, 114, 371, 115, 325, -1, 362, -1, - 114, 371, 115, 362, -1, 114, 372, 115, 363, -1, - 114, 372, 115, -1, 114, 371, 115, 114, 139, 277, - 140, 115, -1, 114, 373, 115, -1, 375, -1, 383, - -1, 237, 383, -1, 376, -1, 377, -1, 157, 235, - -1, 237, 157, 235, -1, 157, 384, -1, 237, 157, - 384, -1, 157, 374, -1, 237, 157, 374, -1, 116, - 117, 235, -1, 378, 235, -1, 116, 117, 363, 235, - -1, 378, 363, 235, -1, 363, 235, -1, 116, 117, - 376, -1, 378, 376, -1, 116, 117, 363, 376, -1, - 378, 363, 376, -1, 363, 376, -1, 116, 139, 237, - 122, 140, 117, -1, 116, 139, 237, 172, 140, 117, - -1, 116, 139, 241, 172, 140, 117, -1, 116, 139, - 241, 237, 172, 140, 117, -1, 383, -1, 237, 383, - -1, 380, -1, 381, -1, 382, -1, 157, 234, -1, - 237, 157, 234, -1, 157, 384, -1, 237, 157, 384, - -1, 157, 379, -1, 237, 157, 379, -1, 116, 117, - 234, -1, 116, 117, 363, 234, -1, 363, 234, -1, - 116, 117, 381, -1, 116, 117, 363, 381, -1, 363, - 381, -1, 116, 139, 276, 140, 117, -1, 383, 114, - 139, 273, 140, 115, -1, 226, 114, 139, 273, 140, - 115, -1, -1, 121, -1, -1, 136, 172, -1 -}; - -/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ -static const yytype_uint16 yyrline[] = -{ - 0, 326, 326, 330, 337, 338, 339, 340, 341, 345, - 346, 347, 351, 352, 356, 357, 361, 362, 366, 370, - 371, 382, 384, 386, 387, 389, 394, 395, 401, 403, - 405, 407, 409, 411, 413, 415, 417, 419, 428, 429, - 435, 436, 440, 441, 445, 446, 448, 450, 452, 454, - 456, 461, 463, 465, 477, 478, 486, 489, 491, 493, - 498, 511, 513, 515, 517, 519, 521, 523, 525, 527, - 529, 531, 538, 539, 545, 546, 547, 548, 552, 553, - 560, 561, 563, 565, 570, 571, 573, 578, 579, 581, - 586, 587, 589, 591, 593, 598, 599, 601, 606, 607, - 612, 613, 618, 619, 624, 625, 630, 631, 636, 637, - 640, 647, 652, 653, 661, 662, 666, 667, 668, 669, - 670, 671, 672, 673, 674, 675, 676, 677, 687, 689, - 694, 695, 700, 701, 707, 708, 714, 715, 716, 717, - 718, 719, 720, 721, 722, 732, 739, 741, 752, 753, - 758, 760, 765, 767, 772, 776, 777, 782, 787, 790, - 792, 794, 804, 806, 817, 818, 820, 824, 826, 830, - 831, 836, 837, 841, 846, 847, 851, 853, 859, 860, - 864, 866, 868, 870, 876, 877, 881, 883, 888, 890, - 892, 897, 899, 904, 906, 910, 913, 917, 920, 924, - 926, 928, 930, 935, 937, 939, 944, 946, 948, 950, - 952, 957, 959, 961, 963, 968, 976, 977, 982, 984, - 989, 993, 995, 997, 999, 1001, 1007, 1008, 1014, 1015, - 1019, 1020, 1025, 1027, 1033, 1034, 1036, 1042, 1047, 1057, - 1059, 1063, 1064, 1069, 1071, 1075, 1076, 1080, 1082, 1086, - 1087, 1091, 1092, 1096, 1097, 1112, 1113, 1114, 1115, 1116, - 1120, 1125, 1132, 1142, 1147, 1152, 1160, 1165, 1170, 1175, - 1180, 1210, 1215, 1222, 1224, 1231, 1236, 1241, 1252, 1257, - 1262, 1267, 1272, 1281, 1286, 1316, 1320, 1321, 1322, 1328, - 1333, 1341, 1342, 1343, 1344, 1353, 1354, 1355, 1356, 1360, - 1361, 1362, 1363, 1372, 1373, 1374, 1375, 1380, 1381, 1390, - 1391, 1396, 1397, 1401, 1403, 1405, 1407, 1409, 1412, 1411, - 1423, 1424, 1426, 1436, 1437, 1442, 1444, 1446, 1448, 1450, - 1453, 1455, 1458, 1463, 1465, 1467, 1469, 1471, 1473, 1475, - 1477, 1479, 1481, 1483, 1485, 1487, 1489, 1491, 1497, 1498, - 1500, 1502, 1504, 1509, 1510, 1516, 1517, 1519, 1521, 1526, - 1528, 1530, 1532, 1537, 1538, 1540, 1542, 1547, 1548, 1550, - 1555, 1556, 1558, 1560, 1565, 1566, 1568, 1573, 1574, 1576, - 1578, 1583, 1585, 1587, 1592, 1593, 1597, 1598, 1602, 1605, - 1604, 1608, 1610, 1614, 1619, 1624, 1626, 1632, 1633, 1638, - 1639, 1644, 1647, 1655, 1656, 1658, 1660, 1665, 1666, 1672, - 1673, 1675, 1678, 1681, 1686, 1687, 1692, 1697, 1700, 1699, - 1703, 1707, 1715, 1717, 1723, 1724, 1732, 1733, 1737, 1738, - 1739, 1741, 1743, 1750, 1751, 1753, 1755, 1760, 1761, 1767, - 1768, 1772, 1773, 1778, 1779, 1780, 1782, 1790, 1791, 1793, - 1796, 1798, 1802, 1803, 1804, 1806, 1808, 1813, 1818, 1826, - 1828, 1837, 1839, 1844, 1845, 1846, 1850, 1851, 1852, 1856, - 1857, 1858, 1862, 1863, 1864, 1869, 1870, 1875, 1876, 1878, - 1883, 1884, 1889, 1890, 1891, 1892, 1893, 1908, 1909, 1914, - 1915, 1921, 1923, 1926, 1928, 1930, 1953, 1954, 1956, 1958, - 1963, 1964, 1966, 1971, 1976, 1977, 1983, 1982, 1986, 1990, - 1992, 1994, 1996, 2002, 2003, 2008, 2013, 2015, 2020, 2022, - 2023, 2025, 2030, 2032, 2034, 2039, 2041, 2046, 2051, 2059, - 2065, 2064, 2078, 2079, 2084, 2085, 2089, 2094, 2099, 2107, - 2112, 2123, 2124, 2129, 2130, 2136, 2137, 2141, 2142, 2143, - 2148, 2147, 2158, 2166, 2172, 2178, 2187, 2193, 2199, 2205, - 2211, 2219, 2225, 2233, 2239, 2248, 2249, 2250, 2254, 2260, - 2261, 2271, 2272, 2276, 2277, 2282, 2287, 2288, 2294, 2295, - 2297, 2302, 2303, 2304, 2305, 2340, 2342, 2343, 2345, 2350, - 2355, 2360, 2362, 2364, 2369, 2371, 2373, 2375, 2380, 2382, - 2391, 2393, 2394, 2399, 2401, 2403, 2408, 2410, 2412, 2417, - 2419, 2421, 2433, 2434, 2435, 2439, 2441, 2443, 2448, 2450, - 2452, 2457, 2459, 2461, 2476, 2478, 2479, 2481, 2486, 2487, - 2492, 2494, 2496, 2501, 2503, 2505, 2507, 2512, 2514, 2516, - 2526, 2528, 2529, 2531, 2536, 2538, 2540, 2545, 2547, 2549, - 2551, 2556, 2558, 2560, 2573, 2575, 2576, 2578, 2583, 2588, - 2596, 2598, 2600, 2605, 2607, 2612, 2614, 2631, 2632, 2634, - 2639, 2641, 2643, 2645, 2647, 2652, 2653, 2655, 2657, 2662, - 2664, 2666, 2672, 2674, 2676, 2680, 2682, 2684, 2686, 2720, - 2721, 2723, 2728, 2730, 2732, 2734, 2736, 2741, 2742, 2744, - 2746, 2751, 2753, 2755, 2761, 2762, 2764, 2773, 2776, 2778, - 2781, 2783, 2785, 2799, 2800, 2802, 2807, 2809, 2811, 2813, - 2815, 2820, 2821, 2823, 2825, 2830, 2832, 2840, 2841, 2842, - 2847, 2848, 2853, 2855, 2857, 2859, 2861, 2863, 2870, 2872, - 2874, 2876, 2878, 2881, 2883, 2885, 2887, 2889, 2894, 2896, - 2898, 2903, 2929, 2930, 2932, 2936, 2937, 2941, 2943, 2945, - 2947, 2949, 2951, 2958, 2960, 2962, 2964, 2966, 2968, 2973, - 2980, 2982, 3000, 3002, 3007, 3008 -}; -#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", "ZERO_T", "ONE_T", "VALIST", "BOOL", "COMPLEX", - "IMAGINARY", "TYPEOF", "LABEL", "ENUM", "STRUCT", "UNION", "OTYPE", - "FTYPE", "DTYPE", "TTYPE", "TRAIT", "SIZEOF", "OFFSETOF", "ATTRIBUTE", - "EXTENSION", "IF", "ELSE", "SWITCH", "CASE", "DEFAULT", "DO", "WHILE", - "FOR", "BREAK", "CONTINUE", "GOTO", "RETURN", "CHOOSE", "DISABLE", - "ENABLE", "FALLTHRU", "TRY", "CATCH", "CATCHRESUME", "FINALLY", "THROW", - "THROWRESUME", "AT", "ASM", "ALIGNAS", "ALIGNOF", "ATOMIC", "GENERIC", - "NORETURN", "STATICASSERT", "THREADLOCAL", "IDENTIFIER", - "QUOTED_IDENTIFIER", "TYPEDEFname", "TYPEGENname", "ATTR_IDENTIFIER", - "ATTR_TYPEDEFname", "ATTR_TYPEGENname", "INTEGERconstant", - "CHARACTERconstant", "STRINGliteral", "REALDECIMALconstant", - "REALFRACTIONconstant", "FLOATINGconstant", "ZERO", "ONE", "ARROW", - "ICR", "DECR", "LS", "RS", "LE", "GE", "EQ", "NE", "ANDAND", "OROR", - "ELLIPSIS", "MULTassign", "DIVassign", "MODassign", "PLUSassign", - "MINUSassign", "LSassign", "RSassign", "ANDassign", "ERassign", - "ORassign", "ATassign", "THEN", "'('", "')'", "'['", "']'", "'.'", "'{'", - "'}'", "','", "'*'", "'&'", "'+'", "'-'", "'!'", "'~'", "'/'", "'%'", - "'<'", "'>'", "'^'", "'|'", "'?'", "':'", "'='", "';'", "$accept", - "push", "pop", "constant", "identifier", "no_01_identifier", - "no_attr_identifier", "zero_one", "string_literal", - "string_literal_list", "primary_expression", "postfix_expression", - "argument_expression_list", "argument_expression", "field_list", "field", - "field_name", "fraction_constants", "unary_expression", - "ptrref_operator", "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", "assignment_operator", "tuple", - "tuple_expression_list", "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_volatile_opt", "asm_operands_opt", "asm_operands_list", - "asm_operand", "asm_clobbers_list_opt", "label_list", - "declaration_list_opt", "declaration_list", "KR_declaration_list_opt", - "KR_declaration_list", "local_label_declaration_opt", - "local_label_declaration_list", "local_label_list", "declaration", - "cfa_declaration", "cfa_variable_declaration", "cfa_variable_specifier", - "cfa_function_declaration", "cfa_function_specifier", - "cfa_function_return", "cfa_typedef_declaration", "typedef_declaration", - "typedef_expression", "c_declaration", "declaring_list", - "declaration_specifier", "declaration_specifier_nobody", - "type_specifier", "type_specifier_nobody", "type_qualifier_list_opt", - "type_qualifier_list", "type_qualifier", "type_qualifier_name", "$@1", - "declaration_qualifier_list", "storage_class_list", "storage_class", - "basic_type_name", "basic_declaration_specifier", "basic_type_specifier", - "direct_type_name", "indirect_type_name", "sue_declaration_specifier", - "sue_type_specifier", "sue_declaration_specifier_nobody", - "sue_type_specifier_nobody", "typedef_declaration_specifier", - "typedef_type_specifier", "elaborated_type", "elaborated_type_nobody", - "aggregate_type", "$@2", "aggregate_type_nobody", "aggregate_key", - "field_declaration_list", "field_declaration", - "cfa_field_declaring_list", "field_declaring_list", "field_declarator", - "bit_subrange_size_opt", "bit_subrange_size", "enum_type", "$@3", - "enum_type_nobody", "enumerator_list", "enumerator_value_opt", - "cfa_parameter_type_list_opt", "cfa_parameter_type_list", - "cfa_parameter_list", "cfa_abstract_parameter_list", - "parameter_type_list_opt", "parameter_type_list", "parameter_list", - "cfa_parameter_declaration", "cfa_abstract_parameter_declaration", - "parameter_declaration", "abstract_parameter_declaration", - "identifier_list", "identifier_or_type_name", - "no_01_identifier_or_type_name", "no_attr_identifier_or_type_name", - "type_name_no_function", "type_name", "initializer_opt", "initializer", - "initializer_list", "designation", "designator_list", "designator", - "typegen_declaration_specifier", "typegen_type_specifier", - "typegen_name", "type_parameter_list", "type_parameter", "$@4", - "type_class", "assertion_list_opt", "assertion", "type_name_list", - "type_declaring_list", "type_declarator", "type_declarator_name", - "trait_specifier", "$@5", "trait_declaration_list", "trait_declaration", - "cfa_trait_declaring_list", "trait_declaring_list", "translation_unit", - "external_definition_list", "external_definition_list_opt", - "external_definition", "$@6", "external_function_definition", - "function_definition", "declarator", "subrange", "asm_name_opt", - "attribute_list_opt", "attribute_list", "attribute", - "attribute_name_list", "attribute_name", "attr_name", - "variable_declarator", "paren_identifier", "variable_ptr", - "variable_array", "variable_function", "function_declarator", - "function_no_ptr", "function_ptr", "function_array", - "KR_function_declarator", "KR_function_no_ptr", "KR_function_ptr", - "KR_function_array", "variable_type_redeclarator", "paren_type", - "type_ptr", "type_array", "type_function", - "identifier_parameter_declarator", "identifier_parameter_ptr", - "identifier_parameter_array", "identifier_parameter_function", - "type_parameter_redeclarator", "typedef", "type_parameter_ptr", - "type_parameter_array", "type_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", - "cfa_identifier_parameter_declarator_tuple", - "cfa_identifier_parameter_declarator_no_tuple", - "cfa_identifier_parameter_ptr", "cfa_identifier_parameter_array", - "cfa_array_parameter_1st_dimension", "cfa_abstract_declarator_tuple", - "cfa_abstract_declarator_no_tuple", "cfa_abstract_ptr", - "cfa_abstract_array", "cfa_abstract_tuple", "cfa_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, 356, 357, 358, 359, 360, 361, 362, 363, 364, - 365, 366, 367, 368, 40, 41, 91, 93, 46, 123, - 125, 44, 42, 38, 43, 45, 33, 126, 47, 37, - 60, 62, 94, 124, 63, 58, 61, 59 -}; -# endif - -/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ -static const yytype_uint16 yyr1[] = -{ - 0, 138, 139, 140, 141, 141, 141, 141, 141, 142, - 142, 142, 143, 143, 144, 144, 145, 145, 146, 147, - 147, 148, 148, 148, 148, 148, 149, 149, 149, 149, - 149, 149, 149, 149, 149, 149, 149, 149, 150, 150, - 151, 151, 152, 152, 153, 153, 153, 153, 153, 153, - 153, 154, 154, 154, 155, 155, 156, 156, 156, 156, - 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, - 156, 156, 157, 157, 158, 158, 158, 158, 159, 159, - 160, 160, 160, 160, 161, 161, 161, 162, 162, 162, - 163, 163, 163, 163, 163, 164, 164, 164, 165, 165, - 166, 166, 167, 167, 168, 168, 169, 169, 170, 170, - 170, 171, 172, 172, 173, 173, 174, 174, 174, 174, - 174, 174, 174, 174, 174, 174, 174, 174, 175, 175, - 176, 176, 177, 177, 178, 178, 179, 179, 179, 179, - 179, 179, 179, 179, 179, 180, 181, 181, 182, 182, - 183, 183, 183, 183, 183, 184, 184, 185, 186, 186, - 186, 186, 186, 186, 187, 187, 187, 188, 188, 189, - 189, 190, 190, 191, 192, 192, 193, 193, 194, 194, - 195, 195, 195, 195, 196, 196, 197, 197, 198, 198, - 198, 199, 199, 200, 200, 200, 200, 200, 200, 200, - 200, 200, 200, 201, 201, 201, 202, 202, 202, 202, - 202, 203, 203, 203, 203, 204, 205, 205, 205, 205, - 205, 206, 206, 206, 206, 206, 207, 207, 208, 208, - 209, 209, 210, 210, 211, 211, 211, 212, 212, 213, - 213, 214, 214, 215, 215, 216, 216, 217, 217, 218, - 218, 219, 219, 220, 220, 221, 221, 221, 221, 221, - 222, 222, 222, 223, 223, 223, 224, 224, 224, 224, - 224, 225, 225, 226, 226, 227, 227, 227, 228, 228, - 228, 228, 228, 229, 229, 230, 230, 230, 230, 231, - 231, 232, 232, 232, 232, 233, 233, 233, 233, 234, - 234, 234, 234, 235, 235, 235, 235, 236, 236, 237, - 237, 238, 238, 239, 239, 239, 239, 239, 240, 239, - 241, 241, 241, 242, 242, 243, 243, 243, 243, 243, - 243, 243, 243, 244, 244, 244, 244, 244, 244, 244, - 244, 244, 244, 244, 244, 244, 244, 244, 245, 245, - 245, 245, 245, 246, 246, 247, 247, 247, 247, 248, - 248, 248, 248, 249, 249, 249, 249, 250, 250, 250, - 251, 251, 251, 251, 252, 252, 252, 253, 253, 253, - 253, 254, 254, 254, 255, 255, 256, 256, 257, 258, - 257, 257, 257, 259, 259, 260, 260, 261, 261, 262, - 262, 262, 262, 263, 263, 263, 263, 264, 264, 265, - 265, 265, 265, 265, 266, 266, 267, 268, 269, 268, - 268, 270, 271, 271, 272, 272, 273, 273, 274, 274, - 274, 274, 274, 275, 275, 275, 275, 276, 276, 277, - 277, 278, 278, 279, 279, 279, 279, 280, 280, 280, - 280, 280, 281, 281, 281, 281, 281, 282, 282, 283, - 283, 284, 284, 285, 285, 285, 286, 286, 286, 287, - 287, 287, 288, 288, 288, 289, 289, 290, 290, 290, - 291, 291, 292, 292, 292, 292, 292, 293, 293, 294, - 294, 295, 295, 295, 295, 295, 296, 296, 296, 296, - 297, 297, 297, 298, 299, 299, 301, 300, 300, 302, - 302, 302, 302, 303, 303, 304, 304, 304, 305, 305, - 305, 305, 306, 306, 306, 307, 307, 308, 308, 309, - 310, 309, 311, 311, 312, 312, 313, 313, 313, 314, - 314, 315, 315, 316, 316, 317, 317, 318, 318, 318, - 319, 318, 318, 320, 320, 320, 321, 321, 321, 321, - 321, 321, 321, 321, 321, 322, 322, 322, 323, 324, - 324, 325, 325, 326, 326, 327, 328, 328, 329, 329, - 329, 330, 330, 330, 330, 331, 331, 331, 331, 332, - 332, 333, 333, 333, 334, 334, 334, 334, 335, 335, - 336, 336, 336, 337, 337, 337, 338, 338, 338, 339, - 339, 339, 340, 340, 340, 341, 341, 341, 342, 342, - 342, 343, 343, 343, 344, 344, 344, 344, 345, 345, - 346, 346, 346, 347, 347, 347, 347, 348, 348, 348, - 349, 349, 349, 349, 350, 350, 350, 351, 351, 351, - 351, 352, 352, 352, 353, 353, 353, 353, 354, 354, - 355, 355, 355, 356, 356, 357, 357, 358, 358, 358, - 359, 359, 359, 359, 359, 360, 360, 360, 360, 361, - 361, 361, 362, 362, 362, 363, 363, 363, 363, 364, - 364, 364, 365, 365, 365, 365, 365, 366, 366, 366, - 366, 367, 367, 367, 368, 368, 368, 369, 369, 369, - 369, 369, 369, 370, 370, 370, 371, 371, 371, 371, - 371, 372, 372, 372, 372, 373, 373, 374, 374, 374, - 375, 375, 376, 376, 376, 376, 376, 376, 377, 377, - 377, 377, 377, 377, 377, 377, 377, 377, 378, 378, - 378, 378, 379, 379, 379, 380, 380, 381, 381, 381, - 381, 381, 381, 382, 382, 382, 382, 382, 382, 383, - 384, 384, 385, 385, 386, 386 -}; - -/* 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, 1, 1, 1, 1, - 2, 1, 1, 1, 3, 3, 1, 6, 4, 3, - 7, 2, 3, 7, 2, 2, 7, 4, 1, 3, - 0, 1, 1, 3, 1, 2, 6, 3, 7, 3, - 7, 2, 2, 2, 0, 2, 1, 1, 1, 2, - 2, 2, 2, 2, 2, 4, 2, 4, 6, 1, - 4, 4, 1, 1, 1, 1, 1, 1, 1, 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, 1, 1, 3, 0, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 6, 7, - 1, 3, 1, 3, 0, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 6, 4, 2, 7, 1, 3, - 1, 2, 1, 2, 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, 3, 5, 3, 3, 4, 1, 5, 6, 5, - 6, 9, 10, 9, 10, 2, 1, 2, 2, 2, - 1, 6, 8, 10, 12, 14, 0, 1, 0, 1, - 1, 3, 4, 7, 0, 1, 3, 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, 7, 7, 5, 9, 2, 2, 5, 3, 5, - 4, 3, 4, 4, 7, 4, 3, 3, 3, 3, - 6, 1, 1, 1, 1, 1, 1, 1, 1, 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, 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, 2, 2, - 3, 1, 2, 2, 1, 1, 1, 1, 5, 0, - 7, 8, 1, 3, 3, 1, 1, 0, 2, 2, - 3, 3, 4, 1, 2, 3, 2, 1, 4, 0, - 1, 2, 2, 1, 0, 1, 2, 6, 0, 8, - 1, 3, 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, 2, - 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 2, 1, 1, 0, 2, 2, - 1, 4, 0, 1, 2, 3, 4, 2, 2, 1, - 2, 2, 5, 5, 7, 6, 1, 2, 2, 3, - 1, 2, 2, 4, 2, 4, 0, 4, 2, 1, - 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, 5, - 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, 4, 2, 4, 4, 3, 8, 3, - 2, 1, 2, 6, 8, 3, 2, 3, 3, 4, - 4, 3, 1, 1, 1, 4, 8, 3, 2, 3, - 3, 4, 4, 3, 2, 1, 2, 2, 1, 3, - 2, 3, 4, 2, 4, 4, 3, 6, 8, 3, - 2, 1, 2, 2, 2, 3, 4, 2, 4, 4, - 3, 6, 8, 3, 2, 1, 2, 2, 1, 1, - 2, 3, 4, 2, 4, 6, 8, 1, 2, 2, - 1, 2, 2, 3, 4, 1, 4, 4, 3, 5, - 8, 3, 2, 3, 1, 5, 5, 6, 6, 1, - 2, 2, 1, 2, 2, 3, 4, 1, 4, 4, - 3, 5, 8, 3, 1, 2, 1, 2, 6, 5, - 6, 7, 7, 1, 2, 2, 1, 2, 2, 3, - 4, 1, 4, 4, 3, 8, 3, 1, 1, 2, - 1, 1, 2, 3, 2, 3, 2, 3, 3, 2, - 4, 3, 2, 3, 2, 4, 3, 2, 6, 6, - 6, 7, 1, 2, 1, 1, 1, 2, 3, 2, - 3, 2, 3, 3, 4, 2, 3, 4, 2, 5, - 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[] = -{ - 307, 307, 327, 325, 328, 326, 329, 330, 313, 315, - 314, 0, 316, 341, 333, 338, 336, 337, 335, 334, - 339, 340, 346, 347, 345, 342, 343, 344, 571, 395, - 396, 0, 0, 0, 307, 0, 317, 331, 332, 9, - 381, 0, 10, 16, 17, 0, 2, 72, 73, 589, - 11, 307, 547, 253, 3, 477, 3, 266, 0, 3, - 3, 3, 254, 0, 0, 0, 308, 309, 311, 307, - 320, 323, 355, 291, 348, 353, 292, 363, 293, 377, - 367, 384, 392, 571, 385, 420, 294, 496, 500, 3, - 3, 0, 2, 543, 548, 553, 312, 0, 0, 571, - 601, 571, 2, 612, 613, 614, 307, 0, 755, 756, - 0, 14, 0, 15, 307, 275, 276, 0, 308, 299, - 300, 301, 302, 550, 318, 0, 572, 573, 14, 470, - 471, 13, 466, 469, 0, 527, 522, 513, 470, 471, - 0, 0, 552, 0, 307, 0, 0, 0, 0, 0, - 0, 0, 0, 307, 307, 0, 757, 308, 606, 618, - 761, 754, 752, 759, 0, 0, 0, 260, 2, 0, - 556, 464, 465, 463, 0, 0, 0, 0, 658, 659, - 0, 0, 3, 569, 565, 571, 586, 571, 571, 567, - 2, 566, 571, 625, 571, 571, 628, 0, 0, 0, - 307, 307, 325, 382, 2, 307, 267, 310, 321, 356, - 368, 501, 0, 2, 0, 477, 268, 308, 349, 364, - 378, 497, 0, 2, 0, 324, 350, 357, 358, 0, - 365, 369, 379, 383, 0, 498, 502, 0, 0, 0, - 1, 307, 2, 554, 600, 602, 307, 2, 765, 308, - 768, 569, 569, 0, 308, 0, 0, 278, 571, 567, - 2, 307, 0, 0, 307, 0, 421, 574, 2, 525, - 2, 578, 19, 0, 18, 0, 0, 0, 0, 21, - 69, 4, 8, 5, 6, 7, 0, 0, 307, 2, - 74, 75, 76, 77, 57, 22, 58, 26, 56, 78, - 307, 0, 80, 84, 87, 90, 95, 98, 100, 102, - 104, 106, 108, 112, 519, 23, 473, 475, 518, 0, - 472, 476, 0, 590, 605, 608, 611, 617, 620, 623, - 2, 763, 307, 766, 571, 2, 72, 307, 3, 451, - 0, 774, 308, 307, 320, 295, 348, 296, 370, 297, - 377, 374, 386, 571, 387, 3, 3, 433, 437, 447, - 452, 298, 496, 307, 453, 730, 731, 307, 454, 456, - 2, 607, 619, 753, 2, 2, 255, 2, 482, 0, - 480, 479, 478, 146, 2, 2, 257, 2, 2, 256, - 2, 286, 2, 287, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 591, 630, 571, 0, 0, 477, 2, - 585, 594, 684, 587, 588, 557, 307, 2, 624, 633, - 626, 627, 0, 281, 307, 307, 354, 308, 0, 308, - 307, 758, 762, 760, 558, 307, 569, 261, 269, 322, - 0, 2, 559, 307, 523, 351, 352, 288, 366, 380, - 471, 307, 397, 393, 394, 499, 524, 258, 259, 544, - 307, 461, 0, 307, 243, 0, 2, 245, 0, 308, - 307, 0, 263, 2, 264, 283, 0, 0, 2, 307, - 569, 307, 509, 511, 510, 512, 0, 0, 774, 0, - 772, 424, 0, 307, 0, 307, 514, 307, 584, 581, - 582, 583, 0, 576, 579, 0, 20, 307, 64, 307, - 78, 59, 307, 66, 307, 307, 62, 63, 2, 132, - 0, 0, 0, 752, 307, 31, 0, 34, 35, 40, - 2, 0, 40, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 117, 116, 0, 60, 61, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 2, 670, 474, - 667, 571, 571, 675, 503, 307, 2, 609, 610, 2, - 621, 622, 0, 764, 767, 0, 307, 307, 0, 732, - 308, 303, 304, 305, 306, 736, 727, 728, 734, 0, - 2, 2, 0, 692, 571, 774, 641, 571, 571, 774, - 571, 655, 571, 571, 706, 774, 689, 571, 571, 697, - 704, 459, 307, 375, 455, 308, 371, 372, 376, 0, - 0, 0, 307, 742, 308, 747, 774, 739, 307, 744, - 774, 307, 307, 0, 0, 21, 2, 0, 22, 0, - 483, 772, 0, 0, 489, 247, 0, 307, 0, 0, - 0, 571, 597, 599, 629, 571, 636, 639, 592, 631, - 0, 285, 0, 289, 682, 0, 307, 282, 0, 0, - 0, 0, 280, 2, 0, 265, 560, 307, 0, 0, - 307, 0, 308, 3, 440, 3, 444, 443, 615, 0, - 555, 307, 308, 72, 3, 307, 774, 308, 3, 453, - 454, 2, 0, 0, 0, 508, 319, 307, 504, 506, - 773, 0, 0, 422, 0, 3, 2, 2, 0, 526, - 3, 0, 578, 40, 549, 0, 2, 0, 0, 0, - 41, 0, 0, 307, 24, 0, 25, 0, 114, 3, - 2, 32, 0, 38, 0, 2, 29, 0, 113, 81, - 82, 83, 85, 86, 88, 89, 93, 94, 91, 92, - 96, 97, 99, 101, 103, 105, 107, 0, 0, 307, - 0, 0, 0, 671, 672, 668, 669, 521, 520, 307, - 307, 421, 738, 307, 743, 308, 307, 686, 729, 685, - 2, 307, 0, 0, 0, 0, 0, 0, 0, 0, - 707, 0, 775, 693, 644, 660, 694, 2, 640, 647, - 457, 642, 643, 458, 2, 654, 663, 656, 657, 460, - 690, 691, 705, 733, 737, 735, 774, 373, 393, 273, - 2, 769, 2, 448, 741, 746, 449, 3, 427, 3, - 3, 3, 477, 0, 0, 2, 491, 488, 773, 0, - 484, 2, 487, 490, 0, 307, 248, 270, 3, 277, - 279, 0, 2, 593, 595, 596, 2, 632, 634, 635, - 569, 0, 683, 561, 3, 360, 359, 362, 361, 307, - 562, 0, 563, 0, 307, 388, 409, 398, 0, 403, - 397, 0, 0, 462, 246, 0, 0, 3, 2, 692, - 455, 0, 551, 0, 774, 513, 424, 417, 111, 425, - 772, 0, 307, 307, 307, 0, 575, 577, 0, 65, - 307, 0, 67, 70, 71, 0, 133, 482, 79, 115, - 130, 3, 114, 0, 28, 40, 3, 0, 37, 110, - 0, 3, 571, 678, 681, 673, 3, 3, 740, 745, - 2, 72, 307, 3, 3, 308, 0, 3, 571, 650, - 653, 571, 571, 700, 703, 307, 3, 645, 661, 695, - 307, 307, 450, 307, 307, 0, 0, 0, 0, 262, - 111, 0, 3, 3, 0, 485, 0, 481, 0, 0, - 251, 307, 0, 0, 134, 0, 0, 0, 0, 0, - 134, 0, 0, 114, 114, 226, 21, 381, 465, 69, - 0, 22, 135, 0, 3, 136, 137, 2, 148, 138, - 139, 140, 141, 142, 143, 150, 0, 152, 0, 0, - 0, 307, 307, 477, 571, 0, 564, 397, 409, 0, - 0, 0, 716, 0, 407, 410, 414, 571, 414, 721, - 413, 713, 571, 571, 406, 399, 404, 307, 603, 2, - 688, 687, 0, 693, 2, 505, 507, 423, 0, 528, - 3, 536, 537, 0, 2, 532, 3, 3, 0, 0, - 580, 0, 772, 114, 0, 3, 54, 0, 54, 54, - 3, 42, 44, 39, 0, 3, 109, 0, 2, 674, - 676, 677, 0, 0, 307, 0, 0, 0, 3, 571, - 0, 2, 646, 648, 649, 2, 662, 664, 2, 696, - 698, 699, 0, 0, 72, 0, 3, 3, 3, 3, - 435, 434, 438, 771, 2, 2, 770, 0, 0, 0, - 0, 3, 486, 3, 0, 249, 151, 153, 0, 0, - 0, 0, 2, 197, 0, 195, 0, 0, 0, 0, - 0, 0, 0, 0, 227, 0, 0, 157, 154, 307, - 0, 571, 0, 272, 284, 3, 3, 290, 570, 637, - 307, 0, 400, 0, 0, 0, 0, 416, 717, 718, - 571, 401, 411, 415, 412, 714, 715, 405, 390, 307, - 271, 307, 419, 0, 539, 516, 307, 0, 0, 515, - 530, 68, 0, 131, 128, 0, 51, 2, 45, 52, - 53, 0, 0, 0, 0, 27, 0, 679, 307, 604, - 616, 748, 749, 750, 0, 701, 307, 307, 307, 3, - 3, 0, 709, 0, 0, 0, 0, 307, 307, 3, - 568, 492, 493, 0, 252, 0, 0, 0, 0, 307, - 198, 196, 0, 193, 199, 0, 0, 0, 0, 203, - 206, 204, 200, 0, 201, 0, 0, 40, 149, 147, - 134, 250, 0, 0, 391, 402, 571, 724, 726, 719, - 409, 442, 446, 445, 0, 533, 2, 534, 2, 535, - 529, 307, 36, 129, 55, 0, 43, 33, 2, 49, - 2, 47, 30, 3, 751, 3, 3, 3, 0, 0, - 708, 710, 651, 665, 274, 2, 432, 3, 431, 0, - 495, 134, 0, 0, 134, 3, 0, 134, 3, 308, - 307, 194, 0, 2, 2, 215, 205, 0, 0, 0, - 0, 0, 0, 145, 598, 638, 2, 720, 722, 723, - 408, 2, 0, 0, 2, 3, 0, 0, 0, 0, - 0, 0, 711, 712, 307, 0, 494, 158, 0, 0, - 2, 171, 134, 160, 0, 188, 0, 134, 0, 308, - 2, 162, 0, 2, 0, 2, 2, 2, 202, 0, - 0, 228, 37, 307, 307, 538, 540, 531, 0, 3, - 3, 680, 652, 666, 702, 436, 134, 164, 167, 0, - 166, 170, 3, 173, 172, 0, 134, 190, 134, 3, - 0, 307, 0, 307, 0, 2, 0, 2, 0, 221, - 0, 0, 0, 229, 230, 144, 3, 2, 46, 0, - 0, 159, 0, 0, 169, 239, 174, 2, 241, 189, - 0, 192, 178, 207, 3, 216, 308, 220, 209, 3, - 0, 307, 0, 307, 228, 0, 0, 0, 228, 0, - 0, 0, 50, 48, 165, 168, 134, 0, 175, 307, - 134, 134, 0, 179, 0, 0, 716, 217, 218, 219, - 0, 208, 3, 210, 3, 0, 0, 0, 222, 0, - 231, 725, 307, 155, 176, 161, 134, 242, 191, 186, - 184, 180, 163, 134, 0, 717, 0, 0, 0, 234, - 0, 232, 0, 234, 0, 156, 177, 187, 181, 185, - 184, 182, 3, 3, 0, 0, 235, 0, 0, 223, - 0, 517, 183, 211, 213, 3, 3, 0, 0, 0, - 0, 212, 214, 236, 237, 0, 233, 224, 0, 0, - 225, 238 -}; - -/* YYDEFGOTO[NTERM-NUM]. */ -static const yytype_int16 yydefgoto[] = -{ - -1, 801, 464, 294, 49, 132, 133, 295, 296, 274, - 297, 298, 752, 753, 1100, 1101, 1102, 1226, 299, 379, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 991, 519, 940, 545, 315, 941, 1022, - 1023, 1523, 1025, 1026, 1027, 1028, 1524, 1029, 1030, 1428, - 1429, 1391, 1392, 1393, 1497, 1498, 1502, 1503, 1548, 1549, - 1031, 1346, 1032, 1033, 1279, 1280, 1281, 1474, 1034, 1175, - 1452, 1453, 1454, 1557, 1575, 1466, 1467, 465, 466, 865, - 866, 999, 52, 53, 54, 55, 56, 339, 155, 59, - 60, 61, 62, 182, 468, 341, 64, 1475, 65, 254, - 67, 68, 264, 343, 344, 71, 72, 345, 119, 75, - 200, 76, 120, 347, 348, 349, 121, 80, 351, 81, - 691, 82, 83, 690, 897, 898, 1053, 1054, 1202, 1055, - 84, 492, 85, 490, 723, 847, 848, 355, 356, 693, - 694, 695, 357, 358, 696, 360, 462, 1036, 134, 135, - 317, 318, 167, 650, 651, 652, 653, 654, 361, 122, - 88, 487, 488, 915, 489, 269, 496, 319, 89, 136, - 137, 90, 1311, 1084, 1085, 1086, 1087, 91, 92, 712, - 93, 263, 94, 95, 183, 993, 685, 410, 126, 96, - 502, 503, 504, 184, 258, 186, 187, 188, 259, 99, - 100, 101, 102, 103, 104, 105, 191, 192, 193, 194, - 195, 814, 606, 607, 608, 609, 196, 611, 612, 613, - 569, 570, 571, 572, 1059, 106, 615, 616, 617, 618, - 619, 620, 1060, 1061, 1062, 1063, 595, 364, 365, 366, - 367, 320, 161, 108, 109, 110, 369, 721, 621 -}; - -/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing - STATE-NUM. */ -#define YYPACT_NINF -1346 -static const yytype_int16 yypact[] = -{ - 7080, 10336, -1346, 65, -1346, -1346, -1346, -1346, -1346, -1346, - -1346, 62, -1346, -1346, -1346, -1346, -1346, -1346, -1346, -1346, - -1346, -1346, -1346, -1346, -1346, -1346, -1346, -1346, 140, -1346, - -1346, 1135, 1743, 79, 8505, 107, -1346, -1346, -1346, -1346, - -1346, 187, -1346, -1346, -1346, 1055, 192, -1346, -1346, -1346, - -1346, 10182, -1346, -1346, -1346, 118, 227, -1346, 1650, -1346, - -1346, -1346, -1346, 2245, 362, 74, 8626, -1346, -1346, 10182, - 1874, -1346, -1346, 1963, 424, 3845, 1754, 831, 1963, 1126, - -1346, -1346, -1346, 140, -1346, -1346, 1963, 1440, -1346, 315, - -1346, 449, 497, -1346, -1346, -1346, -1346, 340, 227, 140, - -1346, 140, -1346, -1346, -1346, -1346, 6995, 1650, -1346, -1346, - 1650, -1346, 379, -1346, 9247, -1346, -1346, 2348, 10491, -1346, - 797, 797, 797, -1346, -1346, 1229, 140, -1346, 431, 468, - 505, -1346, -1346, -1346, 517, -1346, -1346, -1346, -1346, -1346, - 536, 569, -1346, 522, 9788, 2012, 153, 486, 556, 589, - 592, 600, 612, 10524, 8132, 576, -1346, 10222, -1346, -1346, - -1346, -1346, 587, -1346, 216, 3873, 3873, -1346, 616, 454, - -1346, -1346, -1346, -1346, 636, 467, 478, 540, -1346, -1346, - 2245, 2715, 640, 713, -1346, 42, -1346, 140, 140, 227, - -1346, -1346, 80, -1346, 140, 140, -1346, 2887, 679, 692, - 797, 7794, -1346, -1346, -1346, 10182, -1346, -1346, 1963, -1346, - -1346, -1346, 227, -1346, 1650, 118, -1346, 8898, -1346, 797, - 797, 797, 227, -1346, 1135, -1346, 7163, -1346, -1346, 691, - 797, -1346, 797, -1346, 993, 797, -1346, 1135, 700, 717, - -1346, 8505, 606, -1346, -1346, -1346, 10149, -1346, -1346, 4159, - -1346, 713, 16, 5182, 10491, 2348, 2887, -1346, 92, -1346, - -1346, 9247, 1650, 697, 11820, 1743, 800, -1346, -1346, 59, - -1346, 509, -1346, 765, 838, 5241, 819, 5182, 5622, -1346, - 821, -1346, -1346, -1346, -1346, -1346, 6113, 6113, 9552, 192, - -1346, -1346, -1346, -1346, -1346, -1346, -1346, -1346, 1842, 2541, - 9788, 5182, -1346, 385, 290, 801, 638, 472, 837, 833, - 835, 879, 26, -1346, -1346, -1346, 733, -1346, -1346, 223, - -1346, -1346, 2012, -1346, -1346, 432, 865, -1346, 659, 865, - -1346, -1346, 6995, -1346, 140, 874, 876, 9906, -1346, -1346, - 878, 1713, 9333, 7918, 1963, 1963, -1346, 1963, 797, 1963, - 797, -1346, -1346, 140, -1346, -1346, -1346, -1346, -1346, -1346, - -1346, 1963, 797, 10609, 1650, -1346, -1346, 10642, 1324, -1346, - -1346, -1346, -1346, -1346, -1346, -1346, -1346, -1346, 3398, 5182, - -1346, -1346, -1346, -1346, -1346, -1346, -1346, -1346, -1346, -1346, - -1346, -1346, -1346, -1346, 921, 880, 906, 909, 944, 914, - 916, 918, 2715, -1346, -1346, 140, 902, 935, 118, 934, - -1346, -1346, 949, -1346, -1346, -1346, 10149, -1346, -1346, -1346, - -1346, -1346, 2887, -1346, 9788, 9788, -1346, 797, 2348, 8042, - 9408, -1346, -1346, -1346, -1346, 10149, 16, -1346, -1346, 1963, - 227, -1346, -1346, 10149, -1346, 7659, -1346, -1346, 797, 797, - 187, 9788, -1346, 954, -1346, 797, -1346, -1346, -1346, -1346, - 10950, -1346, 397, 11485, -1346, 227, 960, -1346, 2348, 11525, - 7794, 6374, -1346, -1346, -1346, -1346, 980, 2887, -1346, 9408, - 713, 7345, -1346, -1346, -1346, -1346, 1499, 420, 951, 1743, - 969, 967, 990, 11820, 1343, 9247, -1346, 11820, -1346, -1346, - -1346, -1346, 422, -1346, 996, 976, -1346, 9552, -1346, 10682, - -1346, -1346, 9552, -1346, 9670, 9552, -1346, -1346, 192, -1346, - 452, 1006, 1007, -1346, 7884, -1346, 532, -1346, -1346, 5182, - -1346, 763, 5182, -1346, -1346, -1346, -1346, -1346, -1346, -1346, - -1346, -1346, -1346, -1346, -1346, 5182, -1346, -1346, 5182, 5182, - 5182, 5182, 5182, 5182, 5182, 5182, 5182, 5182, 5182, 5182, - 5182, 5182, 5182, 5182, 5182, 5182, 3194, 733, 674, -1346, - -1346, 140, 140, -1346, -1346, 9788, -1346, -1346, 949, -1346, - -1346, 949, 6559, -1346, -1346, 1743, 10642, 7884, 1002, -1346, - 10757, -1346, 797, 797, 797, -1346, -1346, 587, -1346, 1011, - 953, 1016, 5182, 2260, 168, 951, -1346, 140, 140, 951, - 211, -1346, 140, 140, 949, 951, -1346, 140, 140, -1346, - 865, -1346, 10797, -1346, 1650, 11676, 797, 797, -1346, 1953, - 266, 729, 10797, -1346, 7263, -1346, 951, -1346, 10609, -1346, - 193, 9018, 9018, 1650, 4710, 989, -1346, 550, 1010, 1012, - -1346, 1021, 3873, 390, -1346, 1117, 1650, 9018, 606, 2348, - 606, 235, 865, -1346, -1346, 274, 865, -1346, -1346, -1346, - 2348, -1346, 522, -1346, 865, 227, 10950, -1346, 487, 1045, - 620, 1049, -1346, 874, 227, -1346, -1346, 10149, 227, 633, - 6712, 1046, 11676, -1346, -1346, 1051, -1346, -1346, -1346, 606, - -1346, 11601, 11751, 876, -1346, 9018, 518, 9333, -1346, -1346, - 587, 1047, 1050, 1499, 2494, -1346, -1346, 11820, -1346, -1346, - 1743, 1052, 5182, -1346, 1743, 1053, -1346, -1346, 1057, -1346, - 1053, 1060, 509, 5182, -1346, 1061, 192, 1063, 1072, 1073, - -1346, 1076, 1077, 7884, -1346, 5182, -1346, 5073, 5182, 1068, - -1346, -1346, 657, -1346, 5182, -1346, -1346, 828, -1346, -1346, - -1346, -1346, 385, 385, 290, 290, 801, 801, 801, 801, - 638, 638, 472, 837, 833, 835, 879, 5182, 327, 10950, - 1084, 1085, 1086, 674, -1346, -1346, -1346, -1346, -1346, 10950, - 10950, -1346, -1346, 10609, -1346, 8256, 10024, -1346, -1346, -1346, - 953, 10950, 985, 1089, 1093, 1107, 1110, 1115, 1120, 1124, - -1346, 4610, -1346, 2260, -1346, -1346, -1346, -1346, -1346, -1346, - -1346, -1346, -1346, -1346, -1346, -1346, -1346, -1346, -1346, -1346, - -1346, -1346, 949, -1346, -1346, -1346, 951, 797, -1346, -1346, - -1346, -1346, -1346, -1346, -1346, -1346, -1346, -1346, -1346, 1127, - 1130, -1346, 118, 1068, 4710, -1346, -1346, -1346, 3398, 1123, - -1346, -1346, -1346, -1346, 1743, 7483, 1215, -1346, -1346, -1346, - -1346, 1116, -1346, -1346, -1346, 949, -1346, -1346, -1346, 949, - 713, 1136, 949, -1346, -1346, -1346, -1346, -1346, -1346, 8132, - -1346, 227, -1346, 1142, 10682, -1346, 2205, -1346, 542, 1743, - -1346, 1152, 1157, -1346, -1346, 1156, 1162, -1346, 775, 1004, - -1346, 751, -1346, 2494, 951, -1346, 967, -1346, -1346, -1346, - 969, 1165, 11820, 9247, 9788, 1168, -1346, -1346, 677, 1169, - 8132, 606, 1169, -1346, -1346, 1169, -1346, 3398, -1346, -1346, - -1346, 1163, 5182, 1278, -1346, 5182, -1346, 1278, -1346, -1346, - 5182, -1346, 317, 865, -1346, -1346, -1346, -1346, -1346, -1346, - -1346, 876, 9906, -1346, -1346, 8380, 1174, -1346, 318, 865, - -1346, 324, 376, 865, -1346, 797, 4908, -1346, -1346, -1346, - 10950, 10950, -1346, 9408, 9408, 1177, 1176, 1184, 1186, -1346, - 793, 61, 1068, -1346, 1278, -1346, 3873, -1346, 5182, 543, - -1346, 7760, 1195, 1198, 11362, 1199, 1200, 1074, 1128, 1197, - 5182, 1209, 227, 5182, 5182, 1300, 1189, 1193, 187, 182, - 688, 1196, 1212, 1214, -1346, -1346, -1346, 1217, -1346, -1346, - -1346, -1346, -1346, -1346, -1346, -1346, 1219, -1346, 1743, 1234, - 5182, 10950, 10950, 118, 140, 1237, -1346, -1346, 2205, 575, - 1180, 5182, 2333, 588, -1346, -1346, 1222, 54, 1222, -1346, - -1346, -1346, 140, 140, 1743, -1346, -1346, 10376, -1346, -1346, - -1346, -1346, 1255, 1004, -1346, -1346, 1238, -1346, 1254, -1346, - 1053, -1346, -1346, 2348, 1259, -1346, -1346, -1346, 708, 1256, - -1346, 1266, 1021, 5182, 1265, 1163, -1346, 818, -1346, -1346, - 1264, -1346, 23, -1346, 1270, 1264, -1346, 1275, -1346, -1346, - -1346, 949, 1276, 1280, 8008, 1287, 1288, 1291, -1346, 140, - 1294, -1346, -1346, -1346, 949, -1346, -1346, -1346, -1346, -1346, - -1346, 949, 5182, 5182, 876, 1298, -1346, -1346, -1346, -1346, - -1346, -1346, -1346, -1346, -1346, -1346, -1346, 5182, 5182, 1306, - 1307, 1264, -1346, -1346, 1743, -1346, -1346, -1346, 5182, 5182, - 1361, 5182, -1346, -1346, 1296, -1346, 1297, 5182, 1302, 1303, - 5182, 1094, 1304, -2, -1346, 55, 1896, -1346, -1346, 7483, - 1273, 140, 608, -1346, -1346, -1346, -1346, -1346, -1346, -1346, - 10451, 618, -1346, 858, 1310, 1313, 1329, -1346, 2333, -1346, - 140, -1346, -1346, -1346, -1346, -1346, -1346, -1346, -1346, 11178, - -1346, 9408, -1346, 1330, -1346, -1346, 9247, 621, 664, -1346, - 1328, -1346, 1336, -1346, -1346, 1347, 1331, -1346, -1346, 1331, - 1331, 1278, 1349, 897, 1631, -1346, 1350, -1346, 10950, -1346, - -1346, -1346, -1346, -1346, 1355, -1346, 10950, 10950, 10950, -1346, - -1346, 1357, -1346, 1359, 1345, 1365, 815, 9093, 9213, -1346, - -1346, -1346, -1346, 1362, -1346, 710, 712, 1344, 754, 7625, - -1346, -1346, 698, -1346, -1346, 761, 1371, 1376, 227, 1429, - 937, -1346, -1346, 5182, -1346, 1379, 522, 5182, -1346, -1346, - 11362, -1346, 1384, 1385, -1346, -1346, 416, 865, -1346, -1346, - 2205, -1346, -1346, -1346, 1375, -1346, -1346, -1346, -1346, -1346, - -1346, 9247, -1346, -1346, -1346, 1278, -1346, -1346, -1346, -1346, - -1346, -1346, -1346, -1346, -1346, -1346, -1346, -1346, 1387, 1390, - -1346, -1346, -1346, -1346, -1346, -1346, -1346, 1396, -1346, 1397, - -1346, 11362, 52, 5182, 11362, -1346, 1400, 5182, -1346, 8823, - 9247, -1346, 242, 1401, 1418, -1346, -1346, 1406, 1407, 1388, - 522, 291, 885, -1346, -1346, -1346, -1346, -1346, -1346, 949, - -1346, -1346, 1650, 2348, 1409, 1264, 1278, 1278, 1416, 1417, - 1421, 1425, -1346, -1346, 9408, 1420, -1346, 1497, 5182, 1412, - -1346, -1346, 11272, -1346, 794, -1346, 1415, 11362, 1424, 9483, - -1346, -1346, 1439, -1346, 1442, -1346, 1454, 1461, -1346, 1431, - 1427, 210, 1430, 10950, 9247, -1346, -1346, -1346, 1455, 1264, - 1264, -1346, -1346, -1346, -1346, -1346, 11362, 76, -1346, 476, - -1346, -1346, 5498, -1346, -1346, 1443, 5182, -1346, 5182, 5498, - 227, 10830, 227, 10830, 1462, -1346, 1467, -1346, 1457, -1346, - 5182, 1480, 308, 1475, -1346, -1346, -1346, 1479, -1346, 1483, - 1485, -1346, 5182, 5182, -1346, -1346, 963, 96, -1346, -1346, - 1471, -1346, 963, -1346, -1346, 1784, 10757, 606, -1346, -1346, - 227, 10830, 227, 10830, 210, 1487, 5182, 1477, 210, 210, - 1500, 1502, -1346, -1346, -1346, -1346, 11272, 1498, 963, 8747, - 5182, 11182, 1503, 963, 1510, 1784, 2509, -1346, -1346, -1346, - 1512, -1346, -1346, -1346, -1346, 1493, 522, 1516, -1346, 358, - -1346, -1346, 9788, -1346, 11044, -1346, 11272, -1346, -1346, 1501, - 10954, -1346, -1346, 11182, 227, 2509, 227, 1519, 1520, 522, - 1522, -1346, 1509, 522, 809, -1346, 11044, -1346, -1346, -1346, - 10954, -1346, -1346, -1346, 227, 227, -1346, 568, 5182, -1346, - 824, -1346, -1346, -1346, -1346, -1346, -1346, 522, 606, 1533, - 1514, -1346, -1346, -1346, -1346, 843, -1346, -1346, 1518, 606, - -1346, -1346 -}; - -/* YYPGOTO[NTERM-NUM]. */ -static const yytype_int16 yypgoto[] = -{ - -1346, 4712, 1583, -1346, 1844, -1346, 7, 0, 257, -1346, - -1346, 637, -508, -460, -702, -1047, -1346, -72, 1640, 1181, - -1346, 368, 492, 531, 498, 557, 1092, 1099, 1100, 1106, - 1091, -1346, -277, -697, 5286, -774, -1346, -1346, 722, 565, - -972, 603, -1346, 111, -1346, 496, -1130, -1346, -1346, 208, - -1346, -1322, -943, 325, -1346, -1346, -1346, -1346, 128, -1151, - -1346, -1346, -1346, -1346, -1346, -1346, 400, -1046, -1346, -1346, - -544, -1346, 196, 138, -1346, 243, -1346, -329, -1346, -1346, - -1346, 648, -823, -1346, -1346, 5, -1137, 564, 270, -1346, - -1346, -1346, -130, -1346, 18, -452, 47, -213, -191, 2570, - 4418, -1346, -1346, 131, 355, 744, 1341, 39, 2331, -1346, - -1346, -1346, 276, -1346, 365, 201, 2987, 15, -227, -1346, - -1346, 5549, 5788, -872, -1346, 795, 639, 391, 634, -919, - -1346, -1346, 6180, 970, 781, -314, -1346, -52, -391, 770, - -1346, -1346, -927, -863, -63, -19, -1346, 1233, -1346, 1364, - -99, -296, -180, -136, 762, 840, -1346, 1048, 405, 3462, - 1523, -417, 986, -1346, -1346, 792, -1346, -436, -1346, -73, - -1346, -1346, -1346, -1262, 494, -1346, -1346, -1346, 1230, -1346, - 6, -1346, -1346, -803, -107, -1345, -150, 6282, -1346, 3941, - -1346, 982, -1346, -18, 212, -176, -173, -169, 2, -42, - -40, -32, 586, 10, 22, 49, 50, -166, -163, -160, - -158, -318, -540, -528, -480, -587, -304, -556, -1346, -1346, - -509, 1145, 1154, 1155, 1813, 5019, -577, -507, -497, -488, - -468, -1346, -925, -1029, -1004, -1003, -581, -252, -244, -1346, - -1346, 169, 77, -45, -1346, 3860, -39, -632, 147 -}; - -/* 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 -547 -static const yytype_int16 yytable[] = -{ - 50, 113, 98, 147, 395, 148, 115, 396, 112, 426, - 257, 397, 163, 149, 398, 689, 815, 399, 63, 859, - 400, 1194, 401, 605, 757, 919, 816, 706, 1067, 381, - 382, 113, 113, 408, 50, 437, 98, 610, 1169, 73, - 142, 834, 1035, 1430, 806, 50, 1195, 1196, 117, 1374, - 1228, 50, 63, 158, 739, 150, 1140, 1141, 50, 784, - 803, 250, 1037, 50, 1283, 189, 50, 151, 212, 50, - 1434, 222, 804, 73, 215, 163, 725, 107, 107, 395, - 730, 210, 396, 407, 33, 596, 397, 675, 708, 398, - 423, 359, 399, 807, 152, 400, 33, 401, 156, 1388, - 1389, 472, 474, 808, 198, 321, 684, 50, 333, 1285, - 50, 107, 809, 1233, 688, 623, 467, 50, 1430, 635, - 805, 1142, 33, 639, 589, 113, 565, 1199, 679, 681, - 473, 69, 1348, 210, 33, 1284, 819, 1203, 147, 1203, - 148, 1234, 826, -240, -240, 50, 107, 158, 149, 123, - 633, 444, 1457, 248, 637, 199, 242, 50, 409, 371, - 566, 156, 1147, 403, 456, 69, 433, 170, 715, 1286, - 409, 1390, 210, 803, 1434, 1190, 124, 1462, 1156, 1434, - 50, 50, 33, 158, 1316, 804, 1319, 1321, 1148, 522, - 150, 316, 494, 141, 417, 495, 409, 50, 1157, 729, - 331, 78, 151, 1148, 1434, 50, 478, 158, 409, 243, - 33, 1434, 97, 147, 50, 148, -240, 50, 741, 440, - 160, 143, 433, 149, 113, 928, 978, 709, 673, 152, - 165, 404, 210, 805, 113, 78, 979, 113, 403, 1172, - 1173, 50, 113, 98, 966, 1105, 97, 459, 428, 461, - 850, 850, 431, 33, 166, 50, 50, 146, 158, 63, - 803, 163, 50, 97, 210, 113, 850, 242, 323, 210, - 58, 58, 804, 1299, 955, 185, 77, 33, 97, 788, - 73, 97, 817, 160, 601, 73, 467, 584, 1078, 1388, - 1389, 706, 1151, 807, 272, 1348, 514, 1345, 598, 610, - 415, 144, 1348, 808, 58, 467, 404, 473, 431, 153, - 77, 486, 809, 467, 850, 677, 33, -10, 107, 1223, - 805, 682, 50, 434, 371, 824, 1450, 601, 851, 602, - 1140, 1141, 816, 442, 819, 316, 58, 375, 574, 58, - 50, 50, 794, 868, 575, 219, 168, 156, 1142, 872, - 1531, 409, 708, 376, 1197, 70, 1035, 97, 891, 33, - 33, 1400, 1348, 623, 50, 197, 33, 359, 50, 97, - 596, 1530, 69, 792, 432, 1398, 1037, 470, 648, 583, - 596, 834, 1551, 839, 668, 321, 321, 840, 876, 70, - 409, 907, 394, 185, 845, 1142, 1546, 1479, 623, 521, - 273, 807, 50, 1550, 371, 86, 1410, 623, 735, 833, - 737, 808, 321, 738, 551, 552, 742, 97, 33, 589, - 809, 208, 50, 1487, 340, 844, 1411, -299, 50, 97, - 432, 1108, 1121, 409, 409, 1512, 237, 1514, 1125, 86, - 601, 697, 78, 1488, 210, 918, 1347, 78, 745, 240, - 1259, 1260, 669, 97, 242, 73, 321, 1425, 33, 668, - 1222, 359, 950, 113, 1470, 623, 1471, 476, 50, 160, - 112, 316, 316, 1542, 73, 321, 1194, 50, 706, 371, - 623, 50, 73, 98, 210, 1103, 50, 58, 1088, 113, - 1128, 709, 601, 1543, 113, 977, 979, -542, 316, 63, - 949, 1195, 1196, 1127, 1130, 1080, 861, 548, 647, 610, - 117, 58, 698, 549, 550, 253, 860, 77, 699, 498, - 73, 1142, 77, 1496, 359, 862, 113, 669, 1528, 1501, - 1366, 113, 409, 751, 97, 716, 321, 731, 756, 708, - 486, 717, 316, 732, 486, -12, 576, 470, 409, 959, - 1508, 686, 870, 604, 316, 1526, 316, 467, 107, 316, - 1533, 316, 316, 880, 57, 116, 470, 744, 623, 559, - 560, 904, 439, 745, 470, 385, 700, 990, 359, 359, - 958, 1199, -467, 835, 499, 113, 500, 501, 388, 849, - 849, 386, 1139, 598, 359, 977, 70, 1463, 57, 390, - 50, 324, 885, 50, 389, 849, 272, 111, 745, 1468, - 1299, 1464, 69, 1375, 185, 391, 1468, 78, 521, -468, - 43, 44, 316, 521, 50, 111, 521, 138, 139, 113, - 206, 268, 908, 216, 601, 718, 78, 159, 43, 44, - 47, 48, 359, 50, 78, 511, 86, 113, 750, 190, - 270, 86, 213, 849, 602, 223, 50, 697, 113, 50, - 113, 392, 706, 1064, 1154, 869, 855, 871, 546, 547, - 50, 325, 989, 1106, 1419, 1420, 1527, 393, 709, 1065, - 1155, 111, 78, 271, 8, 9, 10, 11, 12, 1567, - 370, 1427, 77, 97, 43, 44, 1064, 208, 604, 113, - 340, 374, 592, 1568, 326, 546, 903, 327, 626, 1200, - 596, 77, 1192, 50, 50, 328, 33, 210, 796, 77, - 113, 990, 995, 708, 113, 1201, 73, 329, 592, 1154, - 1043, 159, 592, 555, 556, 887, 383, 896, 623, 1200, - 73, 745, 1306, 372, 36, 1291, 219, 546, 893, 833, - 387, 58, 820, 1485, 575, 1295, 823, 77, 1307, 706, - 697, 405, 829, 279, 486, 1494, 1427, 159, 557, 558, - 697, 697, 944, 579, 918, 409, 43, 44, 945, 1362, - 407, 438, 697, 843, 1132, 1308, 883, 846, 567, 1517, - 409, 159, 1090, 424, 340, 890, 47, 48, 945, 892, - 50, 1309, 515, 441, 377, 57, 425, 8, 9, 10, - 11, 12, 802, 50, 225, 604, 481, 226, 470, 745, - 230, 86, 232, 1219, 208, 1341, 359, 1342, 447, 575, - 235, 745, 470, 745, -300, 1351, 70, 457, 111, 33, - 86, 8, 9, 10, 11, 12, 841, 567, 86, 409, - 842, 43, 44, 520, 458, 47, 48, 340, 648, 899, - 1152, 1569, 709, 1187, 113, 1021, 1337, 36, 841, 1344, - 918, 918, 1074, 33, 395, 745, 1352, 396, 1056, 755, - 505, 397, 745, 63, 398, 321, 86, 399, 78, 908, - 400, 601, 401, 111, 553, 554, 50, 47, 48, 113, - 1096, 36, 78, 1097, 73, 1098, 43, 44, 372, 1435, - -112, 340, 340, 50, -112, 745, 759, 760, 761, -418, - 359, 359, 506, 835, 1561, 802, 604, 340, 1081, 881, - 575, 113, 1334, 509, 1227, 514, 1335, 648, 1091, 1570, - 1515, 1048, 107, 113, 1519, 1567, 1058, 113, 948, 945, - 1099, 592, 225, 39, 1099, 171, 172, 42, 1578, 709, - 561, 697, 697, 77, 1579, 562, 43, 44, 563, 486, - 1083, 316, 111, 323, 409, 340, 1214, 77, 564, 1096, - 439, 330, 1097, 982, 1098, 43, 44, 592, 372, 678, - 680, 586, 370, -3, 113, 661, 69, 592, 1357, 1358, - 107, 1099, 1046, 592, 1021, 1412, 945, 50, 50, 50, - 1388, 1389, 802, 1318, 8, 9, 10, 11, 12, 63, - 796, 662, 697, 697, 663, 604, 1229, 1230, 39, 665, - 1056, 666, 42, 667, 403, 242, 323, 409, 113, 671, - 73, 43, 44, 762, 763, 57, 33, 208, 50, 672, - 50, 674, 50, 766, 767, 768, 769, 439, 417, 664, - 409, 1075, 208, 899, 113, 247, 78, 800, 111, 601, - 138, 450, 520, -389, 36, 47, 48, 520, 107, -244, - 520, 43, 44, 50, 764, 765, 1544, 602, 225, 226, - 720, 627, 86, 232, 478, 323, 409, 113, 1058, 817, - 323, 601, 404, 722, 1099, 235, 86, 451, 1057, 724, - 733, 918, 452, 734, 896, 938, 770, 771, 908, 797, - 601, 746, 747, 1171, -14, 604, 47, 48, 799, -301, - 39, 778, 69, 810, 42, 58, 8, 9, 10, 11, - 12, 77, 858, 43, 44, -15, 1302, 857, 864, 39, - 208, 171, 172, 42, 113, 1276, 1277, 1278, 592, 340, - 886, 626, 43, 44, 888, 900, -441, -546, 33, 45, - 912, 924, 917, 918, 717, 926, 929, 47, 48, 1021, - 668, 51, 114, 225, 931, 918, 918, 932, 933, 942, - 1303, 934, 935, 58, 359, 359, 36, 63, 50, 952, - 953, 954, 78, 39, 968, 171, 172, 42, 969, 918, - 128, 1163, 129, 130, 131, 51, 43, 44, 73, 697, - 70, 1081, 970, 43, 44, 971, 145, 697, 697, 697, - 972, 113, 51, 113, 113, 973, 899, 896, 1099, 974, - 1099, 1099, -429, 997, 181, -428, 1038, 205, 669, 623, - 51, 1044, 1040, 340, 340, 39, 107, 178, 179, 42, - 1057, 1047, 1193, 1083, 1057, 1165, 1416, 1068, 43, 44, - 86, 58, 39, 1070, 171, 172, 42, 77, 1069, 1071, - 1079, 918, 1056, 1089, 1093, 43, 44, 114, 937, 1119, - 1021, 174, 1143, 107, 1050, 114, 409, 1144, 256, 261, - 50, 1146, 47, 48, 111, 1145, 138, 139, 73, 1158, - 69, 1174, 1159, 1161, 1162, 113, 1081, 43, 44, 1167, - 439, 359, 1099, 1170, -9, 300, 145, 592, -464, 395, - 546, -11, 396, 745, 114, 337, 397, -3, 205, 398, - 251, 1021, 399, 252, 1021, 400, 107, 401, 265, 1183, - 1058, 1177, 1189, 111, 1181, 215, 70, 1051, 1083, 899, - 1096, 181, 181, 1097, 210, 1098, 43, 44, 1507, 511, - 1210, 494, 50, 50, 1212, 1220, 113, 113, 256, 1215, - 78, 1221, 1224, 1099, 1099, 1231, 51, 1235, 107, 1355, - 1237, 1239, 1021, 1289, 697, 1240, 140, 1021, 205, 39, - 1350, 171, 172, 42, 1241, 1242, 86, 209, 1243, 1245, - 1057, 1267, 43, 44, 210, 1252, 228, 1314, 111, 1081, - 138, 139, 51, 1261, 1262, 1296, 1021, 107, 1297, 57, - 261, 43, 44, 1270, 1271, 261, 256, 256, 374, 1273, - 1274, 1282, 114, -302, 1298, 1304, 884, 436, 1310, 58, - 8, 9, 10, 11, 12, 77, 1312, 726, 1343, 209, - 1332, 1083, 727, 147, 1313, 148, 1317, 1322, 1024, 300, - 78, 73, 1324, 149, 1330, 50, 1331, 113, 73, 1340, - 1333, 300, 33, 321, 1509, 1353, 58, 1082, 403, 266, - 1354, 107, 1278, 1360, 1371, 480, 1021, 568, 209, 1364, - 1365, 1021, 1402, 145, 1382, 50, 50, 1383, 158, 107, - 36, -430, 1057, 114, 1386, 1397, 107, 668, 337, 1404, - 1406, 1407, 603, 622, 1021, 1408, 1021, 340, 340, 1417, - 1021, 1421, 1422, 1021, 70, 50, 1423, 371, 73, 58, - 1424, 1335, 1426, 1361, 632, 77, 1021, 1431, 632, 951, - 1021, 1473, 1436, 1478, 1440, 1444, 404, 1442, 209, 956, - 957, 1438, 1446, 1350, 1449, 57, 1448, 1455, 113, 316, - 1350, 967, 1458, 174, 39, 1574, 107, 1480, 42, 113, - 1469, 58, 1482, 181, 86, 669, 1581, 43, 44, 211, - 209, 1511, 1484, 1513, 1486, 209, 1489, 636, 453, 1491, - 1492, 640, 1493, 256, 1516, 300, 300, 1160, 1500, 256, - 1477, 632, 1477, 713, 1518, 1521, 1522, 1409, 1525, 58, - 58, 47, 48, 1532, 70, 1534, 219, 1536, 1539, 491, - 1350, 1541, 300, 78, 1554, 1555, 1558, 164, 1547, 169, - 78, 211, 175, 176, 177, 1552, 1559, 1553, 1576, 256, - 1477, 1577, 1477, 772, 340, 1580, 776, 1176, 256, 229, - 632, 773, 51, 774, 1095, 1565, 1566, 714, 1451, 58, - 775, 1495, 238, 239, 86, 1288, 114, 1401, 1562, 1356, - 211, 1560, 1472, 209, 58, 1520, 1182, 1191, 300, 1049, - 114, 1370, 1204, 300, 920, 300, 300, 1077, 996, 1092, - 78, 863, 58, 914, 208, 337, 111, 1076, 77, 58, - 1305, 711, 780, 1096, 927, 77, 1097, 476, 1098, 43, - 44, 781, 782, 1265, 1266, 39, 1268, 171, 172, 42, - 0, 0, 1272, 0, 0, 1275, 0, 0, 43, 44, - 211, 1451, 649, 57, 0, 1451, 1451, 1320, 568, 568, - 1137, 1138, 0, 0, 439, 0, 300, 454, 2, 202, - 4, 5, 6, 7, 0, 406, 0, 632, 337, 58, - 209, 622, 211, 1540, 0, 77, 0, 211, 0, 0, - 1082, 603, 1024, 0, 603, 0, 209, 70, 39, 0, - 178, 179, 42, 0, 70, 0, 1556, 0, 0, 0, - 1556, 43, 44, 632, 0, 0, 592, 0, 592, 0, - 209, 1185, 1186, 632, 0, 622, 0, 0, 111, 632, - 138, 139, 632, 632, 1573, 0, 37, 600, 38, 601, - 0, 43, 44, 57, 0, 47, 48, 86, 632, 0, - 256, 0, 0, 0, 86, 0, 592, 0, 592, 602, - 0, 256, 0, 719, 70, 0, 0, 836, 728, 39, - 0, 178, 179, 42, 0, 211, 0, 0, 0, 0, - 0, 114, 43, 44, 0, 1082, 852, 0, 2, 202, - 4, 5, 6, 7, 0, 0, 632, 909, 622, 867, - 0, -3, 0, 1363, 714, 714, 0, 0, 1505, 0, - 409, 0, 173, 0, 86, 0, 47, 48, 1394, 224, - 0, 0, 0, 206, 216, 508, 0, 510, 513, 588, - 0, 599, 0, 0, 337, 0, 516, 517, 525, 0, - 0, 209, 526, 527, 528, 0, 0, 0, 630, 631, - 510, 510, 0, 0, 1387, 0, 37, 1395, 38, 791, - 0, 173, 211, 0, 173, 0, 529, 0, 530, 0, - 531, 532, 0, 438, 568, 0, 209, 2, 202, 4, - 5, 6, 7, 0, 632, 209, 962, 510, 1082, 0, - 0, 603, 525, 0, 0, 0, 526, 527, 528, 0, - 0, 0, 211, 838, 603, 1433, 57, 0, 411, 0, - 1437, 0, 0, 57, 0, 419, 0, 0, 1323, 0, - 529, 856, 530, 0, 531, 1287, 1325, 1326, 1327, 510, - 0, 0, 8, 9, 10, 11, 12, 0, 111, 1461, - 138, 450, 0, 209, 0, 37, 0, 38, 0, 0, - 0, 43, 44, 209, 0, 0, 300, 0, 209, 0, - 0, 0, 0, 0, 33, 0, 0, 0, 173, 0, - 0, 0, 0, 57, 0, 0, 0, 0, 0, 0, - 337, 411, 0, 0, 0, 114, 0, 1052, 0, 0, - 0, 0, 36, 0, 916, 0, 0, 39, 491, 909, - 909, 42, 0, 0, 714, 0, 0, 0, 0, 0, - 43, 44, 0, 0, 114, 300, 173, 0, 0, 0, - 0, 337, 0, 211, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 45, 1545, 0, 573, - 0, 0, 0, 1545, 47, 48, 209, 0, 577, 0, - 0, 580, 0, 337, 0, 0, 0, 0, 211, 1545, - 0, 0, 454, 1545, 0, 0, 0, 211, 0, 0, - 0, 0, 0, 0, 632, 632, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 300, 1456, 173, 0, 0, 0, 510, 510, - 510, 510, 510, 510, 510, 510, 510, 510, 510, 510, - 510, 510, 510, 510, 510, 510, 0, 411, 173, 0, - 0, 419, 173, 0, 0, 211, 0, 0, 0, 0, - 0, 0, 649, 0, 0, 211, 0, 0, 1000, 1052, - 211, 1052, 0, 1052, 0, 0, 0, 0, 0, 0, - 1164, 1166, 1168, 0, 0, 0, 0, 0, 114, 0, - 0, 0, 0, 0, 909, 0, 0, 0, 0, 0, - 0, 0, 0, 1066, 256, 0, 0, 0, 0, 0, - 8, 9, 10, 11, 12, 0, 901, 0, 902, 0, - 39, 0, 178, 179, 42, 0, 905, 906, 0, 411, - 0, 911, 0, 43, 44, 337, 0, 0, 0, 0, - 0, 649, 33, 0, 0, 0, 209, 0, 921, 0, - 0, 0, 0, 925, 0, 0, 0, 0, 211, 1050, - 39, 409, 178, 179, 42, 0, 0, 47, 48, 0, - 36, 74, 599, 43, 44, 39, 0, 178, 179, 42, - 1051, 0, 0, 8, 9, 10, 11, 12, 43, 44, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 180, - 300, 0, 510, 0, 0, 74, 0, 47, 48, 0, - 0, 114, 0, 0, 600, 33, 601, 0, 0, 1052, - 573, 573, 47, 48, 0, 0, 0, 510, 0, 0, - 0, 0, 632, 0, 0, 0, 0, 114, 0, 0, - 218, 0, 1000, 36, 0, 0, 0, 0, 39, 0, - 178, 179, 42, 0, 0, 0, 0, 510, 0, 0, - 0, 43, 44, 39, 0, 178, 179, 42, 1207, 0, - 985, 0, 986, 987, 988, 0, 43, 44, 632, 632, - 0, 0, 0, 0, 0, 0, 0, 1050, 0, 409, - 300, 1039, 0, 0, 0, 47, 48, 0, 0, 0, - 0, 0, 255, 0, 0, 0, 0, 1045, 173, 0, - 47, 48, 0, 0, 874, 0, 0, 0, 878, 0, - 0, 1052, 0, 0, 0, 346, 0, 173, 211, 0, - 1072, 0, 114, 0, 0, 0, 0, 0, 0, 0, - 173, 0, 0, 0, 8, 9, 10, 11, 12, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1264, 8, - 9, 10, 11, 12, 1094, 0, 0, 0, 0, 1104, - 261, 114, 0, 0, 1107, 0, 33, 0, 0, 1112, - 1113, 0, 0, 0, 1115, 0, 1116, 1117, 0, 0, - 1120, 33, 0, 0, 256, 0, 0, 446, 0, 1135, - 0, 0, 0, 0, 36, 632, 0, 0, 0, 39, - 66, 118, 74, 42, 0, 1149, 1150, 74, 0, 36, - 261, 0, 43, 44, 39, 0, 178, 179, 42, 0, - 510, 0, 0, 0, 0, 114, 573, 43, 44, 0, - 0, 0, 510, 0, 66, 1415, 0, 1178, 713, 0, - 1180, 0, 0, 114, 0, 0, 47, 48, 0, 0, - 114, 157, 114, 1505, 114, 409, 0, 0, 0, 0, - 0, 47, 48, 0, 0, 0, 0, 0, 0, 217, - 0, 510, 0, 533, 534, 535, 536, 537, 538, 539, - 540, 541, 542, 543, 0, 0, 1506, 261, 0, 0, - 0, 0, 114, 1213, 114, 0, 0, 0, 591, 1217, - 1218, 0, 0, 0, 218, 0, 249, 544, 1225, 0, - 114, 0, 0, 1232, 0, 0, 1506, 1506, 1236, 0, - 209, 510, 0, 0, 591, 0, 0, 0, 591, 0, - 0, 1244, 0, 300, 0, 0, 0, 0, 0, 173, - 0, 0, 0, 0, 0, 322, 1506, 1251, 0, 1253, - 1254, 1255, 1256, 249, 342, 8, 9, 10, 11, 12, - 0, 0, 0, 0, 1263, 0, 1149, 0, 0, 0, - 209, 0, 0, 0, 0, 0, 0, 74, 0, 0, - 0, 402, 0, 0, 0, 0, 0, 33, 0, 0, - 0, 346, 0, 0, 0, 1110, 74, 422, 1292, 1293, - 427, 429, 0, 0, 74, 157, 0, 0, 0, 0, - 0, 1123, 0, 0, 0, 36, 0, 510, 510, 0, - 39, 346, 178, 179, 42, 0, 445, 0, 0, 0, - 448, 218, 449, 43, 44, 455, 0, 0, 0, 0, - 346, 66, 74, 0, 0, 0, 469, 209, 0, 0, - 0, 0, 0, 0, 0, 0, 477, 0, 0, 180, - 0, 0, 1328, 1329, 429, 0, 0, 47, 48, 0, - 0, 0, 1339, 0, 0, 0, 0, 0, 173, 0, - 0, 173, 173, 173, 0, 346, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 411, 0, 211, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 8, 9, 10, - 11, 12, 249, 0, 0, 0, 1378, 590, 1379, 1380, - 1381, 0, 0, 625, 0, 0, 0, 591, 346, 0, - 1385, 0, 211, 0, 0, 0, 0, 0, 1396, 33, - 0, 169, 0, 634, 0, 0, 0, 634, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 591, 0, 0, 0, 36, 1418, 0, - 0, 0, 39, 591, 178, 179, 42, 0, 0, 591, - 0, 0, 346, 346, 0, 43, 44, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 469, 79, 346, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 211, - 342, 255, 1459, 1460, 0, 469, 411, 346, 0, 47, - 48, 0, 0, 469, 0, 1465, 0, 0, 74, 0, - 0, 79, 1465, 173, 0, 0, 0, 0, 510, 0, - 692, 0, 74, 429, 0, 0, 346, 0, 0, 1490, - 702, 0, 0, 0, 0, 0, 0, 0, 0, 707, - 0, 66, 0, 0, 0, 0, 220, 1504, 0, 0, - 0, 0, 1510, 429, 0, 0, 0, 429, 0, 0, - 0, 0, 0, 0, 346, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 510, 0, 0, 0, 342, 1537, 0, 1538, 0, 0, - 0, 0, 510, 510, 0, 0, 0, 0, 0, 1368, - 346, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 346, 346, 0, 0, 591, 0, 510, 218, 0, 0, - 0, 0, 346, 0, 173, 1563, 1564, 0, 783, 0, - 0, 350, 0, 0, 0, 0, 0, 0, 1571, 1572, - 0, 0, 0, 0, 0, 0, 634, 795, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 813, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 173, 0, 0, 173, 0, - 0, 0, 590, 0, 0, 0, 74, 837, 510, 0, - 0, 0, 590, 0, 0, 0, 0, 0, 634, 0, - 0, 342, 342, 0, 0, 0, 173, 0, 0, 0, - 346, 0, 0, 0, 0, 0, 0, 342, 79, 0, - 0, 0, 0, 79, 275, 276, 173, 277, 0, 0, - 0, 173, 0, 0, 0, 0, 692, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 469, 0, 0, - 0, 346, 0, 278, 0, 0, 0, 0, 0, 279, - 173, 469, 0, 280, 0, 342, 281, 282, 272, 283, - 284, 285, 43, 44, 913, 286, 287, 429, 0, 0, - 0, 0, 0, 591, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 288, 0, - 377, 346, 346, 707, 346, 346, 47, 48, 290, 291, - 292, 293, 0, 0, 593, 0, 0, 0, 0, 777, - 220, 0, 74, 0, 0, 0, 0, 0, 0, 0, - 173, 0, 0, 0, 0, 173, 0, 0, 0, 692, - 593, 0, 0, 0, 593, 0, 0, 0, 0, 692, - 692, 0, 0, 634, 0, 0, 965, 0, 173, 0, - 173, 692, 346, 346, 173, 0, 0, 173, 0, 0, - 0, 976, 0, 0, 0, 0, 0, 0, 0, 0, - 173, 0, 0, 0, 173, 0, 0, 0, 0, 0, - 0, 0, 0, 79, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 350, 0, 0, - 0, 0, 79, 0, 0, 0, 0, 0, 0, 0, - 79, 0, 0, 0, 0, 66, 0, 0, 275, 276, - 0, 277, 0, 0, 0, 346, 0, 350, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 220, 0, 795, - 0, 0, 87, 0, 0, 0, 350, 278, 79, 0, - 0, 0, 0, 645, 0, 138, 139, 280, 0, 1073, - 281, 282, 272, 283, 284, 285, 43, 44, 0, 286, - 287, 0, 429, 118, 0, 0, 87, 0, 0, 0, - 707, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 74, 350, 288, 0, 646, 0, 647, 378, 0, 0, - 47, 48, 290, 291, 292, 293, 0, 0, 0, 0, - 0, 221, 590, 0, 0, 0, 0, 0, 0, 0, - 346, 0, 346, 0, 0, 427, 0, 0, 0, 0, - 692, 692, 0, 342, 342, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 346, - 0, 66, 0, 593, 350, 0, 0, 346, 346, 346, - 0, 0, 0, 0, 0, 0, 0, 0, 346, 346, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 74, 0, 0, 0, 0, 0, 0, 0, 0, 593, - 0, 692, 692, 0, 0, 0, 362, 0, 0, 593, - 0, 0, 1198, 0, 0, 593, 0, 0, 350, 350, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 350, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 350, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 79, 0, 0, 0, 0, 0, - 0, 218, 0, 0, 707, 0, 0, 0, 79, 0, - 0, 0, 350, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 87, 0, 0, 0, 0, 87, 0, - 0, 0, 0, 0, 0, 346, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 350, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 346, 0, 0, 0, 0, 66, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 74, 0, 0, 350, 0, 0, 0, - 74, 0, 591, 0, 591, 0, 350, 350, 0, 692, - 593, 707, 0, 220, 0, 0, 118, 0, 350, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 594, - 0, 0, 0, 0, 0, 221, 0, 0, 692, 0, - 0, 0, 591, 0, 591, 0, 692, 692, 692, 0, - 0, 0, 0, 0, 0, 594, 0, 342, 342, 594, - 74, 0, 0, 0, 0, 0, 0, 0, 0, 1349, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 79, 0, 0, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 0, 350, 0, 87, 0, - 0, 118, 0, 0, 0, 0, 0, 33, 0, 0, - 0, 0, 362, 0, 0, 0, 0, 87, 0, 0, - 0, 0, 0, 0, 0, 87, 0, 0, 0, 0, - 0, 162, 0, 275, 276, 36, 277, 350, 0, 0, - 1399, 0, 362, 0, 0, 0, 214, 0, 0, 0, - 0, 0, 221, 0, 0, 0, 0, 0, 0, 0, - 0, 362, 278, 87, 0, 0, 0, 0, 279, 593, - 0, 0, 280, 0, 342, 281, 282, 272, 283, 284, - 285, 43, 44, 0, 286, 287, 0, 350, 350, 127, - 350, 350, 0, 0, 162, 0, 0, 0, 262, 0, - 0, 0, 0, 692, 118, 0, 362, 288, 79, 377, - 0, 0, 378, 0, 0, 47, 48, 290, 291, 292, - 293, 0, 1349, 0, 162, 0, 0, 0, 0, 1349, - 0, 1476, 0, 1476, 368, 0, 0, 373, 0, 0, - 0, 0, 0, 0, 127, 0, 0, 0, 350, 350, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 127, 0, 127, 0, 0, 0, 0, 0, 594, 362, - 0, 1476, 0, 1476, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 162, 0, 267, 0, 1349, - 0, 0, 0, 0, 0, 0, 1535, 214, 0, 0, - 0, 0, 0, 0, 594, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 594, 0, 0, 0, 0, 0, - 594, 350, 0, 362, 362, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 373, 0, 0, 0, 0, 362, - 0, 162, 0, 0, 0, 0, 127, 0, 127, 127, - 0, 0, 0, 127, 0, 127, 127, 0, 362, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 523, 87, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 162, 0, 0, 87, 0, 0, 79, 362, 0, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, 0, - 0, 28, 29, 30, 0, 0, 350, 597, 350, 127, - 0, 33, 624, 0, 0, 362, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 350, 0, 0, 0, 36, - 0, 0, 0, 350, 350, 350, 203, 41, 0, 0, - 0, 362, 0, 0, 350, 350, 0, 0, 0, 0, - 0, 362, 362, 0, 0, 594, 79, 0, 221, 0, - 0, 0, 0, 362, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 127, 0, 0, 0, 0, - 0, 47, 48, 0, 162, 162, 0, 0, 0, 0, - 368, 0, 0, 0, 127, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 162, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 87, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 220, 0, 710, - 0, 0, 0, 0, 0, 0, 127, 0, 0, 0, - 0, 362, 0, 0, 0, 162, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 523, 0, 523, - 0, 350, 523, 0, 162, 523, 0, 0, 0, 0, - 0, 0, 0, 0, 368, 0, 0, 0, 0, 0, - 0, 0, 362, 0, 0, 0, 0, 0, 0, 0, - 350, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 79, - 0, 0, 0, 0, 594, 0, 79, 0, 593, 0, - 593, 0, 0, 0, 0, 162, 0, 0, 0, 0, - 0, 0, 362, 362, 0, 362, 362, 368, 0, 0, - 798, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 87, 0, 0, 0, 0, 593, 0, - 593, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 597, 0, 207, 0, 79, 0, 0, 0, - 0, 0, 597, 227, 0, 231, 0, 233, 0, 0, - 0, 368, 368, 362, 362, 236, 0, 0, 0, 0, - 0, 0, 127, 127, 0, 0, 0, 368, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 207, 0, 231, 233, - 236, 0, 0, 0, 0, 127, 0, 0, 127, 127, - 523, 127, 0, 127, 127, 0, 0, 0, 127, 127, - 0, 0, 0, 0, 0, 368, 0, 910, 0, 0, - 0, 0, 0, 0, 0, 207, 362, 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, 127, 710, 0, 0, 127, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 975, 0, 0, - 8, 9, 10, 11, 12, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 207, 0, 231, 233, 236, - 0, 87, 0, 0, 0, 0, 0, 0, 0, 0, - 275, 276, 33, 277, 0, 624, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 207, 0, 0, - 0, 362, 207, 362, 0, 0, 0, 0, 0, 278, - 36, 0, 0, 0, 0, 279, 0, 0, 0, 280, - 0, 0, 281, 282, 272, 283, 284, 285, 43, 44, - 362, 286, 287, 0, 0, 0, 0, 0, 362, 362, - 362, 0, 0, 0, 0, 0, 0, 0, 0, 362, - 362, 0, 0, 0, 288, 0, 377, 0, 0, 0, - 0, 87, 336, 48, 290, 291, 292, 293, 0, 0, - 207, 0, 0, 0, 0, 0, 0, 0, 0, 368, - 275, 276, 0, 277, 523, 0, 0, 0, 154, 0, - 207, 0, 0, 0, 0, 0, 628, 0, 233, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 278, - 236, 0, 0, 0, 162, 279, 0, 0, 0, 280, - 710, 0, 281, 282, 272, 283, 284, 285, 43, 44, - 0, 286, 287, 0, 241, 0, 0, 0, 0, 0, - 0, 0, 221, 0, 246, 0, 0, 0, 0, 0, - 207, 0, 597, 0, 288, 0, 377, 0, 0, 0, - 0, 748, 47, 48, 290, 291, 292, 293, 0, 0, - 207, 0, 0, 368, 368, 207, 362, 207, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 207, 0, 0, 207, 207, 0, 0, - 0, 0, 0, 207, 0, 362, 0, 0, 0, 0, - 384, 0, 0, 0, 0, 0, 0, 207, 0, 0, - 0, 0, 0, 127, 87, 207, 0, 0, 0, 0, - 0, 87, 416, 594, 0, 594, 0, 0, 0, 127, - 0, 0, 127, 127, 0, 1133, 430, 0, 8, 9, - 10, 11, 12, 0, 0, 435, 0, 523, 0, 0, - 0, 0, 0, 0, 0, 443, 0, 0, 0, 0, - 0, 0, 0, 594, 0, 594, 0, 0, 275, 276, - 33, 277, 0, 0, 460, 0, 0, 0, 0, 471, - 0, 87, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 479, 0, 710, 0, 0, 278, 36, 0, - 493, 0, 497, 279, 0, 127, 0, 280, 0, 0, - 281, 282, 272, 283, 284, 285, 43, 44, 127, 286, - 287, 524, 0, 127, 127, 0, 0, 0, 207, 0, - 628, 233, 236, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 288, 0, 377, 0, 0, 0, 0, 0, - 1134, 48, 290, 291, 292, 293, 0, 0, 0, 0, - 0, 0, 582, 207, 628, 0, 0, 587, 0, 0, - 523, 0, 207, 0, 0, 0, 0, 0, 0, 0, - 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 710, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 641, 0, 0, 0, 642, 643, 0, 644, - 0, 0, 0, 0, 0, 0, 655, 656, 0, 657, - 658, 0, 659, 0, 660, 0, 0, 0, 0, 0, - 207, 0, 0, 275, 276, 0, 277, 368, 368, 0, - 207, 582, 127, 0, 0, 207, 0, 0, 0, 676, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 127, 278, 0, 0, 0, 0, 0, 279, 0, - 0, 0, 280, 687, 0, 281, 282, 272, 283, 284, - 285, 43, 44, 0, 286, 287, 0, 0, 0, 0, - 0, 0, 332, 363, 0, 0, 0, 0, 701, 0, - 0, 0, 0, 0, 0, 705, 0, 288, 0, 377, - 460, 0, 937, 0, 0, 47, 48, 290, 291, 292, - 293, 207, 0, 0, 412, 0, 0, 0, 0, 214, - 0, 412, 0, 207, 0, 0, 0, 0, 0, 0, - 0, 0, 275, 276, 0, 277, 0, 0, 0, 0, - 743, 207, 0, 0, 0, 0, 0, 127, 0, 0, - 0, 0, 754, 0, 368, 0, 0, 0, 0, 0, - 0, 278, 0, 0, 0, 207, 0, 279, 0, 214, - 0, 280, 0, 0, 281, 282, 272, 283, 284, 285, - 43, 44, 0, 286, 287, 0, 0, 412, 0, 779, - 0, 275, 276, 0, 277, 0, 0, 0, 789, 0, - 0, 790, 0, 0, 0, 0, 288, 0, 377, 0, - 0, 523, 0, 523, 47, 48, 290, 291, 292, 293, - 278, 0, 0, 811, 0, 0, 279, 0, 0, 0, - 280, 0, 0, 281, 282, 272, 283, 284, 285, 43, - 44, 207, 286, 287, 0, 412, 373, 0, 0, 0, - 0, 523, 0, 523, 412, 578, 0, 412, 581, 0, - 0, 0, 0, 0, 0, 507, 363, 377, 854, 0, - 614, 0, 0, 47, 48, 290, 291, 292, 293, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 162, 207, 0, 0, 638, 0, 0, 0, - 0, 0, 0, 0, 207, 889, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 412, 0, 0, 0, 412, 0, 0, - 0, 0, 0, 241, 0, 0, 0, 0, 0, 0, - 314, 0, 0, 0, 0, 0, 0, 0, 922, 923, - 338, 0, 0, 0, 0, 0, 0, 0, 930, 363, - 0, 380, 380, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 943, 0, 0, 0, 0, 947, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 207, 0, 0, 0, 412, 0, 0, 363, 0, - 0, 1, 2, 202, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, -307, 980, - 28, 29, 30, 31, 0, 0, 981, 32, 0, 475, - 33, 0, 0, 363, 0, 0, 0, 0, 0, 0, - 0, 0, 983, 0, 984, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 994, 36, 0, - 37, 0, 38, 998, 0, 40, 41, 0, 0, -307, - 0, 0, 0, 0, 1041, 0, 412, 412, 1042, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 793, 363, 0, 0, 0, - 0, 0, 0, 0, 46, 0, 207, 0, 0, 614, - 47, 48, 614, 614, 0, 0, 0, 0, 0, 614, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 832, - 0, 363, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 363, 0, 0, 0, 0, 0, 0, 0, 0, - 363, 363, 275, 276, 380, 277, 0, 0, 0, 0, - 0, 0, 1114, 0, 0, 0, 363, 0, 0, 0, - 412, 875, 0, 0, 412, 879, 0, 0, 0, 0, - 0, 278, 0, 882, 0, 0, 0, 279, 0, 0, - 0, 280, 0, 352, 281, 282, 272, 283, 284, 285, - 43, 44, 0, 286, 287, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 363, 614, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 512, 314, 377, 1179, - 0, 0, 0, 0, 47, 48, 290, 291, 292, 293, - 0, 0, 0, 0, 0, 0, 0, 704, 0, 0, - 0, 0, 363, 0, 0, 0, 0, 207, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1209, 0, 0, 0, 0, 1211, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1216, 0, 0, 0, - 740, 0, 412, 0, 0, 0, 0, 0, 0, 0, - 749, 0, 0, 0, 0, 740, 0, 207, 740, 614, - 1238, 614, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 758, 614, 1246, 0, 0, 0, 1247, 0, 0, - 1248, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1257, 1258, 0, 0, - 0, 787, 0, 0, 0, 0, 0, 0, 338, 0, - 0, 0, 0, 749, 1269, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 352, 0, 812, 0, - 0, 352, 352, 0, 207, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 363, 0, - 0, 0, 352, 0, 0, 412, 352, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 614, 614, 0, - 853, 0, 0, 0, 0, 0, 0, 0, 380, 1315, - 0, 0, 353, 0, 0, 0, 0, 0, 0, 363, - 0, 0, 0, 207, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 412, 1111, 0, 0, 0, 0, 0, 0, 352, - 0, 363, 0, 0, 0, 0, 0, 412, 1124, 0, - 614, 614, 1131, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 363, 363, 0, 0, 0, 0, 0, 352, - 0, 0, 0, 0, 0, 0, 0, 0, 1372, 740, - 1373, 0, 0, 0, 0, 0, 0, 0, 352, 749, - 1376, 936, 1377, 0, 939, 0, 0, 0, 0, 0, - 946, 0, 0, 0, 0, 0, 0, 1384, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1403, 1405, 412, 0, 412, - 0, 412, 0, 352, 0, 0, 412, 0, 1413, 0, - 0, 963, 964, 1414, 0, 0, 1216, 0, 0, 0, - 0, 0, 614, 0, 0, 0, 0, 338, 0, 0, - 0, 0, 1432, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1439, 0, 0, 1441, 0, 1443, 1445, 1447, - 0, 0, 0, 0, 0, 353, 0, 0, 0, 0, - 353, 353, 0, 363, 0, 352, 352, 0, 0, 352, - 992, 0, 0, 0, 380, 0, 0, 0, 0, 0, - 0, 353, 0, 275, 276, 353, 277, 1481, 0, 1483, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1216, - 0, 352, 0, 0, 352, 338, 0, 0, 0, 1499, - 0, 352, 278, 352, 0, 0, 0, 352, 279, 0, - 352, 352, 280, 0, 0, 281, 282, 272, 283, 284, - 285, 43, 44, 0, 286, 287, 352, 0, 0, 0, - 314, 0, 412, 0, 0, 0, 338, 412, 353, 0, - 0, 0, 0, 380, 0, 352, 0, 515, 939, 377, - 363, 740, 0, 0, 0, 47, 48, 290, 291, 292, - 293, 352, 0, 0, 0, 0, 0, 0, 353, 0, - 0, 1118, 0, 0, 352, 0, 352, 0, 0, 0, - 0, 0, 1136, 0, 0, 0, 0, 353, 0, 0, - 0, 0, 0, 0, 0, 0, 363, 363, 0, 0, - 0, 0, 380, 0, 1153, 0, 0, 0, 0, 0, - 0, 0, 352, 0, 0, 0, 0, 0, 0, 939, - 939, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 125, 0, 353, 0, 0, 412, 1369, 0, 0, 412, - 0, 0, 0, 0, 0, 0, 1184, 0, 352, 0, - 0, 0, 0, 0, 354, 0, 0, 0, 352, 352, - 0, 0, 352, 0, 352, 352, 0, 0, 0, 0, - 352, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 234, 0, 0, 0, 0, - 0, 0, 0, 0, 353, 353, 0, 0, 353, 939, - 0, 244, 0, 245, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 853, 0, 0, 363, 0, 0, 0, 0, 0, 0, - 353, 0, 0, 353, 275, 276, 0, 277, 1249, 1250, - 353, 0, 353, 0, 0, 0, 353, 0, 0, 353, - 353, 0, 0, 0, 0, 0, 0, 0, 352, 0, - 0, 0, 0, 278, 0, 353, 0, 0, 0, 279, - 0, 0, 0, 280, 0, 0, 281, 282, 272, 283, - 284, 285, 43, 44, 353, 286, 287, 0, 0, 413, - 414, 0, 0, 0, 418, 0, 420, 421, 0, 352, - 353, 0, 0, 0, 0, 0, 0, 0, 288, 0, - 377, 0, 0, 353, 412, 353, 703, 48, 290, 291, - 292, 293, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 352, 0, 0, 352, 0, 0, 354, 0, 0, - 0, 0, 354, 354, 412, 412, 0, 0, 0, 352, - 352, 353, 352, 352, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 354, 0, 0, 0, 354, 0, 0, - 0, 0, 0, 0, 412, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 353, 0, 1359, - 0, 0, 0, 740, 0, 0, 0, 353, 353, 0, - 0, 353, 0, 353, 353, 0, 0, 0, 0, 353, - 352, 352, 0, 0, 0, 0, 0, 0, 0, 275, - 276, 0, 277, 0, 0, 0, 0, 0, 0, 0, - 354, 0, 0, 0, 0, 0, 585, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 278, 0, - 0, 0, 0, 0, 279, 629, 0, 0, 280, 0, - 354, 281, 282, 272, 283, 284, 285, 43, 44, 0, - 286, 287, 0, 0, 0, 0, 0, 0, 0, 354, - 0, 0, 0, 352, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 288, 0, 377, 0, 353, 0, 0, - 0, 336, 48, 290, 291, 292, 293, 670, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 354, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 353, 0, - 0, 0, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 0, 0, 28, 29, 30, 0, 0, 0, - 353, 0, 0, 353, 33, 894, 0, 0, 352, 0, - 352, 0, 0, 0, 0, 0, 354, 354, 353, 353, - 354, 353, 353, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 36, 0, 0, 0, 0, 352, 0, 40, - 41, 0, 0, 0, 0, 352, 352, 352, 0, 0, - 0, 0, 354, 0, 0, 354, 352, 352, 314, 0, - 0, 0, 354, 0, 354, 0, 0, 0, 354, 0, - 0, 354, 354, 0, 0, 0, 0, 0, 736, 353, - 353, 0, 895, 0, 47, 48, 0, 354, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 785, 786, 0, 354, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 354, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 354, 818, 354, 0, 821, - 822, 0, 825, 0, 827, 828, 0, 0, 0, 830, - 831, 0, 353, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 354, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 352, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 873, 0, 0, 0, 877, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 354, - 0, 0, 352, 0, 0, 0, 0, 0, 0, 354, - 354, 0, 0, 354, 0, 354, 354, 0, 0, 0, - 0, 354, 0, 0, 0, 0, 0, 0, 0, 0, - 352, 0, 352, 0, 0, 0, 0, 353, 0, 353, - 0, 0, 0, 0, 0, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 352, 353, 28, 29, 30, - 352, 0, 352, 0, 353, 353, 353, 33, 0, 0, - 0, 0, 0, 0, 0, 353, 353, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 36, 0, 0, 0, 354, - 0, 0, 40, 41, 0, 0, 0, 0, 0, 0, - -541, 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, 25, 26, 27, - 354, 247, 28, 29, 30, 31, 0, 47, 48, 32, - 0, 0, 33, 34, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 354, 0, 0, 354, 0, 35, 0, 0, - 36, 0, 37, 0, 38, 39, 0, 40, 41, 42, - 354, 354, 0, 354, 354, 0, 0, 0, 43, 44, - 0, 0, 353, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, -307, 45, 0, 46, 0, 0, 0, - 0, 353, 47, 48, 0, 33, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 354, 354, 0, 0, 0, 0, 0, 0, 353, - 0, 353, 0, 36, 1109, 0, 0, 0, 0, 0, - 0, 0, 0, 0, -307, 0, 0, 0, 0, 0, - 1122, 0, 0, 1126, 1129, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 353, 0, 0, 0, 0, 353, - 0, 353, 0, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 0, 354, 334, 29, 30, 0, 0, - 0, 0, 0, 0, 0, 33, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1188, 0, 0, 0, - 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, - 203, 41, 0, 0, 1205, 1206, 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, 25, 26, 27, 0, 0, 28, 29, 30, - 31, 0, 0, 0, 32, 47, 48, 33, 34, 354, - 0, 354, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1126, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 35, 0, 0, 36, 0, 37, 354, 38, - 39, 0, 40, 41, 42, 0, 354, 354, 354, 0, - 0, 0, 0, 43, 44, 0, 0, 354, 354, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 45, - 0, 46, 0, 1290, 0, -545, 0, 47, 48, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1300, 0, 0, 0, 1, 2, 202, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 0, 0, 28, 29, 30, 31, 0, - 0, 0, 32, 275, 276, 33, 1001, 1002, 0, 1003, - 0, 0, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, - 0, 0, 0, 1012, 0, 0, 0, 1013, 1014, 0, - 1015, 0, 278, 36, 0, 37, 0, 38, 1016, 0, - 1017, 1018, 1019, 0, 354, 281, 282, 272, 283, 284, - 285, 43, 44, 0, 286, 287, 0, 0, 1367, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 354, 0, 0, 0, 288, 0, 289, - 0, 0, 168, 0, 0, 47, 48, 290, 291, 292, - 293, 0, 0, 0, 0, 1020, 0, 0, 0, 0, - -134, 354, 0, 354, 0, 0, 0, 0, 1, 2, - 202, 4, 5, 6, 7, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 0, 354, 28, 29, 30, - 31, 354, 0, 354, 32, 275, 276, 33, 277, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, -308, - 0, 0, 0, 0, 278, 36, 0, 37, 0, 38, - 279, 33, 40, 41, 280, 0, 0, 281, 282, 272, - 283, 284, 285, 43, 44, 0, 286, 287, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 36, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 288, - -308, 289, 0, 0, 0, 0, 0, 47, 48, 290, - 291, 292, 293, 0, 0, 0, 0, 0, 0, 0, - 0, 0, -134, 1, 2, 202, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - 0, 0, 28, 29, 30, 31, 0, 0, 0, 32, - 275, 276, 33, 277, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 0, 0, 28, 29, 30, 278, - 36, 0, 37, 0, 38, 279, 33, 40, 41, 280, - 0, 0, 281, 282, 272, 283, 284, 285, 43, 44, - 0, 286, 287, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 36, 0, 0, 0, 0, 0, - 0, 40, 41, 0, 288, 0, 289, 0, 0, 0, - 0, 0, 47, 48, 290, 291, 292, 293, 2, 202, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 0, 0, 334, 29, 30, 0, - 0, 0, 0, 0, 275, 276, 33, 277, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 0, 0, - 334, 29, 30, 278, 36, 0, 37, 0, 38, 279, - 33, 40, 41, 280, 0, 0, 281, 282, 272, 283, - 284, 285, 43, 44, 0, 286, 287, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 36, 0, - 0, 0, 0, 0, 0, 40, 41, 0, 288, 0, - 335, 0, 0, 0, 0, 748, 336, 48, 290, 291, - 292, 293, 2, 202, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 0, 0, - 334, 29, 30, 0, 0, 0, 0, 0, 275, 276, - 33, 277, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 0, 0, 28, 29, 30, 278, 36, 0, - 37, 0, 38, 279, 33, 40, 41, 280, 0, 0, - 281, 282, 272, 283, 284, 285, 43, 44, 0, 286, - 287, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 36, 0, 0, 0, 0, 0, 0, 203, - 41, 0, 288, 0, 335, 0, 0, 0, 0, 748, - 47, 48, 290, 291, 292, 293, 2, 202, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 0, 0, 334, 29, 30, 0, 0, 0, - 0, 0, 275, 276, 33, 277, 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, 278, 36, 0, 37, 0, 38, 279, 0, 40, - 41, 280, 0, 0, 281, 282, 272, 283, 284, 285, - 43, 44, 0, 286, 287, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 288, 0, 335, 0, - 0, 0, 0, 0, 336, 48, 290, 291, 292, 293, - 2, 202, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, 0, 0, 334, 29, - 30, 0, 0, 0, 0, 0, 275, 276, 33, 277, - 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, 278, 36, 0, 37, 0, - 38, 279, 0, 203, 41, 280, 0, 0, 281, 282, - 272, 283, 284, 285, 43, 44, 0, 286, 287, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 288, 0, 960, 0, 0, 0, 0, 0, 961, 48, - 290, 291, 292, 293, 2, 202, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - 0, 0, 334, 29, 30, 0, 0, 0, 0, 0, - 275, 276, 33, 277, 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, 278, - 36, 0, 37, 0, 38, 279, 0, 203, 41, 280, - 0, 0, 281, 282, 272, 283, 284, 285, 43, 44, - 0, 286, 287, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 288, 0, 377, 0, 0, 0, - 0, 0, 47, 48, 290, 291, 292, 293, 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, 0, 0, 28, 29, 30, - 31, 0, 0, 0, 32, 0, 0, 33, 34, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 35, 0, 0, 36, 0, 37, 0, 38, - 39, 0, 40, 41, 42, 0, 0, 0, 0, 0, - 0, 0, 0, 43, 44, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 45, - 0, 46, 0, 0, 0, 0, 0, 47, 48, 201, - 2, 202, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, 0, 0, 28, 29, - 30, 0, 0, 0, 0, 0, 0, 0, 33, 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, 36, 0, 37, 0, - 38, 39, 0, 203, 41, 42, 0, 0, 0, 0, - 0, 0, 0, 0, 43, 44, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 45, 0, 204, 0, 0, 0, 0, 0, 47, 48, - 1, 2, 202, 4, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, 27, 0, 0, 28, - 29, 30, 31, 0, 0, 0, 32, 0, 0, 33, - 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, 36, 0, 37, - 0, 38, 0, 0, 40, 41, 201, 2, 202, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 0, 0, 28, 29, 30, 0, 0, - 0, 0, 0, 46, 0, 33, 0, 0, 0, 47, - 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 36, 0, 37, 0, 38, 0, 0, - 203, 41, 2, 202, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 0, 0, - 28, 29, 30, 0, 0, 0, 0, 0, 0, 204, - 33, 0, 0, 0, 0, 47, 48, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 36, 0, - 37, 0, 38, 39, 0, 203, 41, 42, 0, 0, - 0, 0, 0, 0, 0, 0, 43, 44, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 45, 0, 204, 0, 0, 0, 0, 0, - 47, 48, 2, 202, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 0, 0, - 334, 29, 30, 0, 0, 0, 0, 0, 0, 0, - 33, 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, 36, 0, - 37, 0, 38, 0, 0, 40, 41, 2, 202, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 0, 0, 334, 29, 30, 0, 0, - 0, 0, 0, -426, 683, 33, 0, 0, 0, 0, - 47, 48, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 36, 0, 37, 0, 38, 0, 0, - 40, 41, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1336, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 683, - 0, 0, 0, 0, 0, 47, 48, 2, 202, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 0, 0, 334, 29, 30, 0, 0, - 0, 0, 0, 0, 0, 33, 0, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, 27, 0, 0, 28, - 29, 30, 0, 36, 0, 37, 0, 38, 0, 33, - 40, 41, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1338, 0, 0, 36, 0, 0, - 0, 0, 0, 0, 40, 41, 0, 0, 0, 683, - 0, 0, 0, 0, 0, 47, 48, 2, 202, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 46, 0, 334, 29, 30, 0, 47, - 48, 0, 0, 0, 0, 33, 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, 36, 0, 37, 0, 38, 0, 0, - 203, 41, 2, 202, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 0, 0, - 334, 29, 30, 0, 0, 0, 0, 0, 0, 260, - 33, 0, 0, 0, 0, 47, 48, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 36, 0, - 37, 0, 38, 0, 0, 40, 41, 2, 202, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 0, 0, 28, 29, 30, 0, 0, - 0, 0, 0, 0, 683, 33, 0, 0, 0, 0, - 47, 48, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 36, 0, 37, 0, 38, 0, 0, - 203, 41, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 0, 0, 28, 29, 30, 0, 0, 0, - 0, 0, 275, 276, 33, 277, 0, 0, 0, 204, - 0, 0, 0, 0, 0, 47, 48, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 278, 36, 0, 0, 0, 0, 279, 0, 40, - 41, 280, 0, 0, 281, 282, 272, 283, 284, 285, - 43, 44, 0, 286, 287, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 288, 0, 518, 0, - 0, 168, 0, 0, 47, 48, 290, 291, 292, 293, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - 0, 0, 28, 29, 30, 0, 0, 0, 0, 0, - 275, 276, 33, 277, 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, 278, - 36, 0, 0, 0, 0, 279, 0, 40, 41, 280, - 0, 0, 281, 282, 272, 283, 284, 285, 43, 44, - 0, 286, 287, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 288, -40, 289, 0, 0, 0, - 0, 0, 47, 48, 290, 291, 292, 293, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 0, 0, - 28, 29, 30, 0, 0, 0, 0, 0, 275, 276, - 33, 277, 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, 278, 36, 0, - 0, 0, 0, 279, 0, 40, 41, 280, 0, 0, - 281, 282, 272, 283, 284, 285, 43, 44, 0, 286, - 287, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 288, 0, 289, 0, 0, 0, 0, 0, - 47, 48, 290, 291, 292, 293, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, 0, 0, 334, 29, - 30, 0, 0, 0, 0, 0, 275, 276, 33, 277, - 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, 278, 36, 0, 0, 0, - 0, 279, 0, 40, 41, 280, 0, 0, 281, 282, - 272, 283, 284, 285, 43, 44, 0, 286, 287, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 288, 0, 335, 0, 0, 0, 0, 0, 47, 48, - 290, 291, 292, 293, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 0, 0, 334, 29, 30, 0, - 0, 0, 0, 0, 275, 276, 33, 277, 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, 278, 36, 0, 0, 0, 0, 279, - 0, 40, 41, 280, 0, 0, 281, 282, 272, 283, - 284, 285, 43, 44, 0, 286, 287, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 288, 0, - 377, 0, 0, 0, 0, 0, 47, 48, 290, 291, - 292, 293, 463, 2, 202, 4, 5, 6, 7, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, 0, - 0, 28, 29, 30, 0, 0, 0, 0, 0, 0, - 0, 33, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 0, 0, 28, 29, 30, 0, 0, 36, - 0, 37, 0, 38, 33, 0, 40, 41, 0, 0, - 0, 0, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 36, 0, 28, 29, 30, 39, 0, 40, - 41, 42, 0, 0, 33, 0, 0, 0, -3, 0, - 43, 44, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 36, 0, 0, 0, 45, 39, 46, 203, - 41, 42, 0, 0, 47, 48, 0, 0, 0, 0, - 43, 44, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 45, 0, 260, 0, - 0, 0, 0, 0, 47, 48, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, 0, 0, 28, 29, - 30, 0, 0, 0, 0, 0, 0, 0, 33, 0, - 0, 0, 0, 0, 0, 0, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, 36, 0, 28, 29, - 30, 111, 0, 40, 41, 0, 0, 0, 33, 894, - 0, 0, 0, 0, 43, 44, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 36, 0, 0, 0, - 0, 0, 46, 40, 41, 0, 0, 0, 47, 48, - 0, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, 0, 0, 28, 29, 30, 0, 0, 0, 0, - 0, 0, 736, 33, 894, 0, 1208, 0, 47, 48, - 0, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, 36, 0, 28, 29, 30, 0, 0, 40, 41, - 0, 0, 0, 33, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 0, 0, 28, 29, 30, 0, - 0, 36, 0, 0, 0, 0, 33, 736, 203, 41, - 0, 1294, 0, 47, 48, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 36, 0, 0, 0, 0, 0, - 0, 40, 41, 0, 0, 0, 0, 260, 0, 0, - 0, 0, 0, 47, 48, 0, 0, 0, 0, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, 0, - 330, 334, 29, 30, 0, 0, 47, 48, 0, 0, - 0, 33, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 0, 0, 334, 29, 30, 0, 0, 36, - 0, 0, 0, 0, 33, 0, 40, 41, 0, 0, - 0, 0, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 36, 0, 28, 29, 30, 0, 0, 40, - 41, 0, 0, 0, 33, 247, 0, 0, 0, 0, - 0, 47, 48, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 36, 0, 0, 0, 0, 0, 330, 40, - 41, 0, 0, 0, 47, 48, 0, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, 27, 0, 0, 334, - 29, 30, 0, 0, 0, 0, 0, 0, 736, 33, - 0, 0, 0, 0, 47, 48, 0, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, 27, 36, 0, 334, - 29, 30, 0, 0, 203, 41, 0, 0, 0, 33, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - 0, 0, 334, 29, 30, 0, 0, 36, 0, 0, - 0, 0, 33, 260, 40, 41, 0, 0, 0, 47, - 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 36, 0, 0, 0, 0, 0, 0, 40, 41, 0, - 0, 0, 0, 683, 0, 0, 0, 0, 0, 47, - 48, 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, 736, 0, 0, 0, - 0, 0, 47, 48, 2, 202, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - 0, 0, 334, 29, 30, 0, 0, 0, 0, 0, - 0, 0, 33, 0, 275, 276, 0, 277, 1002, 0, - 1003, 0, 0, 1004, 1005, 1006, 1007, 1008, 1009, 1010, - 1011, 0, 0, 1529, 1012, 0, 0, 0, 1013, 1014, - 36, 1015, 37, 278, 38, 0, 0, 40, 41, 1016, - 0, 171, 172, 1019, 0, 0, 281, 282, 272, 283, - 284, 285, 43, 44, 0, 286, 287, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, -439, 0, 0, 288, 0, - 377, 0, 0, 168, 0, 0, 47, 48, 290, 291, - 292, 293, 0, 0, 275, 276, 1020, 277, 1002, 0, - 1003, -134, 0, 1004, 1005, 1006, 1007, 1008, 1009, 1010, - 1011, 0, 0, 0, 1012, 0, 0, 0, 1013, 1014, - 0, 1015, 0, 278, 0, 0, 0, 0, 0, 1016, - 0, 171, 172, 1019, 0, 0, 281, 282, 272, 283, - 284, 285, 43, 44, 0, 286, 287, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 288, 0, - 377, 0, 0, 168, 0, 0, 47, 48, 290, 291, - 292, 293, 0, 0, 0, 0, 1020, 0, 0, 0, - 0, -134, 2, 202, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 0, 0, - 334, 29, 30, 0, 0, 0, 0, 0, 0, 0, - 33, 0, 275, 276, 0, 277, 1002, 0, 1003, 1388, - 1389, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 0, - 0, 1529, 1012, 0, 0, 0, 1013, 1014, 36, 1015, - 37, 278, 38, 0, 0, 40, 41, 1016, 0, 171, - 172, 1019, 0, 0, 281, 282, 272, 283, 284, 285, - 43, 44, 0, 286, 287, 0, 0, 0, 0, 1301, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 288, 0, 377, 0, - 0, 168, 0, 0, 47, 48, 290, 291, 292, 293, - 0, 0, 275, 276, 1020, 277, 1002, 0, 1003, 1388, - 1389, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 0, - 0, 0, 1012, 0, 0, 0, 1013, 1014, 0, 1015, - 0, 278, 0, 0, 0, 0, 0, 1016, 0, 171, - 172, 1019, 0, 0, 281, 282, 272, 283, 284, 285, - 43, 44, 0, 286, 287, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 288, 0, 377, 0, - 0, 168, 0, 0, 47, 48, 290, 291, 292, 293, - 0, 0, 275, 276, 1020, 277, 1002, 0, 1003, 0, - 0, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 0, - 0, 0, 1012, 0, 0, 0, 1013, 1014, 0, 1015, - 0, 278, 0, 0, 0, 0, 0, 1016, 0, 171, - 172, 1019, 0, 0, 281, 282, 272, 283, 284, 285, - 43, 44, 0, 286, 287, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 288, 0, 377, 0, - 0, 168, 0, 0, 47, 48, 290, 291, 292, 293, - 0, 0, 0, 0, 1020, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 0, 0, 28, 29, 30, - 0, 0, 0, 0, 0, 0, 0, 33, 201, 2, - 202, 4, 5, 6, 7, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 36, 0, 28, 29, 30, - 111, 0, 40, 41, 0, 0, 0, 33, 0, 0, - 0, 0, 0, 43, 44, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 36, 0, 37, 0, 38, - 0, 0, 203, 41, 463, 2, 202, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, 0, 0, 28, 29, 30, 0, 0, 0, 0, - 0, 0, 0, 33, 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, 36, 0, 37, 0, 38, 0, 0, 40, 41, - 2, 202, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, 0, 0, 334, 29, - 30, 0, 0, 0, 0, 0, 0, 0, 33, 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, 36, 0, 37, 0, - 38, 0, 0, 203, 41, 2, 202, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, 0, 0, 28, 29, 30, 0, 0, 0, 0, - 0, 0, 0, 33, 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, 36, 0, 37, 0, 38, 0, 0, 203, 41, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - 0, 0, 28, 29, 30, 482, 483, 484, 485, 0, - 0, 0, 33, 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, - 36, 0, 0, 0, 0, 0, 0, 40, 41 -}; - -#define yypact_value_is_default(yystate) \ - ((yystate) == (-1346)) - -#define yytable_value_is_error(yytable_value) \ - YYID (0) - -static const yytype_int16 yycheck[] = -{ - 0, 1, 0, 45, 180, 45, 1, 180, 1, 200, - 117, 180, 51, 45, 180, 451, 603, 180, 0, 651, - 180, 1050, 180, 341, 532, 722, 603, 479, 900, 165, - 166, 31, 32, 183, 34, 215, 34, 341, 1010, 0, - 34, 622, 865, 1388, 600, 45, 1050, 1050, 1, 1311, - 1097, 51, 34, 51, 514, 45, 983, 984, 58, 568, - 600, 106, 865, 63, 66, 63, 66, 45, 66, 69, - 1392, 69, 600, 34, 69, 114, 493, 0, 1, 255, - 497, 66, 255, 67, 42, 337, 255, 416, 479, 255, - 197, 154, 255, 600, 45, 255, 42, 255, 51, 47, - 48, 251, 252, 600, 30, 144, 435, 107, 153, 54, - 110, 34, 600, 90, 443, 342, 246, 117, 1463, 363, - 600, 984, 42, 367, 337, 125, 100, 1052, 424, 425, - 114, 0, 1269, 118, 42, 137, 604, 1056, 180, 1058, - 180, 118, 610, 47, 48, 145, 69, 145, 180, 84, - 363, 224, 1414, 106, 367, 81, 114, 157, 116, 157, - 134, 114, 101, 181, 237, 34, 205, 56, 486, 114, - 116, 119, 157, 713, 1496, 1047, 114, 101, 1001, 1501, - 180, 181, 42, 181, 1231, 713, 1233, 1234, 127, 288, - 180, 144, 133, 114, 114, 136, 116, 197, 1001, 495, - 153, 0, 180, 127, 1526, 205, 114, 205, 116, 98, - 42, 1533, 0, 255, 214, 255, 120, 217, 514, 217, - 51, 114, 261, 255, 224, 733, 813, 479, 408, 180, - 112, 181, 217, 713, 234, 34, 813, 237, 256, 1013, - 1014, 241, 242, 241, 800, 947, 34, 241, 201, 242, - 641, 642, 205, 42, 136, 255, 256, 45, 256, 241, - 800, 300, 262, 51, 249, 265, 657, 114, 115, 254, - 0, 1, 800, 1198, 783, 63, 0, 42, 66, 575, - 241, 69, 114, 114, 116, 246, 416, 332, 920, 47, - 48, 743, 994, 800, 84, 1432, 114, 1269, 337, 603, - 189, 114, 1439, 800, 34, 435, 256, 114, 261, 117, - 34, 264, 800, 443, 705, 422, 42, 135, 241, 1093, - 800, 428, 322, 212, 322, 114, 116, 116, 642, 136, - 1257, 1258, 909, 222, 802, 288, 66, 121, 115, 69, - 340, 341, 586, 657, 121, 69, 119, 300, 1211, 114, - 1501, 116, 743, 137, 1051, 0, 1179, 145, 687, 42, - 42, 119, 1499, 590, 364, 3, 42, 430, 368, 157, - 622, 1501, 241, 586, 205, 1347, 1179, 246, 378, 332, - 632, 962, 1533, 117, 402, 424, 425, 121, 114, 34, - 116, 705, 180, 181, 638, 1258, 1526, 1443, 625, 288, - 143, 908, 402, 1533, 402, 0, 115, 634, 507, 622, - 509, 908, 451, 512, 124, 125, 515, 205, 42, 632, - 908, 66, 422, 115, 154, 638, 135, 3, 428, 217, - 261, 114, 114, 116, 116, 1481, 121, 1483, 114, 34, - 116, 460, 241, 135, 429, 722, 1269, 246, 121, 0, - 1147, 1148, 402, 241, 114, 416, 495, 1384, 42, 477, - 1092, 524, 135, 463, 1436, 692, 1438, 255, 468, 300, - 463, 424, 425, 115, 435, 514, 1505, 477, 930, 477, - 707, 481, 443, 481, 469, 945, 486, 217, 924, 489, - 114, 743, 116, 135, 494, 813, 1073, 0, 451, 481, - 777, 1505, 1505, 971, 972, 922, 116, 122, 118, 813, - 463, 241, 115, 128, 129, 136, 652, 241, 121, 10, - 481, 1384, 246, 1466, 587, 135, 526, 477, 1500, 1472, - 114, 531, 116, 526, 322, 115, 575, 115, 531, 930, - 493, 121, 495, 121, 497, 114, 114, 416, 116, 793, - 1475, 440, 659, 341, 507, 1498, 509, 687, 481, 512, - 1503, 514, 515, 670, 0, 1, 435, 115, 795, 97, - 98, 701, 217, 121, 443, 121, 465, 854, 641, 642, - 793, 1506, 114, 622, 75, 585, 77, 78, 121, 641, - 642, 137, 983, 632, 657, 913, 241, 121, 34, 121, - 600, 115, 115, 603, 137, 657, 84, 75, 121, 1432, - 1535, 135, 481, 1315, 402, 137, 1439, 416, 507, 114, - 88, 89, 575, 512, 624, 75, 515, 77, 78, 629, - 66, 114, 114, 69, 116, 488, 435, 51, 88, 89, - 122, 123, 705, 643, 443, 277, 241, 647, 116, 63, - 114, 246, 66, 705, 136, 69, 656, 676, 658, 659, - 660, 121, 1114, 121, 121, 658, 116, 660, 300, 301, - 670, 115, 852, 950, 1376, 1377, 1499, 137, 930, 137, - 137, 75, 481, 114, 10, 11, 12, 13, 14, 121, - 114, 1388, 416, 481, 88, 89, 121, 342, 486, 699, - 430, 114, 337, 135, 115, 337, 699, 115, 343, 121, - 962, 435, 137, 713, 714, 115, 42, 702, 587, 443, - 720, 998, 858, 1114, 724, 137, 687, 115, 363, 121, - 880, 145, 367, 95, 96, 115, 120, 690, 965, 121, - 701, 121, 121, 157, 70, 137, 470, 379, 115, 962, - 114, 481, 605, 1450, 121, 137, 609, 481, 137, 1211, - 779, 121, 615, 75, 717, 1462, 1463, 181, 130, 131, - 789, 790, 115, 114, 1051, 116, 88, 89, 121, 1287, - 67, 217, 801, 636, 975, 121, 675, 640, 114, 1486, - 116, 205, 115, 114, 524, 684, 122, 123, 121, 688, - 800, 137, 114, 217, 116, 241, 114, 10, 11, 12, - 13, 14, 600, 813, 70, 603, 119, 73, 687, 121, - 76, 416, 78, 115, 469, 115, 889, 115, 137, 121, - 86, 121, 701, 121, 3, 137, 481, 137, 75, 42, - 435, 10, 11, 12, 13, 14, 117, 114, 443, 116, - 121, 88, 89, 288, 137, 122, 123, 587, 858, 690, - 996, 1558, 1114, 1043, 864, 865, 1257, 70, 117, 115, - 1147, 1148, 121, 42, 1050, 121, 115, 1050, 896, 116, - 115, 1050, 121, 865, 1050, 924, 481, 1050, 687, 114, - 1050, 116, 1050, 75, 93, 94, 896, 122, 123, 899, - 82, 70, 701, 85, 865, 87, 88, 89, 322, 115, - 117, 641, 642, 913, 121, 121, 548, 549, 550, 119, - 983, 984, 84, 962, 115, 713, 714, 657, 923, 672, - 121, 931, 117, 114, 116, 114, 121, 937, 931, 115, - 1484, 894, 865, 943, 1488, 121, 896, 947, 120, 121, - 943, 586, 208, 75, 947, 77, 78, 79, 115, 1211, - 123, 980, 981, 687, 121, 132, 88, 89, 133, 922, - 923, 924, 75, 115, 116, 705, 1083, 701, 99, 82, - 625, 116, 85, 836, 87, 88, 89, 622, 402, 424, - 425, 117, 114, 117, 994, 115, 865, 632, 61, 62, - 923, 994, 891, 638, 1004, 120, 121, 1007, 1008, 1009, - 47, 48, 800, 116, 10, 11, 12, 13, 14, 1001, - 889, 115, 1041, 1042, 115, 813, 1098, 1099, 75, 115, - 1048, 115, 79, 115, 1052, 114, 115, 116, 1038, 137, - 1001, 88, 89, 551, 552, 481, 42, 692, 1048, 114, - 1050, 117, 1052, 555, 556, 557, 558, 702, 114, 115, - 116, 914, 707, 894, 1064, 116, 865, 114, 75, 116, - 77, 78, 507, 119, 70, 122, 123, 512, 1001, 119, - 515, 88, 89, 1083, 553, 554, 1522, 136, 344, 345, - 121, 347, 687, 349, 114, 115, 116, 1097, 1048, 114, - 115, 116, 1052, 136, 1097, 361, 701, 114, 896, 119, - 114, 1388, 119, 137, 1067, 747, 559, 560, 114, 117, - 116, 115, 115, 1012, 135, 913, 122, 123, 117, 3, - 75, 566, 1001, 117, 79, 865, 10, 11, 12, 13, - 14, 865, 121, 88, 89, 135, 1209, 135, 31, 75, - 795, 77, 78, 79, 1154, 61, 62, 63, 793, 889, - 115, 796, 88, 89, 115, 119, 115, 120, 42, 114, - 120, 114, 120, 1450, 121, 115, 115, 122, 123, 1179, - 1198, 0, 1, 439, 121, 1462, 1463, 115, 115, 121, - 1209, 115, 115, 923, 1257, 1258, 70, 1179, 1198, 115, - 115, 115, 1001, 75, 115, 77, 78, 79, 115, 1486, - 75, 137, 77, 78, 79, 34, 88, 89, 1179, 1238, - 865, 1216, 115, 88, 89, 115, 45, 1246, 1247, 1248, - 115, 1231, 51, 1233, 1234, 115, 1067, 1190, 1231, 115, - 1233, 1234, 115, 120, 63, 115, 31, 66, 1198, 1476, - 69, 115, 136, 983, 984, 75, 1179, 77, 78, 79, - 1048, 119, 1050, 1216, 1052, 137, 1373, 115, 88, 89, - 865, 1001, 75, 117, 77, 78, 79, 1001, 121, 117, - 115, 1558, 1300, 115, 121, 88, 89, 106, 119, 115, - 1290, 58, 115, 1216, 114, 114, 116, 121, 117, 118, - 1300, 115, 122, 123, 75, 121, 77, 78, 1269, 114, - 1179, 11, 114, 114, 114, 1315, 1311, 88, 89, 122, - 965, 1384, 1315, 114, 135, 144, 145, 962, 135, 1505, - 962, 135, 1505, 121, 153, 154, 1505, 120, 157, 1505, - 107, 1341, 1505, 110, 1344, 1505, 1269, 1505, 119, 115, - 1300, 137, 115, 75, 135, 1350, 1001, 135, 1311, 1190, - 82, 180, 181, 85, 1349, 87, 88, 89, 1475, 1001, - 115, 133, 1372, 1373, 120, 119, 1376, 1377, 197, 120, - 1179, 115, 117, 1376, 1377, 121, 205, 117, 1311, 1278, - 115, 115, 1392, 120, 1413, 115, 32, 1397, 217, 75, - 1269, 77, 78, 79, 117, 117, 1001, 66, 117, 115, - 1198, 50, 88, 89, 1399, 117, 75, 86, 75, 1414, - 77, 78, 241, 117, 117, 115, 1426, 1350, 115, 865, - 249, 88, 89, 137, 137, 254, 255, 256, 114, 137, - 137, 137, 261, 3, 115, 115, 676, 214, 120, 1179, - 10, 11, 12, 13, 14, 1179, 120, 114, 114, 118, - 115, 1414, 119, 1505, 117, 1505, 117, 117, 865, 288, - 1269, 1432, 117, 1505, 117, 1475, 117, 1477, 1439, 117, - 115, 300, 42, 1522, 1477, 114, 1216, 923, 1506, 125, - 114, 1414, 63, 114, 119, 262, 1496, 316, 157, 115, - 115, 1501, 101, 322, 117, 1505, 1506, 117, 1506, 1432, - 70, 115, 1300, 332, 117, 115, 1439, 1535, 337, 101, - 114, 114, 341, 342, 1524, 137, 1526, 1257, 1258, 120, - 1530, 115, 115, 1533, 1179, 1535, 115, 1535, 1499, 1269, - 115, 121, 45, 1286, 363, 1269, 1546, 135, 367, 779, - 1550, 1440, 137, 1442, 115, 101, 1506, 115, 217, 789, - 790, 137, 101, 1432, 137, 1001, 135, 137, 1568, 1522, - 1439, 801, 117, 340, 75, 1568, 1499, 115, 79, 1579, - 137, 1311, 115, 402, 1179, 1535, 1579, 88, 89, 66, - 249, 1480, 135, 1482, 114, 254, 121, 364, 234, 120, - 117, 368, 117, 422, 117, 424, 425, 1004, 137, 428, - 1441, 430, 1443, 114, 137, 115, 114, 1360, 120, 1349, - 1350, 122, 123, 120, 1269, 115, 1350, 115, 135, 265, - 1499, 115, 451, 1432, 115, 115, 114, 54, 137, 56, - 1439, 118, 59, 60, 61, 1534, 137, 1536, 115, 468, - 1481, 137, 1483, 561, 1384, 137, 565, 1020, 477, 76, - 479, 562, 481, 563, 942, 1554, 1555, 486, 1411, 1399, - 564, 1463, 89, 90, 1269, 1179, 495, 1352, 1550, 1279, - 157, 1543, 1439, 342, 1414, 1489, 1038, 1048, 507, 894, - 509, 1300, 1058, 512, 724, 514, 515, 916, 858, 937, - 1499, 653, 1432, 717, 1349, 524, 75, 915, 1432, 1439, - 1216, 481, 567, 82, 732, 1439, 85, 1505, 87, 88, - 89, 567, 567, 1158, 1159, 75, 1161, 77, 78, 79, - -1, -1, 1167, -1, -1, 1170, -1, -1, 88, 89, - 217, 1484, 378, 1179, -1, 1488, 1489, 116, 567, 568, - 980, 981, -1, -1, 1399, -1, 575, 234, 4, 5, - 6, 7, 8, 9, -1, 182, -1, 586, 587, 1499, - 429, 590, 249, 1516, -1, 1499, -1, 254, -1, -1, - 1216, 600, 1179, -1, 603, -1, 445, 1432, 75, -1, - 77, 78, 79, -1, 1439, -1, 1539, -1, -1, -1, - 1543, 88, 89, 622, -1, -1, 1441, -1, 1443, -1, - 469, 1041, 1042, 632, -1, 634, -1, -1, 75, 638, - 77, 78, 641, 642, 1567, -1, 72, 114, 74, 116, - -1, 88, 89, 1269, -1, 122, 123, 1432, 657, -1, - 659, -1, -1, -1, 1439, -1, 1481, -1, 1483, 136, - -1, 670, -1, 489, 1499, -1, -1, 624, 494, 75, - -1, 77, 78, 79, -1, 342, -1, -1, -1, -1, - -1, 690, 88, 89, -1, 1311, 643, -1, 4, 5, - 6, 7, 8, 9, -1, -1, 705, 706, 707, 656, - -1, 137, -1, 1290, 713, 714, -1, -1, 114, -1, - 116, -1, 58, -1, 1499, -1, 122, 123, 1343, 35, - -1, -1, -1, 1349, 1350, 275, -1, 277, 278, 336, - -1, 338, -1, -1, 743, -1, 286, 287, 86, -1, - -1, 590, 90, 91, 92, -1, -1, -1, 355, 356, - 300, 301, -1, -1, 1341, -1, 72, 1344, 74, 585, - -1, 107, 429, -1, 110, -1, 114, -1, 116, -1, - 118, 119, -1, 1399, 783, -1, 625, 4, 5, 6, - 7, 8, 9, -1, 793, 634, 795, 337, 1414, -1, - -1, 800, 86, -1, -1, -1, 90, 91, 92, -1, - -1, -1, 469, 629, 813, 1392, 1432, -1, 185, -1, - 1397, -1, -1, 1439, -1, 192, -1, -1, 1238, -1, - 114, 647, 116, -1, 118, 119, 1246, 1247, 1248, 379, - -1, -1, 10, 11, 12, 13, 14, -1, 75, 1426, - 77, 78, -1, 692, -1, 72, -1, 74, -1, -1, - -1, 88, 89, 702, -1, -1, 865, -1, 707, -1, - -1, -1, -1, -1, 42, -1, -1, -1, 214, -1, - -1, -1, -1, 1499, -1, -1, -1, -1, -1, -1, - 889, 258, -1, -1, -1, 894, -1, 896, -1, -1, - -1, -1, 70, -1, 720, -1, -1, 75, 724, 908, - 909, 79, -1, -1, 913, -1, -1, -1, -1, -1, - 88, 89, -1, -1, 923, 924, 262, -1, -1, -1, - -1, 930, -1, 590, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 114, 1524, -1, 316, - -1, -1, -1, 1530, 122, 123, 795, -1, 325, -1, - -1, 328, -1, 962, -1, -1, -1, -1, 625, 1546, - -1, -1, 629, 1550, -1, -1, -1, 634, -1, -1, - -1, -1, -1, -1, 983, 984, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 1001, 1413, 340, -1, -1, -1, 548, 549, - 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, - 560, 561, 562, 563, 564, 565, -1, 394, 364, -1, - -1, 398, 368, -1, -1, 692, -1, -1, -1, -1, - -1, -1, 858, -1, -1, 702, -1, -1, 864, 1048, - 707, 1050, -1, 1052, -1, -1, -1, -1, -1, -1, - 1007, 1008, 1009, -1, -1, -1, -1, -1, 1067, -1, - -1, -1, -1, -1, 1073, -1, -1, -1, -1, -1, - -1, -1, -1, 899, 1083, -1, -1, -1, -1, -1, - 10, 11, 12, 13, 14, -1, 693, -1, 695, -1, - 75, -1, 77, 78, 79, -1, 703, 704, -1, 476, - -1, 708, -1, 88, 89, 1114, -1, -1, -1, -1, - -1, 937, 42, -1, -1, -1, 965, -1, 725, -1, - -1, -1, -1, 730, -1, -1, -1, -1, 795, 114, - 75, 116, 77, 78, 79, -1, -1, 122, 123, -1, - 70, 0, 749, 88, 89, 75, -1, 77, 78, 79, - 135, -1, -1, 10, 11, 12, 13, 14, 88, 89, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 114, - 1179, -1, 722, -1, -1, 34, -1, 122, 123, -1, - -1, 1190, -1, -1, 114, 42, 116, -1, -1, 1198, - 567, 568, 122, 123, -1, -1, -1, 747, -1, -1, - -1, -1, 1211, -1, -1, -1, -1, 1216, -1, -1, - 69, -1, 1038, 70, -1, -1, -1, -1, 75, -1, - 77, 78, 79, -1, -1, -1, -1, 777, -1, -1, - -1, 88, 89, 75, -1, 77, 78, 79, 1064, -1, - 847, -1, 849, 850, 851, -1, 88, 89, 1257, 1258, - -1, -1, -1, -1, -1, -1, -1, 114, -1, 116, - 1269, 868, -1, -1, -1, 122, 123, -1, -1, -1, - -1, -1, 114, -1, -1, -1, -1, 884, 624, -1, - 122, 123, -1, -1, 661, -1, -1, -1, 665, -1, - -1, 1300, -1, -1, -1, 154, -1, 643, 965, -1, - 907, -1, 1311, -1, -1, -1, -1, -1, -1, -1, - 656, -1, -1, -1, 10, 11, 12, 13, 14, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 1154, 10, - 11, 12, 13, 14, 941, -1, -1, -1, -1, 946, - 1349, 1350, -1, -1, 951, -1, 42, -1, -1, 956, - 957, -1, -1, -1, 961, -1, 963, 964, -1, -1, - 967, 42, -1, -1, 1373, -1, -1, 226, -1, 976, - -1, -1, -1, -1, 70, 1384, -1, -1, -1, 75, - 0, 1, 241, 79, -1, 992, 993, 246, -1, 70, - 1399, -1, 88, 89, 75, -1, 77, 78, 79, -1, - 950, -1, -1, -1, -1, 1414, 783, 88, 89, -1, - -1, -1, 962, -1, 34, 1372, -1, 1024, 114, -1, - 1027, -1, -1, 1432, -1, -1, 122, 123, -1, -1, - 1439, 51, 1441, 114, 1443, 116, -1, -1, -1, -1, - -1, 122, 123, -1, -1, -1, -1, -1, -1, 69, - -1, 1001, -1, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, -1, -1, 1475, 1476, -1, -1, - -1, -1, 1481, 1080, 1483, -1, -1, -1, 337, 1086, - 1087, -1, -1, -1, 343, -1, 106, 136, 1095, -1, - 1499, -1, -1, 1100, -1, -1, 1505, 1506, 1105, -1, - 1349, 1051, -1, -1, 363, -1, -1, -1, 367, -1, - -1, 1118, -1, 1522, -1, -1, -1, -1, -1, 865, - -1, -1, -1, -1, -1, 145, 1535, 1134, -1, 1136, - 1137, 1138, 1139, 153, 154, 10, 11, 12, 13, 14, - -1, -1, -1, -1, 1151, -1, 1153, -1, -1, -1, - 1399, -1, -1, -1, -1, -1, -1, 416, -1, -1, - -1, 181, -1, -1, -1, -1, -1, 42, -1, -1, - -1, 430, -1, -1, -1, 952, 435, 197, 1185, 1186, - 200, 201, -1, -1, 443, 205, -1, -1, -1, -1, - -1, 968, -1, -1, -1, 70, -1, 1147, 1148, -1, - 75, 460, 77, 78, 79, -1, 226, -1, -1, -1, - 230, 470, 232, 88, 89, 235, -1, -1, -1, -1, - 479, 241, 481, -1, -1, -1, 246, 1476, -1, -1, - -1, -1, -1, -1, -1, -1, 256, -1, -1, 114, - -1, -1, 1249, 1250, 264, -1, -1, 122, 123, -1, - -1, -1, 1259, -1, -1, -1, -1, -1, 1004, -1, - -1, 1007, 1008, 1009, -1, 524, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 1057, -1, 1349, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 10, 11, 12, - 13, 14, 332, -1, -1, -1, 1323, 337, 1325, 1326, - 1327, -1, -1, 343, -1, -1, -1, 586, 587, -1, - 1337, -1, 1399, -1, -1, -1, -1, -1, 1345, 42, - -1, 1348, -1, 363, -1, -1, -1, 367, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 622, -1, -1, -1, 70, 1375, -1, - -1, -1, 75, 632, 77, 78, 79, -1, -1, 638, - -1, -1, 641, 642, -1, 88, 89, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 416, 0, 657, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 1476, - 430, 114, 1419, 1420, -1, 435, 1193, 676, -1, 122, - 123, -1, -1, 443, -1, 1432, -1, -1, 687, -1, - -1, 34, 1439, 1179, -1, -1, -1, -1, 1388, -1, - 460, -1, 701, 463, -1, -1, 705, -1, -1, 1456, - 470, -1, -1, -1, -1, -1, -1, -1, -1, 479, - -1, 481, -1, -1, -1, -1, 69, 1474, -1, -1, - -1, -1, 1479, 493, -1, -1, -1, 497, -1, -1, - -1, -1, -1, -1, 743, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 1450, -1, -1, -1, 524, 1512, -1, 1514, -1, -1, - -1, -1, 1462, 1463, -1, -1, -1, -1, -1, 1296, - 779, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 789, 790, -1, -1, 793, -1, 1486, 796, -1, -1, - -1, -1, 801, -1, 1290, 1552, 1553, -1, 568, -1, - -1, 154, -1, -1, -1, -1, -1, -1, 1565, 1566, - -1, -1, -1, -1, -1, -1, 586, 587, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 603, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 1341, -1, -1, 1344, -1, - -1, -1, 622, -1, -1, -1, 865, 627, 1558, -1, - -1, -1, 632, -1, -1, -1, -1, -1, 638, -1, - -1, 641, 642, -1, -1, -1, 1372, -1, -1, -1, - 889, -1, -1, -1, -1, -1, -1, 657, 241, -1, - -1, -1, -1, 246, 40, 41, 1392, 43, -1, -1, - -1, 1397, -1, -1, -1, -1, 676, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 687, -1, -1, - -1, 930, -1, 69, -1, -1, -1, -1, -1, 75, - 1426, 701, -1, 79, -1, 705, 82, 83, 84, 85, - 86, 87, 88, 89, 714, 91, 92, 717, -1, -1, - -1, -1, -1, 962, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 114, -1, - 116, 980, 981, 743, 983, 984, 122, 123, 124, 125, - 126, 127, -1, -1, 337, -1, -1, -1, -1, 135, - 343, -1, 1001, -1, -1, -1, -1, -1, -1, -1, - 1496, -1, -1, -1, -1, 1501, -1, -1, -1, 779, - 363, -1, -1, -1, 367, -1, -1, -1, -1, 789, - 790, -1, -1, 793, -1, -1, 796, -1, 1524, -1, - 1526, 801, 1041, 1042, 1530, -1, -1, 1533, -1, -1, - -1, 811, -1, -1, -1, -1, -1, -1, -1, -1, - 1546, -1, -1, -1, 1550, -1, -1, -1, -1, -1, - -1, -1, -1, 416, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 430, -1, -1, - -1, -1, 435, -1, -1, -1, -1, -1, -1, -1, - 443, -1, -1, -1, -1, 865, -1, -1, 40, 41, - -1, 43, -1, -1, -1, 1114, -1, 460, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 470, -1, 889, - -1, -1, 0, -1, -1, -1, 479, 69, 481, -1, - -1, -1, -1, 75, -1, 77, 78, 79, -1, 909, - 82, 83, 84, 85, 86, 87, 88, 89, -1, 91, - 92, -1, 922, 923, -1, -1, 34, -1, -1, -1, - 930, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 1179, 524, 114, -1, 116, -1, 118, 119, -1, -1, - 122, 123, 124, 125, 126, 127, -1, -1, -1, -1, - -1, 69, 962, -1, -1, -1, -1, -1, -1, -1, - 1209, -1, 1211, -1, -1, 975, -1, -1, -1, -1, - 980, 981, -1, 983, 984, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 1238, - -1, 1001, -1, 586, 587, -1, -1, 1246, 1247, 1248, - -1, -1, -1, -1, -1, -1, -1, -1, 1257, 1258, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 1269, -1, -1, -1, -1, -1, -1, -1, -1, 622, - -1, 1041, 1042, -1, -1, -1, 154, -1, -1, 632, - -1, -1, 1052, -1, -1, 638, -1, -1, 641, 642, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 657, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 676, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 687, -1, -1, -1, -1, -1, - -1, 1350, -1, -1, 1114, -1, -1, -1, 701, -1, - -1, -1, 705, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 241, -1, -1, -1, -1, 246, -1, - -1, -1, -1, -1, -1, 1384, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 743, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 1413, -1, -1, -1, -1, 1179, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 1432, -1, -1, 779, -1, -1, -1, - 1439, -1, 1441, -1, 1443, -1, 789, 790, -1, 1209, - 793, 1211, -1, 796, -1, -1, 1216, -1, 801, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 337, - -1, -1, -1, -1, -1, 343, -1, -1, 1238, -1, - -1, -1, 1481, -1, 1483, -1, 1246, 1247, 1248, -1, - -1, -1, -1, -1, -1, 363, -1, 1257, 1258, 367, - 1499, -1, -1, -1, -1, -1, -1, -1, -1, 1269, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 865, -1, -1, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, -1, 889, -1, 416, -1, - -1, 1311, -1, -1, -1, -1, -1, 42, -1, -1, - -1, -1, 430, -1, -1, -1, -1, 435, -1, -1, - -1, -1, -1, -1, -1, 443, -1, -1, -1, -1, - -1, 51, -1, 40, 41, 70, 43, 930, -1, -1, - 1350, -1, 460, -1, -1, -1, 66, -1, -1, -1, - -1, -1, 470, -1, -1, -1, -1, -1, -1, -1, - -1, 479, 69, 481, -1, -1, -1, -1, 75, 962, - -1, -1, 79, -1, 1384, 82, 83, 84, 85, 86, - 87, 88, 89, -1, 91, 92, -1, 980, 981, 28, - 983, 984, -1, -1, 114, -1, -1, -1, 118, -1, - -1, -1, -1, 1413, 1414, -1, 524, 114, 1001, 116, - -1, -1, 119, -1, -1, 122, 123, 124, 125, 126, - 127, -1, 1432, -1, 144, -1, -1, -1, -1, 1439, - -1, 1441, -1, 1443, 154, -1, -1, 157, -1, -1, - -1, -1, -1, -1, 83, -1, -1, -1, 1041, 1042, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 99, -1, 101, -1, -1, -1, -1, -1, 586, 587, - -1, 1481, -1, 1483, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 205, -1, 126, -1, 1499, - -1, -1, -1, -1, -1, -1, 1506, 217, -1, -1, - -1, -1, -1, -1, 622, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 632, -1, -1, -1, -1, -1, - 638, 1114, -1, 641, 642, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 254, -1, -1, -1, -1, 657, - -1, 261, -1, -1, -1, -1, 185, -1, 187, 188, - -1, -1, -1, 192, -1, 194, 195, -1, 676, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 288, 687, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 300, -1, -1, 701, -1, -1, 1179, 705, -1, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, 27, 28, 29, -1, - -1, 32, 33, 34, -1, -1, 1209, 337, 1211, 258, - -1, 42, 342, -1, -1, 743, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 1238, -1, -1, -1, 70, - -1, -1, -1, 1246, 1247, 1248, 77, 78, -1, -1, - -1, 779, -1, -1, 1257, 1258, -1, -1, -1, -1, - -1, 789, 790, -1, -1, 793, 1269, -1, 796, -1, - -1, -1, -1, 801, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 334, -1, -1, -1, -1, - -1, 122, 123, -1, 424, 425, -1, -1, -1, -1, - 430, -1, -1, -1, 353, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 451, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 865, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 1350, -1, 479, - -1, -1, -1, -1, -1, -1, 405, -1, -1, -1, - -1, 889, -1, -1, -1, 495, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 507, -1, 509, - -1, 1384, 512, -1, 514, 515, -1, -1, -1, -1, - -1, -1, -1, -1, 524, -1, -1, -1, -1, -1, - -1, -1, 930, -1, -1, -1, -1, -1, -1, -1, - 1413, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 1432, - -1, -1, -1, -1, 962, -1, 1439, -1, 1441, -1, - 1443, -1, -1, -1, -1, 575, -1, -1, -1, -1, - -1, -1, 980, 981, -1, 983, 984, 587, -1, -1, - 590, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 1001, -1, -1, -1, -1, 1481, -1, - 1483, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 622, -1, 66, -1, 1499, -1, -1, -1, - -1, -1, 632, 75, -1, 77, -1, 79, -1, -1, - -1, 641, 642, 1041, 1042, 87, -1, -1, -1, -1, - -1, -1, 571, 572, -1, -1, -1, 657, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 118, -1, 120, 121, - 122, -1, -1, -1, -1, 604, -1, -1, 607, 608, - 690, 610, -1, 612, 613, -1, -1, -1, 617, 618, - -1, -1, -1, -1, -1, 705, -1, 707, -1, -1, - -1, -1, -1, -1, -1, 157, 1114, -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, 661, 743, -1, -1, 665, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 7, -1, -1, - 10, 11, 12, 13, 14, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 217, -1, 219, 220, 221, - -1, 1179, -1, -1, -1, -1, -1, -1, -1, -1, - 40, 41, 42, 43, -1, 795, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 249, -1, -1, - -1, 1209, 254, 1211, -1, -1, -1, -1, -1, 69, - 70, -1, -1, -1, -1, 75, -1, -1, -1, 79, - -1, -1, 82, 83, 84, 85, 86, 87, 88, 89, - 1238, 91, 92, -1, -1, -1, -1, -1, 1246, 1247, - 1248, -1, -1, -1, -1, -1, -1, -1, -1, 1257, - 1258, -1, -1, -1, 114, -1, 116, -1, -1, -1, - -1, 1269, 122, 123, 124, 125, 126, 127, -1, -1, - 322, -1, -1, -1, -1, -1, -1, -1, -1, 889, - 40, 41, -1, 43, 894, -1, -1, -1, 46, -1, - 342, -1, -1, -1, -1, -1, 348, -1, 350, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 69, - 362, -1, -1, -1, 924, 75, -1, -1, -1, 79, - 930, -1, 82, 83, 84, 85, 86, 87, 88, 89, - -1, 91, 92, -1, 92, -1, -1, -1, -1, -1, - -1, -1, 1350, -1, 102, -1, -1, -1, -1, -1, - 402, -1, 962, -1, 114, -1, 116, -1, -1, -1, - -1, 121, 122, 123, 124, 125, 126, 127, -1, -1, - 422, -1, -1, 983, 984, 427, 1384, 429, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 445, -1, -1, 448, 449, -1, -1, - -1, -1, -1, 455, -1, 1413, -1, -1, -1, -1, - 168, -1, -1, -1, -1, -1, -1, 469, -1, -1, - -1, -1, -1, 952, 1432, 477, -1, -1, -1, -1, - -1, 1439, 190, 1441, -1, 1443, -1, -1, -1, 968, - -1, -1, 971, 972, -1, 7, 204, -1, 10, 11, - 12, 13, 14, -1, -1, 213, -1, 1067, -1, -1, - -1, -1, -1, -1, -1, 223, -1, -1, -1, -1, - -1, -1, -1, 1481, -1, 1483, -1, -1, 40, 41, - 42, 43, -1, -1, 242, -1, -1, -1, -1, 247, - -1, 1499, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 260, -1, 1114, -1, -1, 69, 70, -1, - 268, -1, 270, 75, -1, 1044, -1, 79, -1, -1, - 82, 83, 84, 85, 86, 87, 88, 89, 1057, 91, - 92, 289, -1, 1062, 1063, -1, -1, -1, 590, -1, - 592, 593, 594, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 114, -1, 116, -1, -1, -1, -1, -1, - 122, 123, 124, 125, 126, 127, -1, -1, -1, -1, - -1, -1, 330, 625, 626, -1, -1, 335, -1, -1, - 1190, -1, 634, -1, -1, -1, -1, -1, -1, -1, - 1119, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 1211, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 370, -1, -1, -1, 374, 375, -1, 377, - -1, -1, -1, -1, -1, -1, 384, 385, -1, 387, - 388, -1, 390, -1, 392, -1, -1, -1, -1, -1, - 692, -1, -1, 40, 41, -1, 43, 1257, 1258, -1, - 702, 409, 1181, -1, -1, 707, -1, -1, -1, 417, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 1200, 69, -1, -1, -1, -1, -1, 75, -1, - -1, -1, 79, 441, -1, 82, 83, 84, 85, 86, - 87, 88, 89, -1, 91, 92, -1, -1, -1, -1, - -1, -1, 153, 154, -1, -1, -1, -1, 466, -1, - -1, -1, -1, -1, -1, 473, -1, 114, -1, 116, - 478, -1, 119, -1, -1, 122, 123, 124, 125, 126, - 127, 783, -1, -1, 185, -1, -1, -1, -1, 1349, - -1, 192, -1, 795, -1, -1, -1, -1, -1, -1, - -1, -1, 40, 41, -1, 43, -1, -1, -1, -1, - 518, 813, -1, -1, -1, -1, -1, 1296, -1, -1, - -1, -1, 530, -1, 1384, -1, -1, -1, -1, -1, - -1, 69, -1, -1, -1, 837, -1, 75, -1, 1399, - -1, 79, -1, -1, 82, 83, 84, 85, 86, 87, - 88, 89, -1, 91, 92, -1, -1, 258, -1, 567, - -1, 40, 41, -1, 43, -1, -1, -1, 576, -1, - -1, 579, -1, -1, -1, -1, 114, -1, 116, -1, - -1, 1441, -1, 1443, 122, 123, 124, 125, 126, 127, - 69, -1, -1, 601, -1, -1, 75, -1, -1, -1, - 79, -1, -1, 82, 83, 84, 85, 86, 87, 88, - 89, 913, 91, 92, -1, 316, 1476, -1, -1, -1, - -1, 1481, -1, 1483, 325, 326, -1, 328, 329, -1, - -1, -1, -1, -1, -1, 114, 337, 116, 646, -1, - 341, -1, -1, 122, 123, 124, 125, 126, 127, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 1522, 965, -1, -1, 367, -1, -1, -1, - -1, -1, -1, -1, 976, 683, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 394, -1, -1, -1, 398, -1, -1, - -1, -1, -1, 711, -1, -1, -1, -1, -1, -1, - 144, -1, -1, -1, -1, -1, -1, -1, 726, 727, - 154, -1, -1, -1, -1, -1, -1, -1, 736, 430, - -1, 165, 166, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 750, -1, -1, -1, -1, 755, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 1073, -1, -1, -1, 476, -1, -1, 479, -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, 28, 29, 30, 817, - 32, 33, 34, 35, -1, -1, 824, 39, -1, 253, - 42, -1, -1, 524, -1, -1, -1, -1, -1, -1, - -1, -1, 840, -1, 842, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 855, 70, -1, - 72, -1, 74, 861, -1, 77, 78, -1, -1, 81, - -1, -1, -1, -1, 872, -1, 567, 568, 876, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 586, 587, -1, -1, -1, - -1, -1, -1, -1, 116, -1, 1198, -1, -1, 600, - 122, 123, 603, 604, -1, -1, -1, -1, -1, 610, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 620, - -1, 622, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 632, -1, -1, -1, -1, -1, -1, -1, -1, - 641, 642, 40, 41, 378, 43, -1, -1, -1, -1, - -1, -1, 960, -1, -1, -1, 657, -1, -1, -1, - 661, 662, -1, -1, 665, 666, -1, -1, -1, -1, - -1, 69, -1, 674, -1, -1, -1, 75, -1, -1, - -1, 79, -1, 154, 82, 83, 84, 85, 86, 87, - 88, 89, -1, 91, 92, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 705, 706, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 114, 451, 116, 1027, - -1, -1, -1, -1, 122, 123, 124, 125, 126, 127, - -1, -1, -1, -1, -1, -1, -1, 471, -1, -1, - -1, -1, 743, -1, -1, -1, -1, 1349, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 1069, -1, -1, -1, -1, 1074, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 1084, -1, -1, -1, - 514, -1, 783, -1, -1, -1, -1, -1, -1, -1, - 524, -1, -1, -1, -1, 529, -1, 1399, 532, 800, - 1108, 802, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 545, 813, 1121, -1, -1, -1, 1125, -1, -1, - 1128, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 1144, 1145, -1, -1, - -1, 575, -1, -1, -1, -1, -1, -1, 582, -1, - -1, -1, -1, 587, 1162, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 337, -1, 602, -1, - -1, 342, 343, -1, 1476, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 889, -1, - -1, -1, 363, -1, -1, 896, 367, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 908, 909, -1, - 644, -1, -1, -1, -1, -1, -1, -1, 652, 1227, - -1, -1, 154, -1, -1, -1, -1, -1, -1, 930, - -1, -1, -1, 1535, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 952, 953, -1, -1, -1, -1, -1, -1, 430, - -1, 962, -1, -1, -1, -1, -1, 968, 969, -1, - 971, 972, 973, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 983, 984, -1, -1, -1, -1, -1, 460, - -1, -1, -1, -1, -1, -1, -1, -1, 1306, 733, - 1308, -1, -1, -1, -1, -1, -1, -1, 479, 743, - 1318, 745, 1320, -1, 748, -1, -1, -1, -1, -1, - 754, -1, -1, -1, -1, -1, -1, 1335, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 1353, 1354, 1048, -1, 1050, - -1, 1052, -1, 524, -1, -1, 1057, -1, 1366, -1, - -1, 795, 796, 1371, -1, -1, 1374, -1, -1, -1, - -1, -1, 1073, -1, -1, -1, -1, 811, -1, -1, - -1, -1, 1390, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 1400, -1, -1, 1403, -1, 1405, 1406, 1407, - -1, -1, -1, -1, -1, 337, -1, -1, -1, -1, - 342, 343, -1, 1114, -1, 586, 587, -1, -1, 590, - 854, -1, -1, -1, 858, -1, -1, -1, -1, -1, - -1, 363, -1, 40, 41, 367, 43, 1445, -1, 1447, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 1457, - -1, 622, -1, -1, 625, 889, -1, -1, -1, 1467, - -1, 632, 69, 634, -1, -1, -1, 638, 75, -1, - 641, 642, 79, -1, -1, 82, 83, 84, 85, 86, - 87, 88, 89, -1, 91, 92, 657, -1, -1, -1, - 924, -1, 1193, -1, -1, -1, 930, 1198, 430, -1, - -1, -1, -1, 937, -1, 676, -1, 114, 942, 116, - 1211, 945, -1, -1, -1, 122, 123, 124, 125, 126, - 127, 692, -1, -1, -1, -1, -1, -1, 460, -1, - -1, 965, -1, -1, 705, -1, 707, -1, -1, -1, - -1, -1, 976, -1, -1, -1, -1, 479, -1, -1, - -1, -1, -1, -1, -1, -1, 1257, 1258, -1, -1, - -1, -1, 996, -1, 998, -1, -1, -1, -1, -1, - -1, -1, 743, -1, -1, -1, -1, -1, -1, 1013, - 1014, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 28, -1, 524, -1, -1, 1296, 1297, -1, -1, 1300, - -1, -1, -1, -1, -1, -1, 1040, -1, 779, -1, - -1, -1, -1, -1, 154, -1, -1, -1, 789, 790, - -1, -1, 793, -1, 795, 796, -1, -1, -1, -1, - 801, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 83, -1, -1, -1, -1, - -1, -1, -1, -1, 586, 587, -1, -1, 590, 1093, - -1, 99, -1, 101, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 1114, -1, -1, 1384, -1, -1, -1, -1, -1, -1, - 622, -1, -1, 625, 40, 41, -1, 43, 1132, 1133, - 632, -1, 634, -1, -1, -1, 638, -1, -1, 641, - 642, -1, -1, -1, -1, -1, -1, -1, 889, -1, - -1, -1, -1, 69, -1, 657, -1, -1, -1, 75, - -1, -1, -1, 79, -1, -1, 82, 83, 84, 85, - 86, 87, 88, 89, 676, 91, 92, -1, -1, 187, - 188, -1, -1, -1, 192, -1, 194, 195, -1, 930, - 692, -1, -1, -1, -1, -1, -1, -1, 114, -1, - 116, -1, -1, 705, 1475, 707, 122, 123, 124, 125, - 126, 127, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 962, -1, -1, 965, -1, -1, 337, -1, -1, - -1, -1, 342, 343, 1505, 1506, -1, -1, -1, 980, - 981, 743, 983, 984, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 363, -1, -1, -1, 367, -1, -1, - -1, -1, -1, -1, 1535, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 779, -1, 1283, - -1, -1, -1, 1287, -1, -1, -1, 789, 790, -1, - -1, 793, -1, 795, 796, -1, -1, -1, -1, 801, - 1041, 1042, -1, -1, -1, -1, -1, -1, -1, 40, - 41, -1, 43, -1, -1, -1, -1, -1, -1, -1, - 430, -1, -1, -1, -1, -1, 334, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 69, -1, - -1, -1, -1, -1, 75, 353, -1, -1, 79, -1, - 460, 82, 83, 84, 85, 86, 87, 88, 89, -1, - 91, 92, -1, -1, -1, -1, -1, -1, -1, 479, - -1, -1, -1, 1114, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 114, -1, 116, -1, 889, -1, -1, - -1, 122, 123, 124, 125, 126, 127, 405, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 524, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 930, -1, - -1, -1, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - 28, 29, -1, -1, 32, 33, 34, -1, -1, -1, - 962, -1, -1, 965, 42, 43, -1, -1, 1209, -1, - 1211, -1, -1, -1, -1, -1, 586, 587, 980, 981, - 590, 983, 984, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 70, -1, -1, -1, -1, 1238, -1, 77, - 78, -1, -1, -1, -1, 1246, 1247, 1248, -1, -1, - -1, -1, 622, -1, -1, 625, 1257, 1258, 1522, -1, - -1, -1, 632, -1, 634, -1, -1, -1, 638, -1, - -1, 641, 642, -1, -1, -1, -1, -1, 116, 1041, - 1042, -1, 120, -1, 122, 123, -1, 657, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 571, 572, -1, 676, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 692, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 705, 604, 707, -1, 607, - 608, -1, 610, -1, 612, 613, -1, -1, -1, 617, - 618, -1, 1114, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 743, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 1384, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 661, -1, -1, -1, 665, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 779, - -1, -1, 1413, -1, -1, -1, -1, -1, -1, 789, - 790, -1, -1, 793, -1, 795, 796, -1, -1, -1, - -1, 801, -1, -1, -1, -1, -1, -1, -1, -1, - 1441, -1, 1443, -1, -1, -1, -1, 1209, -1, 1211, - -1, -1, -1, -1, -1, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 1476, 1238, 32, 33, 34, - 1481, -1, 1483, -1, 1246, 1247, 1248, 42, -1, -1, - -1, -1, -1, -1, -1, 1257, 1258, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 70, -1, -1, -1, 889, - -1, -1, 77, 78, -1, -1, -1, -1, -1, -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, 27, 28, 29, - 930, 116, 32, 33, 34, 35, -1, 122, 123, 39, - -1, -1, 42, 43, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 962, -1, -1, 965, -1, 67, -1, -1, - 70, -1, 72, -1, 74, 75, -1, 77, 78, 79, - 980, 981, -1, 983, 984, -1, -1, -1, 88, 89, - -1, -1, 1384, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 114, -1, 116, -1, -1, -1, - -1, 1413, 122, 123, -1, 42, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 1041, 1042, -1, -1, -1, -1, -1, -1, 1441, - -1, 1443, -1, 70, 952, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 81, -1, -1, -1, -1, -1, - 968, -1, -1, 971, 972, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 1476, -1, -1, -1, -1, 1481, - -1, 1483, -1, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 1114, 32, 33, 34, -1, -1, - -1, -1, -1, -1, -1, 42, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 1044, -1, -1, -1, - -1, -1, -1, 70, -1, -1, -1, -1, -1, -1, - 77, 78, -1, -1, 1062, 1063, -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, 28, 29, -1, -1, 32, 33, 34, - 35, -1, -1, -1, 39, 122, 123, 42, 43, 1209, - -1, 1211, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 1119, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 67, -1, -1, 70, -1, 72, 1238, 74, - 75, -1, 77, 78, 79, -1, 1246, 1247, 1248, -1, - -1, -1, -1, 88, 89, -1, -1, 1257, 1258, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 114, - -1, 116, -1, 1181, -1, 120, -1, 122, 123, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 1200, -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, - 27, 28, 29, -1, -1, 32, 33, 34, 35, -1, - -1, -1, 39, 40, 41, 42, 43, 44, -1, 46, - -1, -1, 49, 50, 51, 52, 53, 54, 55, 56, - -1, -1, -1, 60, -1, -1, -1, 64, 65, -1, - 67, -1, 69, 70, -1, 72, -1, 74, 75, -1, - 77, 78, 79, -1, 1384, 82, 83, 84, 85, 86, - 87, 88, 89, -1, 91, 92, -1, -1, 1296, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 1413, -1, -1, -1, 114, -1, 116, - -1, -1, 119, -1, -1, 122, 123, 124, 125, 126, - 127, -1, -1, -1, -1, 132, -1, -1, -1, -1, - 137, 1441, -1, 1443, -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, 27, 28, 29, -1, 1476, 32, 33, 34, - 35, 1481, -1, 1483, 39, 40, 41, 42, 43, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, - -1, -1, -1, -1, 69, 70, -1, 72, -1, 74, - 75, 42, 77, 78, 79, -1, -1, 82, 83, 84, - 85, 86, 87, 88, 89, -1, 91, 92, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 70, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 114, - 81, 116, -1, -1, -1, -1, -1, 122, 123, 124, - 125, 126, 127, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 137, 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, - -1, -1, 32, 33, 34, 35, -1, -1, -1, 39, - 40, 41, 42, 43, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 28, 29, -1, -1, 32, 33, 34, 69, - 70, -1, 72, -1, 74, 75, 42, 77, 78, 79, - -1, -1, 82, 83, 84, 85, 86, 87, 88, 89, - -1, 91, 92, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 70, -1, -1, -1, -1, -1, - -1, 77, 78, -1, 114, -1, 116, -1, -1, -1, - -1, -1, 122, 123, 124, 125, 126, 127, 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, -1, -1, 32, 33, 34, -1, - -1, -1, -1, -1, 40, 41, 42, 43, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, 28, 29, -1, -1, - 32, 33, 34, 69, 70, -1, 72, -1, 74, 75, - 42, 77, 78, 79, -1, -1, 82, 83, 84, 85, - 86, 87, 88, 89, -1, 91, 92, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 70, -1, - -1, -1, -1, -1, -1, 77, 78, -1, 114, -1, - 116, -1, -1, -1, -1, 121, 122, 123, 124, 125, - 126, 127, 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, -1, -1, - 32, 33, 34, -1, -1, -1, -1, -1, 40, 41, - 42, 43, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - 28, 29, -1, -1, 32, 33, 34, 69, 70, -1, - 72, -1, 74, 75, 42, 77, 78, 79, -1, -1, - 82, 83, 84, 85, 86, 87, 88, 89, -1, 91, - 92, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 70, -1, -1, -1, -1, -1, -1, 77, - 78, -1, 114, -1, 116, -1, -1, -1, -1, 121, - 122, 123, 124, 125, 126, 127, 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, -1, -1, 32, 33, 34, -1, -1, -1, - -1, -1, 40, 41, 42, 43, -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, 69, 70, -1, 72, -1, 74, 75, -1, 77, - 78, 79, -1, -1, 82, 83, 84, 85, 86, 87, - 88, 89, -1, 91, 92, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 114, -1, 116, -1, - -1, -1, -1, -1, 122, 123, 124, 125, 126, 127, - 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, -1, -1, 32, 33, - 34, -1, -1, -1, -1, -1, 40, 41, 42, 43, - -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, 69, 70, -1, 72, -1, - 74, 75, -1, 77, 78, 79, -1, -1, 82, 83, - 84, 85, 86, 87, 88, 89, -1, 91, 92, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 114, -1, 116, -1, -1, -1, -1, -1, 122, 123, - 124, 125, 126, 127, 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, - -1, -1, 32, 33, 34, -1, -1, -1, -1, -1, - 40, 41, 42, 43, -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, 69, - 70, -1, 72, -1, 74, 75, -1, 77, 78, 79, - -1, -1, 82, 83, 84, 85, 86, 87, 88, 89, - -1, 91, 92, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 114, -1, 116, -1, -1, -1, - -1, -1, 122, 123, 124, 125, 126, 127, 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, -1, -1, 32, 33, 34, - 35, -1, -1, -1, 39, -1, -1, 42, 43, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 67, -1, -1, 70, -1, 72, -1, 74, - 75, -1, 77, 78, 79, -1, -1, -1, -1, -1, - -1, -1, -1, 88, 89, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 114, - -1, 116, -1, -1, -1, -1, -1, 122, 123, 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, -1, -1, 32, 33, - 34, -1, -1, -1, -1, -1, -1, -1, 42, -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, 70, -1, 72, -1, - 74, 75, -1, 77, 78, 79, -1, -1, -1, -1, - -1, -1, -1, -1, 88, 89, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 114, -1, 116, -1, -1, -1, -1, -1, 122, 123, - 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, -1, -1, 32, - 33, 34, 35, -1, -1, -1, 39, -1, -1, 42, - -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, 70, -1, 72, - -1, 74, -1, -1, 77, 78, 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, -1, -1, 32, 33, 34, -1, -1, - -1, -1, -1, 116, -1, 42, -1, -1, -1, 122, - 123, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 70, -1, 72, -1, 74, -1, -1, - 77, 78, 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, -1, -1, - 32, 33, 34, -1, -1, -1, -1, -1, -1, 116, - 42, -1, -1, -1, -1, 122, 123, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 70, -1, - 72, -1, 74, 75, -1, 77, 78, 79, -1, -1, - -1, -1, -1, -1, -1, -1, 88, 89, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 114, -1, 116, -1, -1, -1, -1, -1, - 122, 123, 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, -1, -1, - 32, 33, 34, -1, -1, -1, -1, -1, -1, -1, - 42, -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, 70, -1, - 72, -1, 74, -1, -1, 77, 78, 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, -1, -1, 32, 33, 34, -1, -1, - -1, -1, -1, 115, 116, 42, -1, -1, -1, -1, - 122, 123, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 70, -1, 72, -1, 74, -1, -1, - 77, 78, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 101, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 116, - -1, -1, -1, -1, -1, 122, 123, 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, -1, -1, 32, 33, 34, -1, -1, - -1, -1, -1, -1, -1, 42, -1, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 28, 29, -1, -1, 32, - 33, 34, -1, 70, -1, 72, -1, 74, -1, 42, - 77, 78, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 101, -1, -1, 70, -1, -1, - -1, -1, -1, -1, 77, 78, -1, -1, -1, 116, - -1, -1, -1, -1, -1, 122, 123, 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, 116, -1, 32, 33, 34, -1, 122, - 123, -1, -1, -1, -1, 42, -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, 70, -1, 72, -1, 74, -1, -1, - 77, 78, 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, -1, -1, - 32, 33, 34, -1, -1, -1, -1, -1, -1, 116, - 42, -1, -1, -1, -1, 122, 123, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 70, -1, - 72, -1, 74, -1, -1, 77, 78, 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, -1, -1, 32, 33, 34, -1, -1, - -1, -1, -1, -1, 116, 42, -1, -1, -1, -1, - 122, 123, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 70, -1, 72, -1, 74, -1, -1, - 77, 78, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - 28, 29, -1, -1, 32, 33, 34, -1, -1, -1, - -1, -1, 40, 41, 42, 43, -1, -1, -1, 116, - -1, -1, -1, -1, -1, 122, 123, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 69, 70, -1, -1, -1, -1, 75, -1, 77, - 78, 79, -1, -1, 82, 83, 84, 85, 86, 87, - 88, 89, -1, 91, 92, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 114, -1, 116, -1, - -1, 119, -1, -1, 122, 123, 124, 125, 126, 127, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, - -1, -1, 32, 33, 34, -1, -1, -1, -1, -1, - 40, 41, 42, 43, -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, 69, - 70, -1, -1, -1, -1, 75, -1, 77, 78, 79, - -1, -1, 82, 83, 84, 85, 86, 87, 88, 89, - -1, 91, 92, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 114, 115, 116, -1, -1, -1, - -1, -1, 122, 123, 124, 125, 126, 127, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, 28, 29, -1, -1, - 32, 33, 34, -1, -1, -1, -1, -1, 40, 41, - 42, 43, -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, 69, 70, -1, - -1, -1, -1, 75, -1, 77, 78, 79, -1, -1, - 82, 83, 84, 85, 86, 87, 88, 89, -1, 91, - 92, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 114, -1, 116, -1, -1, -1, -1, -1, - 122, 123, 124, 125, 126, 127, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 28, 29, -1, -1, 32, 33, - 34, -1, -1, -1, -1, -1, 40, 41, 42, 43, - -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, 69, 70, -1, -1, -1, - -1, 75, -1, 77, 78, 79, -1, -1, 82, 83, - 84, 85, 86, 87, 88, 89, -1, 91, 92, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 114, -1, 116, -1, -1, -1, -1, -1, 122, 123, - 124, 125, 126, 127, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 28, 29, -1, -1, 32, 33, 34, -1, - -1, -1, -1, -1, 40, 41, 42, 43, -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, 69, 70, -1, -1, -1, -1, 75, - -1, 77, 78, 79, -1, -1, 82, 83, 84, 85, - 86, 87, 88, 89, -1, 91, 92, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 114, -1, - 116, -1, -1, -1, -1, -1, 122, 123, 124, 125, - 126, 127, 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, -1, - -1, 32, 33, 34, -1, -1, -1, -1, -1, -1, - -1, 42, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - 28, 29, -1, -1, 32, 33, 34, -1, -1, 70, - -1, 72, -1, 74, 42, -1, 77, 78, -1, -1, - -1, -1, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - 28, 29, 70, -1, 32, 33, 34, 75, -1, 77, - 78, 79, -1, -1, 42, -1, -1, -1, 119, -1, - 88, 89, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 70, -1, -1, -1, 114, 75, 116, 77, - 78, 79, -1, -1, 122, 123, -1, -1, -1, -1, - 88, 89, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 114, -1, 116, -1, - -1, -1, -1, -1, 122, 123, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 28, 29, -1, -1, 32, 33, - 34, -1, -1, -1, -1, -1, -1, -1, 42, -1, - -1, -1, -1, -1, -1, -1, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 28, 29, 70, -1, 32, 33, - 34, 75, -1, 77, 78, -1, -1, -1, 42, 43, - -1, -1, -1, -1, 88, 89, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 70, -1, -1, -1, - -1, -1, 116, 77, 78, -1, -1, -1, 122, 123, - -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, - 29, -1, -1, 32, 33, 34, -1, -1, -1, -1, - -1, -1, 116, 42, 43, -1, 120, -1, 122, 123, - -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, - 29, 70, -1, 32, 33, 34, -1, -1, 77, 78, - -1, -1, -1, 42, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 28, 29, -1, -1, 32, 33, 34, -1, - -1, 70, -1, -1, -1, -1, 42, 116, 77, 78, - -1, 120, -1, 122, 123, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 70, -1, -1, -1, -1, -1, - -1, 77, 78, -1, -1, -1, -1, 116, -1, -1, - -1, -1, -1, 122, 123, -1, -1, -1, -1, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, 27, 28, 29, -1, - 116, 32, 33, 34, -1, -1, 122, 123, -1, -1, - -1, 42, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - 28, 29, -1, -1, 32, 33, 34, -1, -1, 70, - -1, -1, -1, -1, 42, -1, 77, 78, -1, -1, - -1, -1, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - 28, 29, 70, -1, 32, 33, 34, -1, -1, 77, - 78, -1, -1, -1, 42, 116, -1, -1, -1, -1, - -1, 122, 123, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 70, -1, -1, -1, -1, -1, 116, 77, - 78, -1, -1, -1, 122, 123, -1, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 28, 29, -1, -1, 32, - 33, 34, -1, -1, -1, -1, -1, -1, 116, 42, - -1, -1, -1, -1, 122, 123, -1, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 28, 29, 70, -1, 32, - 33, 34, -1, -1, 77, 78, -1, -1, -1, 42, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, - -1, -1, 32, 33, 34, -1, -1, 70, -1, -1, - -1, -1, 42, 116, 77, 78, -1, -1, -1, 122, - 123, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 70, -1, -1, -1, -1, -1, -1, 77, 78, -1, - -1, -1, -1, 116, -1, -1, -1, -1, -1, 122, - 123, -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, 116, -1, -1, -1, - -1, -1, 122, 123, 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, - -1, -1, 32, 33, 34, -1, -1, -1, -1, -1, - -1, -1, 42, -1, 40, 41, -1, 43, 44, -1, - 46, -1, -1, 49, 50, 51, 52, 53, 54, 55, - 56, -1, -1, 59, 60, -1, -1, -1, 64, 65, - 70, 67, 72, 69, 74, -1, -1, 77, 78, 75, - -1, 77, 78, 79, -1, -1, 82, 83, 84, 85, - 86, 87, 88, 89, -1, 91, 92, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 115, -1, -1, 114, -1, - 116, -1, -1, 119, -1, -1, 122, 123, 124, 125, - 126, 127, -1, -1, 40, 41, 132, 43, 44, -1, - 46, 137, -1, 49, 50, 51, 52, 53, 54, 55, - 56, -1, -1, -1, 60, -1, -1, -1, 64, 65, - -1, 67, -1, 69, -1, -1, -1, -1, -1, 75, - -1, 77, 78, 79, -1, -1, 82, 83, 84, 85, - 86, 87, 88, 89, -1, 91, 92, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 114, -1, - 116, -1, -1, 119, -1, -1, 122, 123, 124, 125, - 126, 127, -1, -1, -1, -1, 132, -1, -1, -1, - -1, 137, 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, -1, -1, - 32, 33, 34, -1, -1, -1, -1, -1, -1, -1, - 42, -1, 40, 41, -1, 43, 44, -1, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, -1, - -1, 59, 60, -1, -1, -1, 64, 65, 70, 67, - 72, 69, 74, -1, -1, 77, 78, 75, -1, 77, - 78, 79, -1, -1, 82, 83, 84, 85, 86, 87, - 88, 89, -1, 91, 92, -1, -1, -1, -1, 101, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 114, -1, 116, -1, - -1, 119, -1, -1, 122, 123, 124, 125, 126, 127, - -1, -1, 40, 41, 132, 43, 44, -1, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, -1, - -1, -1, 60, -1, -1, -1, 64, 65, -1, 67, - -1, 69, -1, -1, -1, -1, -1, 75, -1, 77, - 78, 79, -1, -1, 82, 83, 84, 85, 86, 87, - 88, 89, -1, 91, 92, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 114, -1, 116, -1, - -1, 119, -1, -1, 122, 123, 124, 125, 126, 127, - -1, -1, 40, 41, 132, 43, 44, -1, 46, -1, - -1, 49, 50, 51, 52, 53, 54, 55, 56, -1, - -1, -1, 60, -1, -1, -1, 64, 65, -1, 67, - -1, 69, -1, -1, -1, -1, -1, 75, -1, 77, - 78, 79, -1, -1, 82, 83, 84, 85, 86, 87, - 88, 89, -1, 91, 92, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 114, -1, 116, -1, - -1, 119, -1, -1, 122, 123, 124, 125, 126, 127, - -1, -1, -1, -1, 132, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, -1, -1, 32, 33, 34, - -1, -1, -1, -1, -1, -1, -1, 42, 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, 70, -1, 32, 33, 34, - 75, -1, 77, 78, -1, -1, -1, 42, -1, -1, - -1, -1, -1, 88, 89, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 70, -1, 72, -1, 74, - -1, -1, 77, 78, 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, -1, -1, 32, 33, 34, -1, -1, -1, -1, - -1, -1, -1, 42, -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, 70, -1, 72, -1, 74, -1, -1, 77, 78, - 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, -1, -1, 32, 33, - 34, -1, -1, -1, -1, -1, -1, -1, 42, -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, 70, -1, 72, -1, - 74, -1, -1, 77, 78, 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, -1, -1, 32, 33, 34, -1, -1, -1, -1, - -1, -1, -1, 42, -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, 70, -1, 72, -1, 74, -1, -1, 77, 78, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, - -1, -1, 32, 33, 34, 35, 36, 37, 38, -1, - -1, -1, 42, -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, - 70, -1, -1, -1, -1, -1, -1, 77, 78 -}; - -/* 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, 27, 28, 29, 32, 33, - 34, 35, 39, 42, 43, 67, 70, 72, 74, 75, - 77, 78, 79, 88, 89, 114, 116, 122, 123, 142, - 145, 157, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 232, 234, 236, 237, 238, 239, 241, - 242, 243, 244, 245, 246, 247, 249, 250, 253, 254, - 255, 257, 259, 260, 268, 270, 296, 297, 298, 306, - 309, 315, 316, 318, 320, 321, 327, 332, 336, 337, - 338, 339, 340, 341, 342, 343, 363, 380, 381, 382, - 383, 75, 144, 145, 157, 223, 225, 234, 237, 246, - 250, 254, 297, 84, 114, 325, 326, 327, 75, 77, - 78, 79, 143, 144, 286, 287, 307, 308, 77, 78, - 287, 114, 318, 114, 114, 157, 332, 337, 338, 339, - 341, 342, 343, 117, 139, 226, 234, 237, 336, 340, - 379, 380, 383, 384, 140, 112, 136, 290, 119, 140, - 181, 77, 78, 142, 285, 140, 140, 140, 77, 78, - 114, 157, 231, 322, 331, 332, 333, 334, 335, 336, - 340, 344, 345, 346, 347, 348, 354, 3, 30, 81, - 248, 3, 5, 77, 116, 157, 225, 238, 242, 244, - 255, 298, 336, 340, 383, 223, 225, 237, 246, 250, - 254, 297, 336, 340, 35, 243, 243, 238, 244, 140, - 243, 238, 243, 238, 325, 243, 238, 121, 140, 140, - 0, 139, 114, 181, 325, 325, 139, 116, 234, 237, - 381, 285, 285, 136, 237, 114, 157, 322, 332, 336, - 116, 157, 383, 319, 240, 119, 287, 327, 114, 303, - 114, 114, 84, 146, 147, 40, 41, 43, 69, 75, - 79, 82, 83, 85, 86, 87, 91, 92, 114, 116, - 124, 125, 126, 127, 141, 145, 146, 148, 149, 156, - 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 172, 175, 234, 288, 289, 305, - 379, 384, 237, 115, 115, 115, 115, 115, 115, 115, - 116, 234, 363, 381, 32, 116, 122, 157, 172, 225, - 226, 233, 237, 241, 242, 245, 246, 251, 252, 253, - 254, 256, 259, 260, 270, 275, 276, 280, 281, 282, - 283, 296, 297, 363, 375, 376, 377, 378, 383, 384, - 114, 336, 340, 383, 114, 121, 137, 116, 119, 157, - 172, 291, 291, 120, 139, 121, 137, 114, 121, 137, - 121, 137, 121, 137, 332, 333, 334, 335, 345, 346, - 347, 348, 237, 331, 344, 121, 140, 67, 324, 116, - 325, 362, 363, 325, 325, 181, 139, 114, 325, 362, - 325, 325, 237, 322, 114, 114, 236, 237, 234, 237, - 139, 234, 379, 384, 181, 139, 285, 290, 225, 242, - 336, 340, 181, 139, 307, 237, 246, 137, 237, 237, - 78, 114, 119, 287, 298, 237, 307, 137, 137, 318, - 139, 144, 284, 3, 140, 215, 216, 230, 232, 237, - 241, 139, 324, 114, 324, 172, 332, 237, 114, 139, - 285, 119, 35, 36, 37, 38, 234, 299, 300, 302, - 271, 287, 269, 139, 133, 136, 304, 139, 10, 75, - 77, 78, 328, 329, 330, 115, 84, 114, 156, 114, - 156, 159, 114, 156, 114, 114, 156, 156, 116, 172, - 177, 181, 288, 383, 139, 86, 90, 91, 92, 114, - 116, 118, 119, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 136, 174, 159, 159, 122, 128, - 129, 124, 125, 93, 94, 95, 96, 130, 131, 97, - 98, 123, 132, 133, 99, 100, 134, 114, 157, 358, - 359, 360, 361, 362, 115, 121, 114, 362, 363, 114, - 362, 363, 139, 234, 381, 325, 117, 139, 140, 235, - 237, 246, 252, 254, 297, 374, 375, 383, 384, 140, - 114, 116, 136, 157, 332, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 363, 364, 365, 366, 367, 368, - 369, 386, 157, 256, 383, 237, 252, 243, 238, 325, - 140, 140, 157, 235, 237, 376, 285, 235, 363, 376, - 285, 139, 139, 139, 139, 75, 116, 118, 145, 287, - 291, 292, 293, 294, 295, 139, 139, 139, 139, 139, - 139, 115, 115, 115, 115, 115, 115, 115, 331, 344, - 325, 137, 114, 290, 117, 215, 139, 322, 177, 289, - 177, 289, 322, 116, 215, 324, 181, 139, 215, 305, - 261, 258, 237, 277, 278, 279, 282, 283, 115, 121, - 181, 139, 237, 122, 172, 139, 233, 237, 276, 375, - 383, 316, 317, 114, 157, 349, 115, 121, 386, 287, - 121, 385, 136, 272, 119, 299, 114, 119, 287, 289, - 299, 115, 121, 114, 137, 288, 116, 288, 288, 151, - 172, 289, 288, 139, 115, 121, 115, 115, 121, 172, - 116, 144, 150, 151, 139, 116, 144, 150, 172, 159, - 159, 159, 160, 160, 161, 161, 162, 162, 162, 162, - 163, 163, 164, 165, 166, 167, 168, 135, 177, 139, - 359, 360, 361, 237, 358, 325, 325, 172, 289, 139, - 139, 287, 235, 363, 376, 237, 241, 117, 383, 117, - 114, 139, 332, 350, 351, 352, 355, 365, 366, 367, - 117, 139, 172, 237, 349, 353, 364, 114, 325, 368, - 386, 325, 325, 386, 114, 325, 368, 325, 325, 386, - 325, 325, 363, 235, 374, 384, 285, 237, 287, 117, - 121, 117, 121, 386, 235, 376, 386, 273, 274, 275, - 276, 273, 285, 172, 139, 116, 287, 135, 121, 385, - 291, 116, 135, 295, 31, 217, 218, 285, 273, 144, - 322, 144, 114, 325, 362, 363, 114, 325, 362, 363, - 322, 146, 363, 181, 277, 115, 115, 115, 115, 139, - 181, 215, 181, 115, 43, 120, 234, 262, 263, 379, - 119, 140, 140, 144, 230, 140, 140, 273, 114, 157, - 383, 140, 120, 237, 300, 301, 287, 120, 170, 171, - 271, 140, 139, 139, 114, 140, 115, 329, 150, 115, - 139, 121, 115, 115, 115, 115, 172, 119, 159, 172, - 173, 176, 121, 139, 115, 121, 172, 139, 120, 170, - 135, 277, 115, 115, 115, 358, 277, 277, 235, 376, - 116, 122, 157, 172, 172, 237, 355, 277, 115, 115, - 115, 115, 115, 115, 115, 7, 237, 349, 353, 364, - 139, 139, 386, 139, 139, 140, 140, 140, 140, 290, - 170, 171, 172, 323, 139, 291, 293, 120, 139, 219, - 287, 43, 44, 46, 49, 50, 51, 52, 53, 54, - 55, 56, 60, 64, 65, 67, 75, 77, 78, 79, - 132, 145, 177, 178, 179, 180, 181, 182, 183, 185, - 186, 198, 200, 201, 206, 220, 285, 321, 31, 140, - 136, 139, 139, 324, 115, 140, 181, 119, 234, 263, - 114, 135, 157, 264, 265, 267, 331, 332, 344, 362, - 370, 371, 372, 373, 121, 137, 287, 261, 115, 121, - 117, 117, 140, 237, 121, 386, 303, 272, 385, 115, - 299, 223, 225, 234, 311, 312, 313, 314, 305, 115, - 115, 144, 292, 121, 140, 176, 82, 85, 87, 144, - 152, 153, 154, 151, 140, 152, 170, 140, 114, 325, - 362, 363, 140, 140, 139, 140, 140, 140, 172, 115, - 140, 114, 325, 362, 363, 114, 325, 368, 114, 325, - 368, 363, 236, 7, 122, 140, 172, 277, 277, 276, - 280, 280, 281, 115, 121, 121, 115, 101, 127, 140, - 140, 152, 291, 172, 121, 137, 220, 321, 114, 114, - 179, 114, 114, 137, 285, 137, 285, 122, 285, 178, - 114, 181, 173, 173, 11, 207, 149, 137, 140, 139, - 140, 135, 219, 115, 172, 277, 277, 290, 325, 115, - 261, 264, 137, 332, 371, 372, 373, 171, 237, 370, - 121, 137, 266, 267, 266, 325, 325, 287, 120, 139, - 115, 139, 120, 140, 322, 120, 139, 140, 140, 115, - 119, 115, 385, 173, 117, 140, 155, 116, 153, 155, - 155, 121, 140, 90, 118, 117, 140, 115, 139, 115, - 115, 117, 117, 117, 140, 115, 139, 139, 139, 172, - 172, 140, 117, 140, 140, 140, 140, 139, 139, 171, - 171, 117, 117, 140, 287, 177, 177, 50, 177, 139, - 137, 137, 177, 137, 137, 177, 61, 62, 63, 202, - 203, 204, 137, 66, 137, 54, 114, 119, 183, 120, - 325, 137, 140, 140, 120, 137, 115, 115, 115, 370, - 325, 101, 282, 283, 115, 312, 121, 137, 121, 137, - 120, 310, 120, 117, 86, 139, 153, 117, 116, 153, - 116, 153, 117, 277, 117, 277, 277, 277, 140, 140, - 117, 117, 115, 115, 117, 121, 101, 276, 101, 140, - 117, 115, 115, 114, 115, 178, 199, 220, 224, 237, - 241, 137, 115, 114, 114, 181, 204, 61, 62, 172, - 114, 146, 150, 179, 115, 115, 114, 325, 362, 363, - 265, 119, 139, 139, 311, 152, 139, 139, 140, 140, - 140, 140, 117, 117, 139, 140, 117, 179, 47, 48, - 119, 189, 190, 191, 177, 179, 140, 115, 178, 237, - 119, 191, 101, 139, 101, 139, 114, 114, 137, 146, - 115, 135, 120, 139, 139, 285, 322, 120, 140, 152, - 152, 115, 115, 115, 115, 280, 45, 171, 187, 188, - 323, 135, 139, 179, 189, 115, 137, 179, 137, 139, - 115, 139, 115, 139, 101, 139, 101, 139, 135, 137, - 116, 146, 208, 209, 210, 137, 277, 311, 117, 140, - 140, 179, 101, 121, 135, 140, 213, 214, 220, 137, - 178, 178, 213, 181, 205, 235, 237, 379, 181, 205, - 115, 139, 115, 139, 135, 171, 114, 115, 135, 121, - 140, 120, 117, 117, 171, 187, 190, 192, 193, 139, - 137, 190, 194, 195, 140, 114, 157, 322, 370, 144, - 140, 181, 205, 181, 205, 208, 117, 171, 137, 208, - 210, 115, 114, 179, 184, 120, 190, 220, 178, 59, - 184, 197, 120, 190, 115, 237, 115, 140, 140, 135, - 146, 115, 115, 135, 305, 179, 184, 137, 196, 197, - 184, 197, 181, 181, 115, 115, 146, 211, 114, 137, - 211, 115, 196, 140, 140, 181, 181, 121, 135, 171, - 115, 140, 140, 146, 144, 212, 115, 137, 115, 121, - 137, 144 -}; - -#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 326 "parser.yy" - { typedefTable.enterScope(); } - break; - - case 3: - -/* Line 1806 of yacc.c */ -#line 330 "parser.yy" - { typedefTable.leaveScope(); } - break; - - case 4: - -/* Line 1806 of yacc.c */ -#line 337 "parser.yy" - { (yyval.en) = new ExpressionNode( build_constantInteger( *(yyvsp[(1) - (1)].tok) ) ); } - break; - - case 5: - -/* Line 1806 of yacc.c */ -#line 338 "parser.yy" - { (yyval.en) = new ExpressionNode( build_constantFloat( *(yyvsp[(1) - (1)].tok) ) ); } - break; - - case 6: - -/* Line 1806 of yacc.c */ -#line 339 "parser.yy" - { (yyval.en) = new ExpressionNode( build_constantFloat( *(yyvsp[(1) - (1)].tok) ) ); } - break; - - case 7: - -/* Line 1806 of yacc.c */ -#line 340 "parser.yy" - { (yyval.en) = new ExpressionNode( build_constantFloat( *(yyvsp[(1) - (1)].tok) ) ); } - break; - - case 8: - -/* Line 1806 of yacc.c */ -#line 341 "parser.yy" - { (yyval.en) = new ExpressionNode( build_constantChar( *(yyvsp[(1) - (1)].tok) ) ); } - break; - - case 18: - -/* Line 1806 of yacc.c */ -#line 366 "parser.yy" - { (yyval.constant) = build_constantStr( *(yyvsp[(1) - (1)].str) ); } - break; - - case 19: - -/* Line 1806 of yacc.c */ -#line 370 "parser.yy" - { (yyval.str) = (yyvsp[(1) - (1)].tok); } - break; - - case 20: - -/* Line 1806 of yacc.c */ -#line 372 "parser.yy" - { - appendStr( (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].tok) ); // append 2nd juxtaposed string to 1st - delete (yyvsp[(2) - (2)].tok); // allocated by lexer - (yyval.str) = (yyvsp[(1) - (2)].str); // conversion from tok to str - } - break; - - case 21: - -/* Line 1806 of yacc.c */ -#line 383 "parser.yy" - { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); } - break; - - case 22: - -/* Line 1806 of yacc.c */ -#line 385 "parser.yy" - { (yyval.en) = new ExpressionNode( build_constantZeroOne( *(yyvsp[(1) - (1)].tok) ) ); } - break; - - case 24: - -/* Line 1806 of yacc.c */ -#line 388 "parser.yy" - { (yyval.en) = (yyvsp[(2) - (3)].en); } - break; - - case 25: - -/* Line 1806 of yacc.c */ -#line 390 "parser.yy" - { (yyval.en) = new ExpressionNode( build_valexpr( (yyvsp[(2) - (3)].sn) ) ); } - break; - - case 27: - -/* Line 1806 of yacc.c */ -#line 400 "parser.yy" - { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Index, (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en) ) ); } - break; - - case 28: - -/* Line 1806 of yacc.c */ -#line 402 "parser.yy" - { (yyval.en) = new ExpressionNode( build_func( (yyvsp[(1) - (4)].en), (yyvsp[(3) - (4)].en) ) ); } - break; - - case 29: - -/* Line 1806 of yacc.c */ -#line 404 "parser.yy" - { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (3)].en), build_varref( (yyvsp[(3) - (3)].tok) ) ) ); } - break; - - case 30: - -/* Line 1806 of yacc.c */ -#line 406 "parser.yy" - { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (7)].en), build_tuple( (yyvsp[(5) - (7)].en) ) ) ); } - break; - - case 31: - -/* Line 1806 of yacc.c */ -#line 408 "parser.yy" - { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (2)].en), build_field_name_REALFRACTIONconstant( *(yyvsp[(2) - (2)].tok) ) ) ); } - break; - - case 32: - -/* Line 1806 of yacc.c */ -#line 410 "parser.yy" - { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(1) - (3)].en), build_varref( (yyvsp[(3) - (3)].tok) ) ) ); } - break; - - case 33: - -/* Line 1806 of yacc.c */ -#line 412 "parser.yy" - { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(1) - (7)].en), build_tuple( (yyvsp[(5) - (7)].en) ) ) ); } - break; - - case 34: - -/* Line 1806 of yacc.c */ -#line 414 "parser.yy" - { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, (yyvsp[(1) - (2)].en) ) ); } - break; - - case 35: - -/* Line 1806 of yacc.c */ -#line 416 "parser.yy" - { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::DecrPost, (yyvsp[(1) - (2)].en) ) ); } - break; - - case 36: - -/* Line 1806 of yacc.c */ -#line 418 "parser.yy" - { (yyval.en) = new ExpressionNode( build_compoundLiteral( (yyvsp[(2) - (7)].decl), new InitializerNode( (yyvsp[(5) - (7)].in), true ) ) ); } - break; - - case 37: - -/* Line 1806 of yacc.c */ -#line 420 "parser.yy" - { - Token fn; - fn.str = new std::string( "?{}" ); // location undefined - use location of '{'? - (yyval.en) = new ExpressionNode( new ConstructorExpr( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( (yyvsp[(1) - (4)].en) )->set_last( (yyvsp[(3) - (4)].en) ) ) ) ); - } - break; - - case 39: - -/* Line 1806 of yacc.c */ -#line 430 "parser.yy" - { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) )); } - break; - - case 40: - -/* Line 1806 of yacc.c */ -#line 435 "parser.yy" - { (yyval.en) = nullptr; } - break; - - case 43: - -/* Line 1806 of yacc.c */ -#line 441 "parser.yy" - { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); } - break; - - case 45: - -/* Line 1806 of yacc.c */ -#line 447 "parser.yy" - { (yyval.en) = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_REALDECIMALconstant( *(yyvsp[(1) - (2)].tok) ) ), maybeMoveBuild( (yyvsp[(2) - (2)].en) ) ) ); } - break; - - case 46: - -/* Line 1806 of yacc.c */ -#line 449 "parser.yy" - { (yyval.en) = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_REALDECIMALconstant( *(yyvsp[(1) - (6)].tok) ) ), build_tuple( (yyvsp[(4) - (6)].en) ) ) ); } - break; - - case 47: - -/* Line 1806 of yacc.c */ -#line 451 "parser.yy" - { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (3)].en), maybeMoveBuild( (yyvsp[(3) - (3)].en) ) ) ); } - break; - - case 48: - -/* Line 1806 of yacc.c */ -#line 453 "parser.yy" - { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (7)].en), build_tuple( (yyvsp[(5) - (7)].en) ) ) ); } - break; - - case 49: - -/* Line 1806 of yacc.c */ -#line 455 "parser.yy" - { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(1) - (3)].en), maybeMoveBuild( (yyvsp[(3) - (3)].en) ) ) ); } - break; - - case 50: - -/* Line 1806 of yacc.c */ -#line 457 "parser.yy" - { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(1) - (7)].en), build_tuple( (yyvsp[(5) - (7)].en) ) ) ); } - break; - - case 51: - -/* Line 1806 of yacc.c */ -#line 462 "parser.yy" - { (yyval.en) = new ExpressionNode( build_field_name_fraction_constants( build_constantInteger( *(yyvsp[(1) - (2)].tok) ), (yyvsp[(2) - (2)].en) ) ); } - break; - - case 52: - -/* Line 1806 of yacc.c */ -#line 464 "parser.yy" - { (yyval.en) = new ExpressionNode( build_field_name_fraction_constants( build_field_name_FLOATINGconstant( *(yyvsp[(1) - (2)].tok) ), (yyvsp[(2) - (2)].en) ) ); } - break; - - case 53: - -/* Line 1806 of yacc.c */ -#line 466 "parser.yy" - { - if( (*(yyvsp[(1) - (2)].tok)) == "0" || (*(yyvsp[(1) - (2)].tok)) == "1" ) { - (yyval.en) = new ExpressionNode( build_field_name_fraction_constants( build_constantZeroOne( *(yyvsp[(1) - (2)].tok) ), (yyvsp[(2) - (2)].en) ) ); - } else { - (yyval.en) = new ExpressionNode( build_field_name_fraction_constants( build_varref( (yyvsp[(1) - (2)].tok) ), (yyvsp[(2) - (2)].en) ) ); - } - } - break; - - case 54: - -/* Line 1806 of yacc.c */ -#line 477 "parser.yy" - { (yyval.en) = nullptr; } - break; - - case 55: - -/* Line 1806 of yacc.c */ -#line 479 "parser.yy" - { - Expression * constant = build_field_name_REALFRACTIONconstant( *(yyvsp[(2) - (2)].tok) ); - (yyval.en) = (yyvsp[(1) - (2)].en) != nullptr ? new ExpressionNode( build_fieldSel( (yyvsp[(1) - (2)].en), constant ) ) : new ExpressionNode( constant ); - } - break; - - case 57: - -/* Line 1806 of yacc.c */ -#line 490 "parser.yy" - { (yyval.en) = (yyvsp[(1) - (1)].en); } - break; - - case 58: - -/* Line 1806 of yacc.c */ -#line 492 "parser.yy" - { (yyval.en) = new ExpressionNode( (yyvsp[(1) - (1)].constant) ); } - break; - - case 59: - -/* Line 1806 of yacc.c */ -#line 494 "parser.yy" - { (yyval.en) = (yyvsp[(2) - (2)].en)->set_extension( true ); } - break; - - case 60: - -/* Line 1806 of yacc.c */ -#line 499 "parser.yy" - { - switch ( (yyvsp[(1) - (2)].op) ) { - case OperKinds::AddressOf: - (yyval.en) = new ExpressionNode( build_addressOf( (yyvsp[(2) - (2)].en) ) ); - break; - case OperKinds::PointTo: - (yyval.en) = new ExpressionNode( build_unary_val( (yyvsp[(1) - (2)].op), (yyvsp[(2) - (2)].en) ) ); - break; - default: - assert( false ); - } - } - break; - - case 61: - -/* Line 1806 of yacc.c */ -#line 512 "parser.yy" - { (yyval.en) = new ExpressionNode( build_unary_val( (yyvsp[(1) - (2)].op), (yyvsp[(2) - (2)].en) ) ); } - break; - - case 62: - -/* Line 1806 of yacc.c */ -#line 514 "parser.yy" - { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::Incr, (yyvsp[(2) - (2)].en) ) ); } - break; - - case 63: - -/* Line 1806 of yacc.c */ -#line 516 "parser.yy" - { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::Decr, (yyvsp[(2) - (2)].en) ) ); } - break; - - case 64: - -/* Line 1806 of yacc.c */ -#line 518 "parser.yy" - { (yyval.en) = new ExpressionNode( build_sizeOfexpr( (yyvsp[(2) - (2)].en) ) ); } - break; - - case 65: - -/* Line 1806 of yacc.c */ -#line 520 "parser.yy" - { (yyval.en) = new ExpressionNode( build_sizeOftype( (yyvsp[(3) - (4)].decl) ) ); } - break; - - case 66: - -/* Line 1806 of yacc.c */ -#line 522 "parser.yy" - { (yyval.en) = new ExpressionNode( build_alignOfexpr( (yyvsp[(2) - (2)].en) ) ); } - break; - - case 67: - -/* Line 1806 of yacc.c */ -#line 524 "parser.yy" - { (yyval.en) = new ExpressionNode( build_alignOftype( (yyvsp[(3) - (4)].decl) ) ); } - break; - - case 68: - -/* Line 1806 of yacc.c */ -#line 526 "parser.yy" - { (yyval.en) = new ExpressionNode( build_offsetOf( (yyvsp[(3) - (6)].decl), build_varref( (yyvsp[(5) - (6)].tok) ) ) ); } - break; - - case 69: - -/* Line 1806 of yacc.c */ -#line 528 "parser.yy" - { (yyval.en) = new ExpressionNode( build_attrexpr( build_varref( (yyvsp[(1) - (1)].tok) ), nullptr ) ); } - break; - - case 70: - -/* Line 1806 of yacc.c */ -#line 530 "parser.yy" - { (yyval.en) = new ExpressionNode( build_attrexpr( build_varref( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].en) ) ); } - break; - - case 71: - -/* Line 1806 of yacc.c */ -#line 532 "parser.yy" - { (yyval.en) = new ExpressionNode( build_attrtype( build_varref( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].decl) ) ); } - break; - - case 72: - -/* Line 1806 of yacc.c */ -#line 538 "parser.yy" - { (yyval.op) = OperKinds::PointTo; } - break; - - case 73: - -/* Line 1806 of yacc.c */ -#line 539 "parser.yy" - { (yyval.op) = OperKinds::AddressOf; } - break; - - case 74: - -/* Line 1806 of yacc.c */ -#line 545 "parser.yy" - { (yyval.op) = OperKinds::UnPlus; } - break; - - case 75: - -/* Line 1806 of yacc.c */ -#line 546 "parser.yy" - { (yyval.op) = OperKinds::UnMinus; } - break; - - case 76: - -/* Line 1806 of yacc.c */ -#line 547 "parser.yy" - { (yyval.op) = OperKinds::Neg; } - break; - - case 77: - -/* Line 1806 of yacc.c */ -#line 548 "parser.yy" - { (yyval.op) = OperKinds::BitNeg; } - break; - - case 79: - -/* Line 1806 of yacc.c */ -#line 554 "parser.yy" - { (yyval.en) = new ExpressionNode( build_cast( (yyvsp[(2) - (4)].decl), (yyvsp[(4) - (4)].en) ) ); } - break; - - case 81: - -/* Line 1806 of yacc.c */ -#line 562 "parser.yy" - { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Mul, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } - break; - - case 82: - -/* Line 1806 of yacc.c */ -#line 564 "parser.yy" - { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Div, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } - break; - - case 83: - -/* Line 1806 of yacc.c */ -#line 566 "parser.yy" - { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Mod, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } - break; - - case 85: - -/* Line 1806 of yacc.c */ -#line 572 "parser.yy" - { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Plus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } - break; - - case 86: - -/* Line 1806 of yacc.c */ -#line 574 "parser.yy" - { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Minus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } - break; - - case 88: - -/* Line 1806 of yacc.c */ -#line 580 "parser.yy" - { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } - break; - - case 89: - -/* Line 1806 of yacc.c */ -#line 582 "parser.yy" - { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::RShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } - break; - - case 91: - -/* Line 1806 of yacc.c */ -#line 588 "parser.yy" - { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } - break; - - case 92: - -/* Line 1806 of yacc.c */ -#line 590 "parser.yy" - { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::GThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } - break; - - case 93: - -/* Line 1806 of yacc.c */ -#line 592 "parser.yy" - { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } - break; - - case 94: - -/* Line 1806 of yacc.c */ -#line 594 "parser.yy" - { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::GEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } - break; - - case 96: - -/* Line 1806 of yacc.c */ -#line 600 "parser.yy" - { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Eq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } - break; - - case 97: - -/* Line 1806 of yacc.c */ -#line 602 "parser.yy" - { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Neq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } - break; - - case 99: - -/* Line 1806 of yacc.c */ -#line 608 "parser.yy" - { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitAnd, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } - break; - - case 101: - -/* Line 1806 of yacc.c */ -#line 614 "parser.yy" - { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Xor, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } - break; - - case 103: - -/* Line 1806 of yacc.c */ -#line 620 "parser.yy" - { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitOr, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } - break; - - case 105: - -/* Line 1806 of yacc.c */ -#line 626 "parser.yy" - { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), true ) ); } - break; - - case 107: - -/* Line 1806 of yacc.c */ -#line 632 "parser.yy" - { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), false ) ); } - break; - - case 109: - -/* Line 1806 of yacc.c */ -#line 638 "parser.yy" - { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); } - break; - - case 110: - -/* Line 1806 of yacc.c */ -#line 641 "parser.yy" - { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (4)].en), (yyvsp[(1) - (4)].en), (yyvsp[(4) - (4)].en) ) ); } - break; - - case 113: - -/* Line 1806 of yacc.c */ -#line 654 "parser.yy" - { (yyval.en) = new ExpressionNode( build_binary_ptr( (yyvsp[(2) - (3)].op), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } - break; - - case 114: - -/* Line 1806 of yacc.c */ -#line 661 "parser.yy" - { (yyval.en) = nullptr; } - break; - - case 116: - -/* Line 1806 of yacc.c */ -#line 666 "parser.yy" - { (yyval.op) = OperKinds::Assign; } - break; - - case 117: - -/* Line 1806 of yacc.c */ -#line 667 "parser.yy" - { (yyval.op) = OperKinds::AtAssn; } - break; - - case 118: - -/* Line 1806 of yacc.c */ -#line 668 "parser.yy" - { (yyval.op) = OperKinds::MulAssn; } - break; - - case 119: - -/* Line 1806 of yacc.c */ -#line 669 "parser.yy" - { (yyval.op) = OperKinds::DivAssn; } - break; - - case 120: - -/* Line 1806 of yacc.c */ -#line 670 "parser.yy" - { (yyval.op) = OperKinds::ModAssn; } - break; - - case 121: - -/* Line 1806 of yacc.c */ -#line 671 "parser.yy" - { (yyval.op) = OperKinds::PlusAssn; } - break; - - case 122: - -/* Line 1806 of yacc.c */ -#line 672 "parser.yy" - { (yyval.op) = OperKinds::MinusAssn; } - break; - - case 123: - -/* Line 1806 of yacc.c */ -#line 673 "parser.yy" - { (yyval.op) = OperKinds::LSAssn; } - break; - - case 124: - -/* Line 1806 of yacc.c */ -#line 674 "parser.yy" - { (yyval.op) = OperKinds::RSAssn; } - break; - - case 125: - -/* Line 1806 of yacc.c */ -#line 675 "parser.yy" - { (yyval.op) = OperKinds::AndAssn; } - break; - - case 126: - -/* Line 1806 of yacc.c */ -#line 676 "parser.yy" - { (yyval.op) = OperKinds::ERAssn; } - break; - - case 127: - -/* Line 1806 of yacc.c */ -#line 677 "parser.yy" - { (yyval.op) = OperKinds::OrAssn; } - break; - - case 128: - -/* Line 1806 of yacc.c */ -#line 688 "parser.yy" - { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( (yyvsp[(4) - (6)].en) ) ) ); } - break; - - case 129: - -/* Line 1806 of yacc.c */ -#line 690 "parser.yy" - { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(yyvsp[(3) - (7)].en)->set_last( (yyvsp[(5) - (7)].en) ) ) ); } - break; - - case 131: - -/* Line 1806 of yacc.c */ -#line 696 "parser.yy" - { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); } - break; - - case 133: - -/* Line 1806 of yacc.c */ -#line 702 "parser.yy" - { (yyval.en) = new ExpressionNode( build_comma( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } - break; - - case 134: - -/* Line 1806 of yacc.c */ -#line 707 "parser.yy" - { (yyval.en) = nullptr; } - break; - - case 138: - -/* Line 1806 of yacc.c */ -#line 716 "parser.yy" - { (yyval.sn) = (yyvsp[(1) - (1)].sn); } - break; - - case 144: - -/* Line 1806 of yacc.c */ -#line 723 "parser.yy" - { - Token fn; - fn.str = new string( "^?{}" ); // location undefined - (yyval.sn) = new StatementNode( build_expr( new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( (yyvsp[(2) - (6)].en) )->set_last( (yyvsp[(4) - (6)].en) ) ) ) ) ); - } - break; - - case 145: - -/* Line 1806 of yacc.c */ -#line 733 "parser.yy" - { - (yyval.sn) = (yyvsp[(4) - (4)].sn)->add_label( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); - } - break; - - case 146: - -/* Line 1806 of yacc.c */ -#line 740 "parser.yy" - { (yyval.sn) = new StatementNode( build_compound( (StatementNode *)0 ) ); } - break; - - case 147: - -/* Line 1806 of yacc.c */ -#line 748 "parser.yy" - { (yyval.sn) = new StatementNode( build_compound( (yyvsp[(5) - (7)].sn) ) ); } - break; - - case 149: - -/* Line 1806 of yacc.c */ -#line 754 "parser.yy" - { if ( (yyvsp[(1) - (3)].sn) != 0 ) { (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(3) - (3)].sn) ); (yyval.sn) = (yyvsp[(1) - (3)].sn); } } - break; - - case 150: - -/* Line 1806 of yacc.c */ -#line 759 "parser.yy" - { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); } - break; - - case 151: - -/* Line 1806 of yacc.c */ -#line 761 "parser.yy" - { - distExt( (yyvsp[(2) - (2)].decl) ); - (yyval.sn) = new StatementNode( (yyvsp[(2) - (2)].decl) ); - } - break; - - case 152: - -/* Line 1806 of yacc.c */ -#line 766 "parser.yy" - { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); } - break; - - case 153: - -/* Line 1806 of yacc.c */ -#line 768 "parser.yy" - { - distExt( (yyvsp[(2) - (2)].decl) ); - (yyval.sn) = new StatementNode( (yyvsp[(2) - (2)].decl) ); - } - break; - - case 156: - -/* Line 1806 of yacc.c */ -#line 778 "parser.yy" - { if ( (yyvsp[(1) - (2)].sn) != 0 ) { (yyvsp[(1) - (2)].sn)->set_last( (yyvsp[(2) - (2)].sn) ); (yyval.sn) = (yyvsp[(1) - (2)].sn); } } - break; - - case 157: - -/* Line 1806 of yacc.c */ -#line 783 "parser.yy" - { (yyval.sn) = new StatementNode( build_expr( (yyvsp[(1) - (2)].en) ) ); } - break; - - case 158: - -/* Line 1806 of yacc.c */ -#line 789 "parser.yy" - { (yyval.sn) = new StatementNode( build_if( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn), nullptr ) ); } - break; - - case 159: - -/* Line 1806 of yacc.c */ -#line 791 "parser.yy" - { (yyval.sn) = new StatementNode( build_if( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].sn), (yyvsp[(7) - (7)].sn) ) ); } - break; - - case 160: - -/* Line 1806 of yacc.c */ -#line 793 "parser.yy" - { (yyval.sn) = new StatementNode( build_switch( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); } - break; - - case 161: - -/* Line 1806 of yacc.c */ -#line 795 "parser.yy" - { - StatementNode *sw = new StatementNode( build_switch( (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) ) ); - // The semantics of the declaration list is changed to include associated initialization, which is performed - // *before* the transfer to the appropriate case clause by hoisting the declarations into a compound - // statement around the switch. Statements after the initial declaration list can never be executed, and - // therefore, are removed from the grammar even though C allows it. The change also applies to choose - // statement. - (yyval.sn) = (yyvsp[(7) - (9)].decl) ? new StatementNode( build_compound( (StatementNode *)((new StatementNode( (yyvsp[(7) - (9)].decl) ))->set_last( sw )) ) ) : sw; - } - break; - - case 162: - -/* Line 1806 of yacc.c */ -#line 805 "parser.yy" - { (yyval.sn) = new StatementNode( build_switch( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); } - break; - - case 163: - -/* Line 1806 of yacc.c */ -#line 807 "parser.yy" - { - StatementNode *sw = new StatementNode( build_switch( (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) ) ); - (yyval.sn) = (yyvsp[(7) - (9)].decl) ? new StatementNode( build_compound( (StatementNode *)((new StatementNode( (yyvsp[(7) - (9)].decl) ))->set_last( sw )) ) ) : sw; - } - break; - - case 164: - -/* Line 1806 of yacc.c */ -#line 817 "parser.yy" - { (yyval.en) = (yyvsp[(1) - (1)].en); } - break; - - case 165: - -/* Line 1806 of yacc.c */ -#line 819 "parser.yy" - { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } - break; - - case 167: - -/* Line 1806 of yacc.c */ -#line 824 "parser.yy" - { (yyval.sn) = new StatementNode( build_case( (yyvsp[(1) - (1)].en) ) ); } - break; - - case 168: - -/* Line 1806 of yacc.c */ -#line 826 "parser.yy" - { (yyval.sn) = (StatementNode *)((yyvsp[(1) - (3)].sn)->set_last( new StatementNode( build_case( (yyvsp[(3) - (3)].en) ) ) ) ); } - break; - - case 169: - -/* Line 1806 of yacc.c */ -#line 830 "parser.yy" - { (yyval.sn) = (yyvsp[(2) - (3)].sn); } - break; - - case 170: - -/* Line 1806 of yacc.c */ -#line 831 "parser.yy" - { (yyval.sn) = new StatementNode( build_default() ); } - break; - - case 172: - -/* Line 1806 of yacc.c */ -#line 837 "parser.yy" - { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (2)].sn)->set_last( (yyvsp[(2) - (2)].sn) )); } - break; - - case 173: - -/* Line 1806 of yacc.c */ -#line 841 "parser.yy" - { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(2) - (2)].sn) ) ) ); } - break; - - case 174: - -/* Line 1806 of yacc.c */ -#line 846 "parser.yy" - { (yyval.sn) = nullptr; } - break; - - case 176: - -/* Line 1806 of yacc.c */ -#line 852 "parser.yy" - { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(2) - (2)].sn) ) ) ); } - break; - - case 177: - -/* Line 1806 of yacc.c */ -#line 854 "parser.yy" - { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(3) - (3)].sn) ) ) ) ) ); } - break; - - case 178: - -/* Line 1806 of yacc.c */ -#line 859 "parser.yy" - { (yyval.sn) = nullptr; } - break; - - case 180: - -/* Line 1806 of yacc.c */ -#line 865 "parser.yy" - { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); } - break; - - case 181: - -/* Line 1806 of yacc.c */ -#line 867 "parser.yy" - { (yyval.sn) = (yyvsp[(1) - (3)].sn)->append_last_case( new StatementNode( build_compound( (StatementNode *)(yyvsp[(2) - (3)].sn)->set_last( (yyvsp[(3) - (3)].sn) ) ) ) ); } - break; - - case 182: - -/* Line 1806 of yacc.c */ -#line 869 "parser.yy" - { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( (yyvsp[(3) - (3)].sn) ))); } - break; - - case 183: - -/* Line 1806 of yacc.c */ -#line 871 "parser.yy" - { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (4)].sn)->set_last( (yyvsp[(2) - (4)].sn)->append_last_case( new StatementNode( build_compound( (StatementNode *)(yyvsp[(3) - (4)].sn)->set_last( (yyvsp[(4) - (4)].sn) ) ) ) ) ) ); } - break; - - case 184: - -/* Line 1806 of yacc.c */ -#line 876 "parser.yy" - { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Break ) ); } - break; - - case 186: - -/* Line 1806 of yacc.c */ -#line 882 "parser.yy" - { (yyval.sn) = nullptr; } - break; - - case 187: - -/* Line 1806 of yacc.c */ -#line 884 "parser.yy" - { (yyval.sn) = nullptr; } - break; - - case 188: - -/* Line 1806 of yacc.c */ -#line 889 "parser.yy" - { (yyval.sn) = new StatementNode( build_while( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); } - break; - - case 189: - -/* Line 1806 of yacc.c */ -#line 891 "parser.yy" - { (yyval.sn) = new StatementNode( build_while( (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn), true ) ); } - break; - - case 190: - -/* Line 1806 of yacc.c */ -#line 893 "parser.yy" - { (yyval.sn) = new StatementNode( build_for( (yyvsp[(4) - (6)].fctl), (yyvsp[(6) - (6)].sn) ) ); } - break; - - case 191: - -/* Line 1806 of yacc.c */ -#line 898 "parser.yy" - { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].en) ); } - break; - - case 192: - -/* Line 1806 of yacc.c */ -#line 900 "parser.yy" - { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (4)].decl), (yyvsp[(2) - (4)].en), (yyvsp[(4) - (4)].en) ); } - break; - - case 193: - -/* Line 1806 of yacc.c */ -#line 905 "parser.yy" - { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Goto ) ); } - break; - - case 194: - -/* Line 1806 of yacc.c */ -#line 909 "parser.yy" - { (yyval.sn) = new StatementNode( build_computedgoto( (yyvsp[(3) - (4)].en) ) ); } - break; - - case 195: - -/* Line 1806 of yacc.c */ -#line 912 "parser.yy" - { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Continue ) ); } - break; - - case 196: - -/* Line 1806 of yacc.c */ -#line 916 "parser.yy" - { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Continue ) ); } - break; - - case 197: - -/* Line 1806 of yacc.c */ -#line 919 "parser.yy" - { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Break ) ); } - break; - - case 198: - -/* Line 1806 of yacc.c */ -#line 923 "parser.yy" - { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Break ) ); } - break; - - case 199: - -/* Line 1806 of yacc.c */ -#line 925 "parser.yy" - { (yyval.sn) = new StatementNode( build_return( (yyvsp[(2) - (3)].en) ) ); } - break; - - case 200: - -/* Line 1806 of yacc.c */ -#line 927 "parser.yy" - { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (3)].en) ) ); } - break; - - case 201: - -/* Line 1806 of yacc.c */ -#line 929 "parser.yy" - { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (3)].en) ) ); } - break; - - case 202: - -/* Line 1806 of yacc.c */ -#line 931 "parser.yy" - { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (5)].en) ) ); } - break; - - case 203: - -/* Line 1806 of yacc.c */ -#line 936 "parser.yy" - { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (3)].sn), (yyvsp[(3) - (3)].sn), 0 ) ); } - break; - - case 204: - -/* Line 1806 of yacc.c */ -#line 938 "parser.yy" - { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (3)].sn), 0, (yyvsp[(3) - (3)].sn) ) ); } - break; - - case 205: - -/* Line 1806 of yacc.c */ -#line 940 "parser.yy" - { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (4)].sn), (yyvsp[(3) - (4)].sn), (yyvsp[(4) - (4)].sn) ) ); } - break; - - case 207: - -/* Line 1806 of yacc.c */ -#line 947 "parser.yy" - { (yyval.sn) = new StatementNode( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); } - break; - - case 208: - -/* Line 1806 of yacc.c */ -#line 949 "parser.yy" - { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (6)].sn)->set_last( new StatementNode( build_catch( 0, (yyvsp[(6) - (6)].sn), true ) ) ); } - break; - - case 209: - -/* Line 1806 of yacc.c */ -#line 951 "parser.yy" - { (yyval.sn) = new StatementNode( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); } - break; - - case 210: - -/* Line 1806 of yacc.c */ -#line 953 "parser.yy" - { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (6)].sn)->set_last( new StatementNode( build_catch( 0, (yyvsp[(6) - (6)].sn), true ) ) ); } - break; - - case 211: - -/* Line 1806 of yacc.c */ -#line 958 "parser.yy" - { (yyval.sn) = new StatementNode( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); } - break; - - case 212: - -/* Line 1806 of yacc.c */ -#line 960 "parser.yy" - { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (10)].sn)->set_last( new StatementNode( build_catch( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ) ); } - break; - - case 213: - -/* Line 1806 of yacc.c */ -#line 962 "parser.yy" - { (yyval.sn) = new StatementNode( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); } - break; - - case 214: - -/* Line 1806 of yacc.c */ -#line 964 "parser.yy" - { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (10)].sn)->set_last( new StatementNode( build_catch( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ) ); } - break; - - case 215: - -/* Line 1806 of yacc.c */ -#line 969 "parser.yy" - { - (yyval.sn) = new StatementNode( build_finally( (yyvsp[(2) - (2)].sn) ) ); - } - break; - - case 217: - -/* Line 1806 of yacc.c */ -#line 978 "parser.yy" - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); - } - break; - - case 218: - -/* Line 1806 of yacc.c */ -#line 983 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); } - break; - - case 219: - -/* Line 1806 of yacc.c */ -#line 985 "parser.yy" - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - (yyval.decl) = (yyvsp[(1) - (2)].decl)->addName( (yyvsp[(2) - (2)].tok) ); - } - break; - - case 221: - -/* Line 1806 of yacc.c */ -#line 994 "parser.yy" - { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (6)].flag), (yyvsp[(4) - (6)].constant), 0 ) ); } - break; - - case 222: - -/* Line 1806 of yacc.c */ -#line 996 "parser.yy" - { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (8)].flag), (yyvsp[(4) - (8)].constant), (yyvsp[(6) - (8)].en) ) ); } - break; - - case 223: - -/* Line 1806 of yacc.c */ -#line 998 "parser.yy" - { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (10)].flag), (yyvsp[(4) - (10)].constant), (yyvsp[(6) - (10)].en), (yyvsp[(8) - (10)].en) ) ); } - break; - - case 224: - -/* Line 1806 of yacc.c */ -#line 1000 "parser.yy" - { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (12)].flag), (yyvsp[(4) - (12)].constant), (yyvsp[(6) - (12)].en), (yyvsp[(8) - (12)].en), (yyvsp[(10) - (12)].en) ) ); } - break; - - case 225: - -/* Line 1806 of yacc.c */ -#line 1002 "parser.yy" - { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (14)].flag), (yyvsp[(5) - (14)].constant), 0, (yyvsp[(8) - (14)].en), (yyvsp[(10) - (14)].en), (yyvsp[(12) - (14)].label) ) ); } - break; - - case 226: - -/* Line 1806 of yacc.c */ -#line 1007 "parser.yy" - { (yyval.flag) = false; } - break; - - case 227: - -/* Line 1806 of yacc.c */ -#line 1009 "parser.yy" - { (yyval.flag) = true; } - break; - - case 228: - -/* Line 1806 of yacc.c */ -#line 1014 "parser.yy" - { (yyval.en) = nullptr; } - break; - - case 231: - -/* Line 1806 of yacc.c */ -#line 1021 "parser.yy" - { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); } - break; - - case 232: - -/* Line 1806 of yacc.c */ -#line 1026 "parser.yy" - { (yyval.en) = new ExpressionNode( build_asmexpr( 0, (yyvsp[(1) - (4)].constant), (yyvsp[(3) - (4)].en) ) ); } - break; - - case 233: - -/* Line 1806 of yacc.c */ -#line 1028 "parser.yy" - { (yyval.en) = new ExpressionNode( build_asmexpr( (yyvsp[(2) - (7)].en), (yyvsp[(4) - (7)].constant), (yyvsp[(6) - (7)].en) ) ); } - break; - - case 234: - -/* Line 1806 of yacc.c */ -#line 1033 "parser.yy" - { (yyval.en) = nullptr; } - break; - - case 235: - -/* Line 1806 of yacc.c */ -#line 1035 "parser.yy" - { (yyval.en) = new ExpressionNode( (yyvsp[(1) - (1)].constant) ); } - break; - - case 236: - -/* Line 1806 of yacc.c */ -#line 1038 "parser.yy" - { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( new ExpressionNode( (yyvsp[(3) - (3)].constant) ) ); } - break; - - case 237: - -/* Line 1806 of yacc.c */ -#line 1043 "parser.yy" - { - (yyval.label) = new LabelNode(); (yyval.label)->labels.push_back( *(yyvsp[(1) - (1)].tok) ); - delete (yyvsp[(1) - (1)].tok); // allocated by lexer - } - break; - - case 238: - -/* Line 1806 of yacc.c */ -#line 1048 "parser.yy" - { - (yyval.label) = (yyvsp[(1) - (3)].label); (yyvsp[(1) - (3)].label)->labels.push_back( *(yyvsp[(3) - (3)].tok) ); - delete (yyvsp[(3) - (3)].tok); // allocated by lexer - } - break; - - case 239: - -/* Line 1806 of yacc.c */ -#line 1058 "parser.yy" - { (yyval.decl) = nullptr; } - break; - - case 242: - -/* Line 1806 of yacc.c */ -#line 1065 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); } - break; - - case 243: - -/* Line 1806 of yacc.c */ -#line 1070 "parser.yy" - { (yyval.decl) = nullptr; } - break; - - case 246: - -/* Line 1806 of yacc.c */ -#line 1077 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); } - break; - - case 251: - -/* Line 1806 of yacc.c */ -#line 1091 "parser.yy" - {} - break; - - case 252: - -/* Line 1806 of yacc.c */ -#line 1092 "parser.yy" - {} - break; - - case 260: - -/* Line 1806 of yacc.c */ -#line 1121 "parser.yy" - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - (yyval.decl) = (yyvsp[(1) - (2)].decl)->addInitializer( (yyvsp[(2) - (2)].in) ); - } - break; - - case 261: - -/* Line 1806 of yacc.c */ -#line 1128 "parser.yy" - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addInitializer( (yyvsp[(3) - (3)].in) );; - } - break; - - case 262: - -/* Line 1806 of yacc.c */ -#line 1133 "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) )->addInitializer( (yyvsp[(6) - (6)].in) ) ); - } - break; - - case 263: - -/* Line 1806 of yacc.c */ -#line 1143 "parser.yy" - { - typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) ); - (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) )->addAsmName( (yyvsp[(3) - (3)].decl) ); - } - break; - - case 264: - -/* Line 1806 of yacc.c */ -#line 1148 "parser.yy" - { - typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) ); - (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) )->addAsmName( (yyvsp[(3) - (3)].decl) ); - } - break; - - case 265: - -/* Line 1806 of yacc.c */ -#line 1153 "parser.yy" - { - typedefTable.setNextIdentifier( *(yyvsp[(3) - (4)].tok) ); - (yyval.decl) = (yyvsp[(2) - (4)].decl)->addQualifiers( (yyvsp[(1) - (4)].decl) )->addName( (yyvsp[(3) - (4)].tok) )->addAsmName( (yyvsp[(4) - (4)].decl) ); - } - break; - - case 266: - -/* Line 1806 of yacc.c */ -#line 1161 "parser.yy" - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - (yyval.decl) = (yyvsp[(1) - (1)].decl); - } - break; - - case 267: - -/* Line 1806 of yacc.c */ -#line 1166 "parser.yy" - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); - } - break; - - case 268: - -/* Line 1806 of yacc.c */ -#line 1171 "parser.yy" - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); - } - break; - - case 269: - -/* Line 1806 of yacc.c */ -#line 1176 "parser.yy" - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(2) - (3)].decl) ); - } - break; - - case 270: - -/* Line 1806 of yacc.c */ -#line 1181 "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 271: - -/* Line 1806 of yacc.c */ -#line 1212 "parser.yy" - { - (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true ); - } - break; - - case 272: - -/* Line 1806 of yacc.c */ -#line 1216 "parser.yy" - { - (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true ); - } - break; - - case 273: - -/* Line 1806 of yacc.c */ -#line 1223 "parser.yy" - { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); } - break; - - case 274: - -/* Line 1806 of yacc.c */ -#line 1227 "parser.yy" - { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (9)].decl)->appendList( (yyvsp[(7) - (9)].decl) ) ); } - break; - - case 275: - -/* Line 1806 of yacc.c */ -#line 1232 "parser.yy" - { - typedefTable.addToEnclosingScope( TypedefTable::TD ); - (yyval.decl) = (yyvsp[(2) - (2)].decl)->addTypedef(); - } - break; - - case 276: - -/* Line 1806 of yacc.c */ -#line 1237 "parser.yy" - { - typedefTable.addToEnclosingScope( TypedefTable::TD ); - (yyval.decl) = (yyvsp[(2) - (2)].decl)->addTypedef(); - } - break; - - case 277: - -/* Line 1806 of yacc.c */ -#line 1242 "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 278: - -/* Line 1806 of yacc.c */ -#line 1253 "parser.yy" - { - typedefTable.addToEnclosingScope( TypedefTable::TD ); - (yyval.decl) = (yyvsp[(3) - (3)].decl)->addType( (yyvsp[(2) - (3)].decl) )->addTypedef(); - } - break; - - case 279: - -/* Line 1806 of yacc.c */ -#line 1258 "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 280: - -/* Line 1806 of yacc.c */ -#line 1263 "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 281: - -/* Line 1806 of yacc.c */ -#line 1268 "parser.yy" - { - typedefTable.addToEnclosingScope( TypedefTable::TD ); - (yyval.decl) = (yyvsp[(3) - (3)].decl)->addType( (yyvsp[(1) - (3)].decl) )->addTypedef(); - } - break; - - case 282: - -/* Line 1806 of yacc.c */ -#line 1273 "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 283: - -/* Line 1806 of yacc.c */ -#line 1282 "parser.yy" - { - typedefTable.addToEnclosingScope( *(yyvsp[(2) - (4)].tok), TypedefTable::TD ); - (yyval.decl) = DeclarationNode::newName( 0 ); // unimplemented - } - break; - - case 284: - -/* Line 1806 of yacc.c */ -#line 1287 "parser.yy" - { - typedefTable.addToEnclosingScope( *(yyvsp[(5) - (7)].tok), TypedefTable::TD ); - (yyval.decl) = DeclarationNode::newName( 0 ); // unimplemented - } - break; - - case 285: - -/* Line 1806 of yacc.c */ -#line 1317 "parser.yy" - { - (yyval.decl) = distAttr( (yyvsp[(1) - (4)].decl), (yyvsp[(2) - (4)].decl) ); - } - break; - - case 289: - -/* Line 1806 of yacc.c */ -#line 1329 "parser.yy" - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - (yyval.decl) = (yyvsp[(1) - (3)].decl)->addAsmName( (yyvsp[(2) - (3)].decl) )->addInitializer( (yyvsp[(3) - (3)].in) ); - } - break; - - case 290: - -/* Line 1806 of yacc.c */ -#line 1334 "parser.yy" - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - (yyval.decl) = (yyvsp[(1) - (6)].decl)->appendList( (yyvsp[(4) - (6)].decl)->addQualifiers( (yyvsp[(3) - (6)].decl) )->addAsmName( (yyvsp[(5) - (6)].decl) )->addInitializer( (yyvsp[(6) - (6)].in) ) ); - } - break; - - case 307: - -/* Line 1806 of yacc.c */ -#line 1380 "parser.yy" - { (yyval.decl) = nullptr; } - break; - - case 310: - -/* Line 1806 of yacc.c */ -#line 1392 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 313: - -/* Line 1806 of yacc.c */ -#line 1402 "parser.yy" - { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); } - break; - - case 314: - -/* Line 1806 of yacc.c */ -#line 1404 "parser.yy" - { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); } - break; - - case 315: - -/* Line 1806 of yacc.c */ -#line 1406 "parser.yy" - { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); } - break; - - case 316: - -/* Line 1806 of yacc.c */ -#line 1408 "parser.yy" - { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); } - break; - - case 317: - -/* Line 1806 of yacc.c */ -#line 1410 "parser.yy" - { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); } - break; - - case 318: - -/* Line 1806 of yacc.c */ -#line 1412 "parser.yy" - { - typedefTable.enterScope(); - } - break; - - case 319: - -/* Line 1806 of yacc.c */ -#line 1416 "parser.yy" - { - typedefTable.leaveScope(); - (yyval.decl) = DeclarationNode::newForall( (yyvsp[(4) - (5)].decl) ); - } - break; - - case 321: - -/* Line 1806 of yacc.c */ -#line 1425 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 322: - -/* Line 1806 of yacc.c */ -#line 1427 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } - break; - - case 324: - -/* Line 1806 of yacc.c */ -#line 1438 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 325: - -/* Line 1806 of yacc.c */ -#line 1443 "parser.yy" - { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Extern ); } - break; - - case 326: - -/* Line 1806 of yacc.c */ -#line 1445 "parser.yy" - { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Static ); } - break; - - case 327: - -/* Line 1806 of yacc.c */ -#line 1447 "parser.yy" - { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Auto ); } - break; - - case 328: - -/* Line 1806 of yacc.c */ -#line 1449 "parser.yy" - { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Register ); } - break; - - case 329: - -/* Line 1806 of yacc.c */ -#line 1452 "parser.yy" - { (yyval.decl) = new DeclarationNode; (yyval.decl)->isInline = true; } - break; - - case 330: - -/* Line 1806 of yacc.c */ -#line 1454 "parser.yy" - { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); } - break; - - case 331: - -/* Line 1806 of yacc.c */ -#line 1457 "parser.yy" - { (yyval.decl) = new DeclarationNode; (yyval.decl)->isNoreturn = true; } - break; - - case 332: - -/* Line 1806 of yacc.c */ -#line 1459 "parser.yy" - { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); } - break; - - case 333: - -/* Line 1806 of yacc.c */ -#line 1464 "parser.yy" - { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); } - break; - - case 334: - -/* Line 1806 of yacc.c */ -#line 1466 "parser.yy" - { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); } - break; - - case 335: - -/* Line 1806 of yacc.c */ -#line 1468 "parser.yy" - { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); } - break; - - case 336: - -/* Line 1806 of yacc.c */ -#line 1470 "parser.yy" - { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); } - break; - - case 337: - -/* Line 1806 of yacc.c */ -#line 1472 "parser.yy" - { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Long ); } - break; - - case 338: - -/* Line 1806 of yacc.c */ -#line 1474 "parser.yy" - { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Short ); } - break; - - case 339: - -/* Line 1806 of yacc.c */ -#line 1476 "parser.yy" - { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Signed ); } - break; - - case 340: - -/* Line 1806 of yacc.c */ -#line 1478 "parser.yy" - { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Unsigned ); } - break; - - case 341: - -/* Line 1806 of yacc.c */ -#line 1480 "parser.yy" - { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); } - break; - - case 342: - -/* Line 1806 of yacc.c */ -#line 1482 "parser.yy" - { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); } - break; - - case 343: - -/* Line 1806 of yacc.c */ -#line 1484 "parser.yy" - { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Complex ); } - break; - - case 344: - -/* Line 1806 of yacc.c */ -#line 1486 "parser.yy" - { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); } - break; - - case 345: - -/* Line 1806 of yacc.c */ -#line 1488 "parser.yy" - { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); } - break; - - case 346: - -/* Line 1806 of yacc.c */ -#line 1490 "parser.yy" - { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::Zero ); } - break; - - case 347: - -/* Line 1806 of yacc.c */ -#line 1492 "parser.yy" - { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::One ); } - break; - - case 349: - -/* Line 1806 of yacc.c */ -#line 1499 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } - break; - - case 350: - -/* Line 1806 of yacc.c */ -#line 1501 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 351: - -/* Line 1806 of yacc.c */ -#line 1503 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } - break; - - case 352: - -/* Line 1806 of yacc.c */ -#line 1505 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addType( (yyvsp[(1) - (3)].decl) ); } - break; - - case 354: - -/* Line 1806 of yacc.c */ -#line 1511 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } - break; - - case 356: - -/* Line 1806 of yacc.c */ -#line 1518 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } - break; - - case 357: - -/* Line 1806 of yacc.c */ -#line 1520 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 358: - -/* Line 1806 of yacc.c */ -#line 1522 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addType( (yyvsp[(2) - (2)].decl) ); } - break; - - case 359: - -/* Line 1806 of yacc.c */ -#line 1527 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (4)].decl); } - break; - - case 360: - -/* Line 1806 of yacc.c */ -#line 1529 "parser.yy" - { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); } - break; - - case 361: - -/* Line 1806 of yacc.c */ -#line 1531 "parser.yy" - { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); } - break; - - case 362: - -/* Line 1806 of yacc.c */ -#line 1533 "parser.yy" - { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); } - break; - - case 364: - -/* Line 1806 of yacc.c */ -#line 1539 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } - break; - - case 365: - -/* Line 1806 of yacc.c */ -#line 1541 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 366: - -/* Line 1806 of yacc.c */ -#line 1543 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } - break; - - case 368: - -/* Line 1806 of yacc.c */ -#line 1549 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } - break; - - case 369: - -/* Line 1806 of yacc.c */ -#line 1551 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 371: - -/* Line 1806 of yacc.c */ -#line 1557 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } - break; - - case 372: - -/* Line 1806 of yacc.c */ -#line 1559 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 373: - -/* Line 1806 of yacc.c */ -#line 1561 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } - break; - - case 375: - -/* Line 1806 of yacc.c */ -#line 1567 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } - break; - - case 376: - -/* Line 1806 of yacc.c */ -#line 1569 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 378: - -/* Line 1806 of yacc.c */ -#line 1575 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } - break; - - case 379: - -/* Line 1806 of yacc.c */ -#line 1577 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 380: - -/* Line 1806 of yacc.c */ -#line 1579 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } - break; - - case 381: - -/* Line 1806 of yacc.c */ -#line 1584 "parser.yy" - { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); } - break; - - case 382: - -/* Line 1806 of yacc.c */ -#line 1586 "parser.yy" - { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(2) - (2)].tok) )->addQualifiers( (yyvsp[(1) - (2)].decl) ); } - break; - - case 383: - -/* Line 1806 of yacc.c */ -#line 1588 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 388: - -/* Line 1806 of yacc.c */ -#line 1603 "parser.yy" - { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (5)].aggKey), nullptr, nullptr, (yyvsp[(4) - (5)].decl), true )->addQualifiers( (yyvsp[(2) - (5)].decl) ); } - break; - - case 389: - -/* Line 1806 of yacc.c */ -#line 1605 "parser.yy" - { typedefTable.makeTypedef( *(yyvsp[(3) - (3)].tok) ); } - break; - - case 390: - -/* Line 1806 of yacc.c */ -#line 1607 "parser.yy" - { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), (yyvsp[(3) - (7)].tok), nullptr, (yyvsp[(6) - (7)].decl), true )->addQualifiers( (yyvsp[(2) - (7)].decl) ); } - break; - - case 391: - -/* Line 1806 of yacc.c */ -#line 1609 "parser.yy" - { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (8)].aggKey), nullptr, (yyvsp[(4) - (8)].en), (yyvsp[(7) - (8)].decl), false )->addQualifiers( (yyvsp[(2) - (8)].decl) ); } - break; - - case 393: - -/* Line 1806 of yacc.c */ -#line 1615 "parser.yy" - { - typedefTable.makeTypedef( *(yyvsp[(3) - (3)].tok) ); - (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (3)].aggKey), (yyvsp[(3) - (3)].tok), nullptr, nullptr, false )->addQualifiers( (yyvsp[(2) - (3)].decl) ); - } - break; - - case 394: - -/* Line 1806 of yacc.c */ -#line 1620 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) ); } - break; - - case 395: - -/* Line 1806 of yacc.c */ -#line 1625 "parser.yy" - { (yyval.aggKey) = DeclarationNode::Struct; } - break; - - case 396: - -/* Line 1806 of yacc.c */ -#line 1627 "parser.yy" - { (yyval.aggKey) = DeclarationNode::Union; } - break; - - case 397: - -/* Line 1806 of yacc.c */ -#line 1632 "parser.yy" - { (yyval.decl) = nullptr; } - break; - - case 398: - -/* Line 1806 of yacc.c */ -#line 1634 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl) ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); } - break; - - case 400: - -/* Line 1806 of yacc.c */ -#line 1640 "parser.yy" - { - distExt( (yyvsp[(2) - (3)].decl) ); // mark all fields in list - (yyval.decl) = (yyvsp[(2) - (3)].decl); - } - break; - - case 401: - -/* Line 1806 of yacc.c */ -#line 1645 "parser.yy" - { - (yyval.decl) = distAttr( (yyvsp[(1) - (3)].decl), (yyvsp[(2) - (3)].decl) ); } - break; - - case 402: - -/* Line 1806 of yacc.c */ -#line 1648 "parser.yy" - { - distExt( (yyvsp[(3) - (4)].decl) ); // mark all fields in list - (yyval.decl) = distAttr( (yyvsp[(2) - (4)].decl), (yyvsp[(3) - (4)].decl) ); - } - break; - - case 404: - -/* Line 1806 of yacc.c */ -#line 1657 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addName( (yyvsp[(2) - (2)].tok) ); } - break; - - case 405: - -/* Line 1806 of yacc.c */ -#line 1659 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(1) - (3)].decl)->cloneType( (yyvsp[(3) - (3)].tok) ) ); } - break; - - case 406: - -/* Line 1806 of yacc.c */ -#line 1661 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(1) - (2)].decl)->cloneType( 0 ) ); } - break; - - case 408: - -/* Line 1806 of yacc.c */ -#line 1667 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(4) - (4)].decl)->addQualifiers( (yyvsp[(3) - (4)].decl) ) ); } - break; - - case 409: - -/* Line 1806 of yacc.c */ -#line 1672 "parser.yy" - { (yyval.decl) = DeclarationNode::newName( 0 ); /* XXX */ } - break; - - case 410: - -/* Line 1806 of yacc.c */ -#line 1674 "parser.yy" - { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); } - break; - - case 411: - -/* Line 1806 of yacc.c */ -#line 1677 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); } - break; - - case 412: - -/* Line 1806 of yacc.c */ -#line 1680 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); } - break; - - case 414: - -/* Line 1806 of yacc.c */ -#line 1686 "parser.yy" - { (yyval.en) = nullptr; } - break; - - case 415: - -/* Line 1806 of yacc.c */ -#line 1688 "parser.yy" - { (yyval.en) = (yyvsp[(1) - (1)].en); } - break; - - case 416: - -/* Line 1806 of yacc.c */ -#line 1693 "parser.yy" - { (yyval.en) = (yyvsp[(2) - (2)].en); } - break; - - case 417: - -/* Line 1806 of yacc.c */ -#line 1698 "parser.yy" - { (yyval.decl) = DeclarationNode::newEnum( nullptr, (yyvsp[(4) - (6)].decl), true )->addQualifiers( (yyvsp[(2) - (6)].decl) ); } - break; - - case 418: - -/* Line 1806 of yacc.c */ -#line 1700 "parser.yy" - { typedefTable.makeTypedef( *(yyvsp[(3) - (3)].tok) ); } - break; - - case 419: - -/* Line 1806 of yacc.c */ -#line 1702 "parser.yy" - { (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(3) - (8)].tok), (yyvsp[(6) - (8)].decl), true )->addQualifiers( (yyvsp[(2) - (8)].decl) ); } - break; - - case 421: - -/* Line 1806 of yacc.c */ -#line 1708 "parser.yy" - { - typedefTable.makeTypedef( *(yyvsp[(3) - (3)].tok) ); - (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(3) - (3)].tok), 0, false )->addQualifiers( (yyvsp[(2) - (3)].decl) ); - } - break; - - case 422: - -/* Line 1806 of yacc.c */ -#line 1716 "parser.yy" - { (yyval.decl) = DeclarationNode::newEnumConstant( (yyvsp[(1) - (2)].tok), (yyvsp[(2) - (2)].en) ); } - break; - - case 423: - -/* Line 1806 of yacc.c */ -#line 1718 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( DeclarationNode::newEnumConstant( (yyvsp[(3) - (4)].tok), (yyvsp[(4) - (4)].en) ) ); } - break; - - case 424: - -/* Line 1806 of yacc.c */ -#line 1723 "parser.yy" - { (yyval.en) = nullptr; } - break; - - case 425: - -/* Line 1806 of yacc.c */ -#line 1725 "parser.yy" - { (yyval.en) = (yyvsp[(2) - (2)].en); } - break; - - case 426: - -/* Line 1806 of yacc.c */ -#line 1732 "parser.yy" - { (yyval.decl) = nullptr; } - break; - - case 430: - -/* Line 1806 of yacc.c */ -#line 1740 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } - break; - - case 431: - -/* Line 1806 of yacc.c */ -#line 1742 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); } - break; - - case 432: - -/* Line 1806 of yacc.c */ -#line 1744 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); } - break; - - case 434: - -/* Line 1806 of yacc.c */ -#line 1752 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } - break; - - case 435: - -/* Line 1806 of yacc.c */ -#line 1754 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } - break; - - case 436: - -/* Line 1806 of yacc.c */ -#line 1756 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (9)].decl)->appendList( (yyvsp[(5) - (9)].decl) )->appendList( (yyvsp[(9) - (9)].decl) ); } - break; - - case 438: - -/* Line 1806 of yacc.c */ -#line 1762 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } - break; - - case 439: - -/* Line 1806 of yacc.c */ -#line 1767 "parser.yy" - { (yyval.decl) = nullptr; } - break; - - case 442: - -/* Line 1806 of yacc.c */ -#line 1774 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); } - break; - - case 445: - -/* Line 1806 of yacc.c */ -#line 1781 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } - break; - - case 446: - -/* Line 1806 of yacc.c */ -#line 1783 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } - break; - - case 448: - -/* Line 1806 of yacc.c */ -#line 1792 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); } - break; - - case 449: - -/* Line 1806 of yacc.c */ -#line 1795 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); } - break; - - case 450: - -/* Line 1806 of yacc.c */ -#line 1797 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addName( (yyvsp[(3) - (4)].tok) )->addQualifiers( (yyvsp[(1) - (4)].decl) ); } - break; - - case 455: - -/* Line 1806 of yacc.c */ -#line 1807 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } - break; - - case 457: - -/* Line 1806 of yacc.c */ -#line 1814 "parser.yy" - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - (yyval.decl) = (yyvsp[(2) - (3)].decl)->addType( (yyvsp[(1) - (3)].decl) )->addInitializer( (yyvsp[(3) - (3)].en) ? new InitializerNode( (yyvsp[(3) - (3)].en) ) : nullptr ); - } - break; - - case 458: - -/* Line 1806 of yacc.c */ -#line 1819 "parser.yy" - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - (yyval.decl) = (yyvsp[(2) - (3)].decl)->addType( (yyvsp[(1) - (3)].decl) )->addInitializer( (yyvsp[(3) - (3)].en) ? new InitializerNode( (yyvsp[(3) - (3)].en) ) : nullptr ); - } - break; - - case 459: - -/* Line 1806 of yacc.c */ -#line 1827 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addInitializer( (yyvsp[(2) - (2)].en) ? new InitializerNode( (yyvsp[(2) - (2)].en) ) : nullptr ); } - break; - - case 460: - -/* Line 1806 of yacc.c */ -#line 1829 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addType( (yyvsp[(1) - (3)].decl) )->addInitializer( (yyvsp[(3) - (3)].en) ? new InitializerNode( (yyvsp[(3) - (3)].en) ) : nullptr ); } - break; - - case 461: - -/* Line 1806 of yacc.c */ -#line 1838 "parser.yy" - { (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); } - break; - - case 462: - -/* Line 1806 of yacc.c */ -#line 1840 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( DeclarationNode::newName( (yyvsp[(3) - (3)].tok) ) ); } - break; - - case 474: - -/* Line 1806 of yacc.c */ -#line 1865 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); } - break; - - case 477: - -/* Line 1806 of yacc.c */ -#line 1875 "parser.yy" - { (yyval.in) = nullptr; } - break; - - case 478: - -/* Line 1806 of yacc.c */ -#line 1877 "parser.yy" - { (yyval.in) = (yyvsp[(2) - (2)].in); } - break; - - case 479: - -/* Line 1806 of yacc.c */ -#line 1879 "parser.yy" - { (yyval.in) = (yyvsp[(2) - (2)].in)->set_maybeConstructed( false ); } - break; - - case 480: - -/* Line 1806 of yacc.c */ -#line 1883 "parser.yy" - { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); } - break; - - case 481: - -/* Line 1806 of yacc.c */ -#line 1884 "parser.yy" - { (yyval.in) = new InitializerNode( (yyvsp[(2) - (4)].in), true ); } - break; - - case 482: - -/* Line 1806 of yacc.c */ -#line 1889 "parser.yy" - { (yyval.in) = nullptr; } - break; - - case 484: - -/* Line 1806 of yacc.c */ -#line 1891 "parser.yy" - { (yyval.in) = (yyvsp[(2) - (2)].in)->set_designators( (yyvsp[(1) - (2)].en) ); } - break; - - case 485: - -/* Line 1806 of yacc.c */ -#line 1892 "parser.yy" - { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (3)].in)->set_last( (yyvsp[(3) - (3)].in) ) ); } - break; - - case 486: - -/* Line 1806 of yacc.c */ -#line 1894 "parser.yy" - { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (4)].in)->set_last( (yyvsp[(4) - (4)].in)->set_designators( (yyvsp[(3) - (4)].en) ) ) ); } - break; - - case 488: - -/* Line 1806 of yacc.c */ -#line 1910 "parser.yy" - { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (2)].tok) ) ); } - break; - - case 490: - -/* Line 1806 of yacc.c */ -#line 1916 "parser.yy" - { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (2)].en)->set_last( (yyvsp[(2) - (2)].en) ) ); } - break; - - case 491: - -/* Line 1806 of yacc.c */ -#line 1922 "parser.yy" - { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(2) - (2)].tok) ) ); } - break; - - case 492: - -/* Line 1806 of yacc.c */ -#line 1925 "parser.yy" - { (yyval.en) = (yyvsp[(3) - (5)].en); } - break; - - case 493: - -/* Line 1806 of yacc.c */ -#line 1927 "parser.yy" - { (yyval.en) = (yyvsp[(3) - (5)].en); } - break; - - case 494: - -/* Line 1806 of yacc.c */ -#line 1929 "parser.yy" - { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].en) ) ); } - break; - - case 495: - -/* Line 1806 of yacc.c */ -#line 1931 "parser.yy" - { (yyval.en) = (yyvsp[(4) - (6)].en); } - break; - - case 497: - -/* Line 1806 of yacc.c */ -#line 1955 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } - break; - - case 498: - -/* Line 1806 of yacc.c */ -#line 1957 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 499: - -/* Line 1806 of yacc.c */ -#line 1959 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } - break; - - case 501: - -/* Line 1806 of yacc.c */ -#line 1965 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } - break; - - case 502: - -/* Line 1806 of yacc.c */ -#line 1967 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 503: - -/* Line 1806 of yacc.c */ -#line 1972 "parser.yy" - { (yyval.decl) = DeclarationNode::newFromTypeGen( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); } - break; - - case 505: - -/* Line 1806 of yacc.c */ -#line 1978 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(3) - (4)].decl) ); } - break; - - case 506: - -/* Line 1806 of yacc.c */ -#line 1983 "parser.yy" - { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (2)].tok), TypedefTable::TD ); } - break; - - case 507: - -/* Line 1806 of yacc.c */ -#line 1985 "parser.yy" - { (yyval.decl) = DeclarationNode::newTypeParam( (yyvsp[(1) - (4)].tclass), (yyvsp[(2) - (4)].tok) )->addAssertions( (yyvsp[(4) - (4)].decl) ); } - break; - - case 509: - -/* Line 1806 of yacc.c */ -#line 1991 "parser.yy" - { (yyval.tclass) = DeclarationNode::Otype; } - break; - - case 510: - -/* Line 1806 of yacc.c */ -#line 1993 "parser.yy" - { (yyval.tclass) = DeclarationNode::Dtype; } - break; - - case 511: - -/* Line 1806 of yacc.c */ -#line 1995 "parser.yy" - { (yyval.tclass) = DeclarationNode::Ftype; } - break; - - case 512: - -/* Line 1806 of yacc.c */ -#line 1997 "parser.yy" - { (yyval.tclass) = DeclarationNode::Ttype; } - break; - - case 513: - -/* Line 1806 of yacc.c */ -#line 2002 "parser.yy" - { (yyval.decl) = nullptr; } - break; - - case 514: - -/* Line 1806 of yacc.c */ -#line 2004 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl) ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); } - break; - - case 515: - -/* Line 1806 of yacc.c */ -#line 2009 "parser.yy" - { - typedefTable.openTrait( *(yyvsp[(2) - (5)].tok) ); - (yyval.decl) = DeclarationNode::newTraitUse( (yyvsp[(2) - (5)].tok), (yyvsp[(4) - (5)].en) ); - } - break; - - case 516: - -/* Line 1806 of yacc.c */ -#line 2014 "parser.yy" - { (yyval.decl) = (yyvsp[(4) - (5)].decl); } - break; - - case 517: - -/* Line 1806 of yacc.c */ -#line 2016 "parser.yy" - { (yyval.decl) = nullptr; } - break; - - case 518: - -/* Line 1806 of yacc.c */ -#line 2021 "parser.yy" - { (yyval.en) = new ExpressionNode( build_typevalue( (yyvsp[(1) - (1)].decl) ) ); } - break; - - case 520: - -/* Line 1806 of yacc.c */ -#line 2024 "parser.yy" - { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( new ExpressionNode( build_typevalue( (yyvsp[(3) - (3)].decl) ) ) ) ); } - break; - - case 521: - -/* Line 1806 of yacc.c */ -#line 2026 "parser.yy" - { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) )); } - break; - - case 522: - -/* Line 1806 of yacc.c */ -#line 2031 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl); } - break; - - case 523: - -/* Line 1806 of yacc.c */ -#line 2033 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) ); } - break; - - case 524: - -/* Line 1806 of yacc.c */ -#line 2035 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl)->copyStorageClasses( (yyvsp[(1) - (3)].decl) ) ); } - break; - - case 525: - -/* Line 1806 of yacc.c */ -#line 2040 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addAssertions( (yyvsp[(2) - (2)].decl) ); } - break; - - case 526: - -/* Line 1806 of yacc.c */ -#line 2042 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addAssertions( (yyvsp[(2) - (4)].decl) )->addType( (yyvsp[(4) - (4)].decl) ); } - break; - - case 527: - -/* Line 1806 of yacc.c */ -#line 2047 "parser.yy" - { - typedefTable.addToEnclosingScope( *(yyvsp[(1) - (1)].tok), TypedefTable::TD ); - (yyval.decl) = DeclarationNode::newTypeDecl( (yyvsp[(1) - (1)].tok), 0 ); - } - break; - - case 528: - -/* Line 1806 of yacc.c */ -#line 2052 "parser.yy" - { - typedefTable.addToEnclosingScope( *(yyvsp[(1) - (6)].tok), TypedefTable::TG ); - (yyval.decl) = DeclarationNode::newTypeDecl( (yyvsp[(1) - (6)].tok), (yyvsp[(4) - (6)].decl) ); - } - break; - - case 529: - -/* Line 1806 of yacc.c */ -#line 2060 "parser.yy" - { - typedefTable.addToEnclosingScope( *(yyvsp[(2) - (9)].tok), TypedefTable::ID ); - (yyval.decl) = DeclarationNode::newTrait( (yyvsp[(2) - (9)].tok), (yyvsp[(5) - (9)].decl), 0 ); - } - break; - - case 530: - -/* Line 1806 of yacc.c */ -#line 2065 "parser.yy" - { - typedefTable.enterTrait( *(yyvsp[(2) - (8)].tok) ); - typedefTable.enterScope(); - } - break; - - case 531: - -/* Line 1806 of yacc.c */ -#line 2070 "parser.yy" - { - typedefTable.leaveTrait(); - typedefTable.addToEnclosingScope( *(yyvsp[(2) - (11)].tok), TypedefTable::ID ); - (yyval.decl) = DeclarationNode::newTrait( (yyvsp[(2) - (11)].tok), (yyvsp[(5) - (11)].decl), (yyvsp[(10) - (11)].decl) ); - } - break; - - case 533: - -/* Line 1806 of yacc.c */ -#line 2080 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); } - break; - - case 536: - -/* Line 1806 of yacc.c */ -#line 2090 "parser.yy" - { - typedefTable.addToEnclosingScope2( TypedefTable::ID ); - (yyval.decl) = (yyvsp[(1) - (1)].decl); - } - break; - - case 537: - -/* Line 1806 of yacc.c */ -#line 2095 "parser.yy" - { - typedefTable.addToEnclosingScope2( TypedefTable::ID ); - (yyval.decl) = (yyvsp[(1) - (1)].decl); - } - break; - - case 538: - -/* Line 1806 of yacc.c */ -#line 2100 "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 539: - -/* Line 1806 of yacc.c */ -#line 2108 "parser.yy" - { - typedefTable.addToEnclosingScope2( TypedefTable::ID ); - (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); - } - break; - - case 540: - -/* Line 1806 of yacc.c */ -#line 2113 "parser.yy" - { - typedefTable.addToEnclosingScope2( TypedefTable::ID ); - (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(1) - (5)].decl)->cloneBaseType( (yyvsp[(5) - (5)].decl) ) ); - } - break; - - case 541: - -/* Line 1806 of yacc.c */ -#line 2123 "parser.yy" - {} - break; - - case 542: - -/* Line 1806 of yacc.c */ -#line 2125 "parser.yy" - { parseTree = parseTree ? parseTree->appendList( (yyvsp[(1) - (1)].decl) ) : (yyvsp[(1) - (1)].decl); } - break; - - case 544: - -/* Line 1806 of yacc.c */ -#line 2131 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (3)].decl) ? (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ) : (yyvsp[(3) - (3)].decl); } - break; - - case 545: - -/* Line 1806 of yacc.c */ -#line 2136 "parser.yy" - { (yyval.decl) = nullptr; } - break; - - case 549: - -/* Line 1806 of yacc.c */ -#line 2144 "parser.yy" - { - (yyval.decl) = DeclarationNode::newAsmStmt( new StatementNode( build_asmstmt( false, (yyvsp[(3) - (5)].constant), 0 ) ) ); - } - break; - - case 550: - -/* Line 1806 of yacc.c */ -#line 2148 "parser.yy" - { - linkageStack.push( linkage ); // handle nested extern "C"/"Cforall" - linkage = LinkageSpec::linkageCheck( (yyvsp[(2) - (2)].tok) ); - } - break; - - case 551: - -/* Line 1806 of yacc.c */ -#line 2153 "parser.yy" - { - linkage = linkageStack.top(); - linkageStack.pop(); - (yyval.decl) = (yyvsp[(5) - (6)].decl); - } - break; - - case 552: - -/* Line 1806 of yacc.c */ -#line 2159 "parser.yy" - { - distExt( (yyvsp[(2) - (2)].decl) ); // mark all fields in list - (yyval.decl) = (yyvsp[(2) - (2)].decl); - } - break; - - case 554: - -/* Line 1806 of yacc.c */ -#line 2173 "parser.yy" - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - typedefTable.leaveScope(); - (yyval.decl) = (yyvsp[(1) - (2)].decl)->addFunctionBody( (yyvsp[(2) - (2)].sn) ); - } - break; - - case 555: - -/* Line 1806 of yacc.c */ -#line 2179 "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 556: - -/* Line 1806 of yacc.c */ -#line 2188 "parser.yy" - { - typedefTable.addToEnclosingScope( TypedefTable::ID ); - typedefTable.leaveScope(); - (yyval.decl) = (yyvsp[(1) - (2)].decl)->addFunctionBody( (yyvsp[(2) - (2)].sn) ); - } - break; - - case 557: - -/* Line 1806 of yacc.c */ -#line 2194 "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 558: - -/* Line 1806 of yacc.c */ -#line 2200 "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 559: - -/* Line 1806 of yacc.c */ -#line 2206 "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 560: - -/* Line 1806 of yacc.c */ -#line 2212 "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 561: - -/* Line 1806 of yacc.c */ -#line 2220 "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 562: - -/* Line 1806 of yacc.c */ -#line 2226 "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 563: - -/* Line 1806 of yacc.c */ -#line 2234 "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 564: - -/* Line 1806 of yacc.c */ -#line 2240 "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 568: - -/* Line 1806 of yacc.c */ -#line 2255 "parser.yy" - { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } - break; - - case 569: - -/* Line 1806 of yacc.c */ -#line 2260 "parser.yy" - { (yyval.decl) = nullptr; } - break; - - case 570: - -/* Line 1806 of yacc.c */ -#line 2262 "parser.yy" - { - DeclarationNode * name = new DeclarationNode(); - name->asmName = (yyvsp[(3) - (5)].constant); - (yyval.decl) = name->addQualifiers( (yyvsp[(5) - (5)].decl) ); - } - break; - - case 571: - -/* Line 1806 of yacc.c */ -#line 2271 "parser.yy" - { (yyval.decl) = nullptr; } - break; - - case 574: - -/* Line 1806 of yacc.c */ -#line 2278 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } - break; - - case 575: - -/* Line 1806 of yacc.c */ -#line 2283 "parser.yy" - { (yyval.decl) = (yyvsp[(4) - (6)].decl); } - break; - - case 577: - -/* Line 1806 of yacc.c */ -#line 2289 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) ); } - break; - - case 578: - -/* Line 1806 of yacc.c */ -#line 2294 "parser.yy" - { (yyval.decl) = nullptr; } - break; - - case 579: - -/* Line 1806 of yacc.c */ -#line 2296 "parser.yy" - { (yyval.decl) = DeclarationNode::newAttribute( (yyvsp[(1) - (1)].tok) ); } - break; - - case 580: - -/* Line 1806 of yacc.c */ -#line 2298 "parser.yy" - { (yyval.decl) = DeclarationNode::newAttribute( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); } - break; - - case 584: - -/* Line 1806 of yacc.c */ -#line 2306 "parser.yy" - { (yyval.tok) = Token{ new string( "__const__" ) }; } - break; - - case 585: - -/* Line 1806 of yacc.c */ -#line 2341 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 587: - -/* Line 1806 of yacc.c */ -#line 2344 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 588: - -/* Line 1806 of yacc.c */ -#line 2346 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 589: - -/* Line 1806 of yacc.c */ -#line 2351 "parser.yy" - { - typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) ); - (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); - } - break; - - case 590: - -/* Line 1806 of yacc.c */ -#line 2356 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 591: - -/* Line 1806 of yacc.c */ -#line 2361 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } - break; - - case 592: - -/* Line 1806 of yacc.c */ -#line 2363 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } - break; - - case 593: - -/* Line 1806 of yacc.c */ -#line 2365 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addQualifiers( (yyvsp[(4) - (4)].decl) ); } - break; - - case 594: - -/* Line 1806 of yacc.c */ -#line 2370 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); } - break; - - case 595: - -/* Line 1806 of yacc.c */ -#line 2372 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } - break; - - case 596: - -/* Line 1806 of yacc.c */ -#line 2374 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } - break; - - case 597: - -/* Line 1806 of yacc.c */ -#line 2376 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 598: - -/* Line 1806 of yacc.c */ -#line 2381 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } - break; - - case 599: - -/* Line 1806 of yacc.c */ -#line 2383 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 600: - -/* Line 1806 of yacc.c */ -#line 2392 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 602: - -/* Line 1806 of yacc.c */ -#line 2395 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 603: - -/* Line 1806 of yacc.c */ -#line 2400 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); } - break; - - case 604: - -/* Line 1806 of yacc.c */ -#line 2402 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } - break; - - case 605: - -/* Line 1806 of yacc.c */ -#line 2404 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 606: - -/* Line 1806 of yacc.c */ -#line 2409 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } - break; - - case 607: - -/* Line 1806 of yacc.c */ -#line 2411 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } - break; - - case 608: - -/* Line 1806 of yacc.c */ -#line 2413 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 609: - -/* Line 1806 of yacc.c */ -#line 2418 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } - break; - - case 610: - -/* Line 1806 of yacc.c */ -#line 2420 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } - break; - - case 611: - -/* Line 1806 of yacc.c */ -#line 2422 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 615: - -/* Line 1806 of yacc.c */ -#line 2440 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addIdList( (yyvsp[(3) - (4)].decl) ); } - break; - - case 616: - -/* Line 1806 of yacc.c */ -#line 2442 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } - break; - - case 617: - -/* Line 1806 of yacc.c */ -#line 2444 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 618: - -/* Line 1806 of yacc.c */ -#line 2449 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } - break; - - case 619: - -/* Line 1806 of yacc.c */ -#line 2451 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } - break; - - case 620: - -/* Line 1806 of yacc.c */ -#line 2453 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 621: - -/* Line 1806 of yacc.c */ -#line 2458 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } - break; - - case 622: - -/* Line 1806 of yacc.c */ -#line 2460 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } - break; - - case 623: - -/* Line 1806 of yacc.c */ -#line 2462 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 624: - -/* Line 1806 of yacc.c */ -#line 2477 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 626: - -/* Line 1806 of yacc.c */ -#line 2480 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 627: - -/* Line 1806 of yacc.c */ -#line 2482 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 629: - -/* Line 1806 of yacc.c */ -#line 2488 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 630: - -/* Line 1806 of yacc.c */ -#line 2493 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } - break; - - case 631: - -/* Line 1806 of yacc.c */ -#line 2495 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } - break; - - case 632: - -/* Line 1806 of yacc.c */ -#line 2497 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addQualifiers( (yyvsp[(4) - (4)].decl) ); } - break; - - case 633: - -/* Line 1806 of yacc.c */ -#line 2502 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); } - break; - - case 634: - -/* Line 1806 of yacc.c */ -#line 2504 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } - break; - - case 635: - -/* Line 1806 of yacc.c */ -#line 2506 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } - break; - - case 636: - -/* Line 1806 of yacc.c */ -#line 2508 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 637: - -/* Line 1806 of yacc.c */ -#line 2513 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); } - break; - - case 638: - -/* Line 1806 of yacc.c */ -#line 2515 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } - break; - - case 639: - -/* Line 1806 of yacc.c */ -#line 2517 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 640: - -/* Line 1806 of yacc.c */ -#line 2527 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 642: - -/* Line 1806 of yacc.c */ -#line 2530 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 643: - -/* Line 1806 of yacc.c */ -#line 2532 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 644: - -/* Line 1806 of yacc.c */ -#line 2537 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } - break; - - case 645: - -/* Line 1806 of yacc.c */ -#line 2539 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } - break; - - case 646: - -/* Line 1806 of yacc.c */ -#line 2541 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addQualifiers( (yyvsp[(4) - (4)].decl) ); } - break; - - case 647: - -/* Line 1806 of yacc.c */ -#line 2546 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); } - break; - - case 648: - -/* Line 1806 of yacc.c */ -#line 2548 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } - break; - - case 649: - -/* Line 1806 of yacc.c */ -#line 2550 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } - break; - - case 650: - -/* Line 1806 of yacc.c */ -#line 2552 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 651: - -/* Line 1806 of yacc.c */ -#line 2557 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); } - break; - - case 652: - -/* Line 1806 of yacc.c */ -#line 2559 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } - break; - - case 653: - -/* Line 1806 of yacc.c */ -#line 2561 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 654: - -/* Line 1806 of yacc.c */ -#line 2574 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 656: - -/* Line 1806 of yacc.c */ -#line 2577 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 657: - -/* Line 1806 of yacc.c */ -#line 2579 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 658: - -/* Line 1806 of yacc.c */ -#line 2584 "parser.yy" - { - typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) ); - (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); - } - break; - - case 659: - -/* Line 1806 of yacc.c */ -#line 2589 "parser.yy" - { - typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) ); - (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); - } - break; - - case 660: - -/* Line 1806 of yacc.c */ -#line 2597 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } - break; - - case 661: - -/* Line 1806 of yacc.c */ -#line 2599 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } - break; - - case 662: - -/* Line 1806 of yacc.c */ -#line 2601 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addQualifiers( (yyvsp[(4) - (4)].decl) ); } - break; - - case 663: - -/* Line 1806 of yacc.c */ -#line 2606 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); } - break; - - case 664: - -/* Line 1806 of yacc.c */ -#line 2608 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } - break; - - case 665: - -/* Line 1806 of yacc.c */ -#line 2613 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); } - break; - - case 666: - -/* Line 1806 of yacc.c */ -#line 2615 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } - break; - - case 668: - -/* Line 1806 of yacc.c */ -#line 2633 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 669: - -/* Line 1806 of yacc.c */ -#line 2635 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 670: - -/* Line 1806 of yacc.c */ -#line 2640 "parser.yy" - { (yyval.decl) = DeclarationNode::newPointer( 0 ); } - break; - - case 671: - -/* Line 1806 of yacc.c */ -#line 2642 "parser.yy" - { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); } - break; - - case 672: - -/* Line 1806 of yacc.c */ -#line 2644 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } - break; - - case 673: - -/* Line 1806 of yacc.c */ -#line 2646 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } - break; - - case 674: - -/* Line 1806 of yacc.c */ -#line 2648 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addQualifiers( (yyvsp[(4) - (4)].decl) ); } - break; - - case 676: - -/* Line 1806 of yacc.c */ -#line 2654 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } - break; - - case 677: - -/* Line 1806 of yacc.c */ -#line 2656 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } - break; - - case 678: - -/* Line 1806 of yacc.c */ -#line 2658 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 679: - -/* Line 1806 of yacc.c */ -#line 2663 "parser.yy" - { (yyval.decl) = DeclarationNode::newFunction( nullptr, nullptr, (yyvsp[(3) - (5)].decl), nullptr ); } - break; - - case 680: - -/* Line 1806 of yacc.c */ -#line 2665 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } - break; - - case 681: - -/* Line 1806 of yacc.c */ -#line 2667 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 682: - -/* Line 1806 of yacc.c */ -#line 2673 "parser.yy" - { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); } - break; - - case 683: - -/* Line 1806 of yacc.c */ -#line 2675 "parser.yy" - { (yyval.decl) = DeclarationNode::newArray( 0, 0, false )->addArray( (yyvsp[(3) - (3)].decl) ); } - break; - - case 685: - -/* Line 1806 of yacc.c */ -#line 2681 "parser.yy" - { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(3) - (5)].en), 0, false ); } - break; - - case 686: - -/* Line 1806 of yacc.c */ -#line 2683 "parser.yy" - { (yyval.decl) = DeclarationNode::newVarArray( 0 ); } - break; - - case 687: - -/* Line 1806 of yacc.c */ -#line 2685 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newArray( (yyvsp[(4) - (6)].en), 0, false ) ); } - break; - - case 688: - -/* Line 1806 of yacc.c */ -#line 2687 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newVarArray( 0 ) ); } - break; - - case 690: - -/* Line 1806 of yacc.c */ -#line 2722 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 691: - -/* Line 1806 of yacc.c */ -#line 2724 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 692: - -/* Line 1806 of yacc.c */ -#line 2729 "parser.yy" - { (yyval.decl) = DeclarationNode::newPointer( nullptr ); } - break; - - case 693: - -/* Line 1806 of yacc.c */ -#line 2731 "parser.yy" - { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); } - break; - - case 694: - -/* Line 1806 of yacc.c */ -#line 2733 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( nullptr ) ); } - break; - - case 695: - -/* Line 1806 of yacc.c */ -#line 2735 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } - break; - - case 696: - -/* Line 1806 of yacc.c */ -#line 2737 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addQualifiers( (yyvsp[(4) - (4)].decl) ); } - break; - - case 698: - -/* Line 1806 of yacc.c */ -#line 2743 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } - break; - - case 699: - -/* Line 1806 of yacc.c */ -#line 2745 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } - break; - - case 700: - -/* Line 1806 of yacc.c */ -#line 2747 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 701: - -/* Line 1806 of yacc.c */ -#line 2752 "parser.yy" - { (yyval.decl) = DeclarationNode::newFunction( nullptr, nullptr, (yyvsp[(3) - (5)].decl), nullptr ); } - break; - - case 702: - -/* Line 1806 of yacc.c */ -#line 2754 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } - break; - - case 703: - -/* Line 1806 of yacc.c */ -#line 2756 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 705: - -/* Line 1806 of yacc.c */ -#line 2763 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); } - break; - - case 707: - -/* Line 1806 of yacc.c */ -#line 2774 "parser.yy" - { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); } - break; - - case 708: - -/* Line 1806 of yacc.c */ -#line 2777 "parser.yy" - { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); } - break; - - case 709: - -/* Line 1806 of yacc.c */ -#line 2779 "parser.yy" - { (yyval.decl) = DeclarationNode::newArray( 0, (yyvsp[(3) - (5)].decl), false ); } - break; - - case 710: - -/* Line 1806 of yacc.c */ -#line 2782 "parser.yy" - { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); } - break; - - case 711: - -/* Line 1806 of yacc.c */ -#line 2784 "parser.yy" - { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl), true ); } - break; - - case 712: - -/* Line 1806 of yacc.c */ -#line 2786 "parser.yy" - { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(3) - (7)].decl), true ); } - break; - - case 714: - -/* Line 1806 of yacc.c */ -#line 2801 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 715: - -/* Line 1806 of yacc.c */ -#line 2803 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 716: - -/* Line 1806 of yacc.c */ -#line 2808 "parser.yy" - { (yyval.decl) = DeclarationNode::newPointer( 0 ); } - break; - - case 717: - -/* Line 1806 of yacc.c */ -#line 2810 "parser.yy" - { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); } - break; - - case 718: - -/* Line 1806 of yacc.c */ -#line 2812 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } - break; - - case 719: - -/* Line 1806 of yacc.c */ -#line 2814 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } - break; - - case 720: - -/* Line 1806 of yacc.c */ -#line 2816 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addQualifiers( (yyvsp[(4) - (4)].decl) ); } - break; - - case 722: - -/* Line 1806 of yacc.c */ -#line 2822 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } - break; - - case 723: - -/* Line 1806 of yacc.c */ -#line 2824 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } - break; - - case 724: - -/* Line 1806 of yacc.c */ -#line 2826 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 725: - -/* Line 1806 of yacc.c */ -#line 2831 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } - break; - - case 726: - -/* Line 1806 of yacc.c */ -#line 2833 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 729: - -/* Line 1806 of yacc.c */ -#line 2843 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } - break; - - case 732: - -/* Line 1806 of yacc.c */ -#line 2854 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } - break; - - case 733: - -/* Line 1806 of yacc.c */ -#line 2856 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } - break; - - case 734: - -/* Line 1806 of yacc.c */ -#line 2858 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } - break; - - case 735: - -/* Line 1806 of yacc.c */ -#line 2860 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } - break; - - case 736: - -/* Line 1806 of yacc.c */ -#line 2862 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } - break; - - case 737: - -/* Line 1806 of yacc.c */ -#line 2864 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } - break; - - case 738: - -/* Line 1806 of yacc.c */ -#line 2871 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } - break; - - case 739: - -/* Line 1806 of yacc.c */ -#line 2873 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } - break; - - case 740: - -/* Line 1806 of yacc.c */ -#line 2875 "parser.yy" - { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } - break; - - case 741: - -/* Line 1806 of yacc.c */ -#line 2877 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); } - break; - - case 742: - -/* Line 1806 of yacc.c */ -#line 2879 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } - break; - - case 743: - -/* Line 1806 of yacc.c */ -#line 2882 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } - break; - - case 744: - -/* Line 1806 of yacc.c */ -#line 2884 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } - break; - - case 745: - -/* Line 1806 of yacc.c */ -#line 2886 "parser.yy" - { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } - break; - - case 746: - -/* Line 1806 of yacc.c */ -#line 2888 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); } - break; - - case 747: - -/* Line 1806 of yacc.c */ -#line 2890 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } - break; - - case 748: - -/* Line 1806 of yacc.c */ -#line 2895 "parser.yy" - { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); } - break; - - case 749: - -/* Line 1806 of yacc.c */ -#line 2897 "parser.yy" - { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); } - break; - - case 750: - -/* Line 1806 of yacc.c */ -#line 2902 "parser.yy" - { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), true ); } - break; - - case 751: - -/* Line 1806 of yacc.c */ -#line 2904 "parser.yy" - { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl)->addQualifiers( (yyvsp[(3) - (7)].decl) ), true ); } - break; - - case 753: - -/* Line 1806 of yacc.c */ -#line 2931 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } - break; - - case 757: - -/* Line 1806 of yacc.c */ -#line 2942 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } - break; - - case 758: - -/* Line 1806 of yacc.c */ -#line 2944 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } - break; - - case 759: - -/* Line 1806 of yacc.c */ -#line 2946 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } - break; - - case 760: - -/* Line 1806 of yacc.c */ -#line 2948 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } - break; - - case 761: - -/* Line 1806 of yacc.c */ -#line 2950 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } - break; - - case 762: - -/* Line 1806 of yacc.c */ -#line 2952 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } - break; - - case 763: - -/* Line 1806 of yacc.c */ -#line 2959 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); } - break; - - case 764: - -/* Line 1806 of yacc.c */ -#line 2961 "parser.yy" - { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); } - break; - - case 765: - -/* Line 1806 of yacc.c */ -#line 2963 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } - break; - - case 766: - -/* Line 1806 of yacc.c */ -#line 2965 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); } - break; - - case 767: - -/* Line 1806 of yacc.c */ -#line 2967 "parser.yy" - { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); } - break; - - case 768: - -/* Line 1806 of yacc.c */ -#line 2969 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } - break; - - case 769: - -/* Line 1806 of yacc.c */ -#line 2974 "parser.yy" - { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); } - break; - - case 770: - -/* Line 1806 of yacc.c */ -#line 2981 "parser.yy" - { (yyval.decl) = DeclarationNode::newFunction( nullptr, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), nullptr ); } - break; - - case 771: - -/* Line 1806 of yacc.c */ -#line 2983 "parser.yy" - { (yyval.decl) = DeclarationNode::newFunction( nullptr, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), nullptr ); } - break; - - case 774: - -/* Line 1806 of yacc.c */ -#line 3007 "parser.yy" - { (yyval.en) = nullptr; } - break; - - case 775: - -/* Line 1806 of yacc.c */ -#line 3009 "parser.yy" - { (yyval.en) = (yyvsp[(2) - (2)].en); } - break; - - - -/* Line 1806 of yacc.c */ -#line 9572 "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 3012 "parser.yy" - -// ----end of grammar---- - -extern char *yytext; - -void yyerror( const char * ) { - cout << "Error "; - if ( yyfilename ) { - cout << "in file " << yyfilename << " "; - } // if - cout << "at line " << yylineno << " reading token \"" << (yytext[0] == '\0' ? "EOF" : yytext) << "\"" << endl; -} - -// Local Variables: // -// mode: c++ // -// tab-width: 4 // -// compile-command: "make install" // -// End: // - Index: src/Parser/parser.h =================================================================== --- src/Parser/parser.h (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ (revision ) @@ -1,303 +1,0 @@ -/* A Bison parser, made by GNU Bison 2.5. */ - -/* Bison interface 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. */ - - -/* 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, - ZERO_T = 279, - ONE_T = 280, - VALIST = 281, - BOOL = 282, - COMPLEX = 283, - IMAGINARY = 284, - TYPEOF = 285, - LABEL = 286, - ENUM = 287, - STRUCT = 288, - UNION = 289, - OTYPE = 290, - FTYPE = 291, - DTYPE = 292, - TTYPE = 293, - TRAIT = 294, - SIZEOF = 295, - OFFSETOF = 296, - ATTRIBUTE = 297, - EXTENSION = 298, - IF = 299, - ELSE = 300, - SWITCH = 301, - CASE = 302, - DEFAULT = 303, - DO = 304, - WHILE = 305, - FOR = 306, - BREAK = 307, - CONTINUE = 308, - GOTO = 309, - RETURN = 310, - CHOOSE = 311, - DISABLE = 312, - ENABLE = 313, - FALLTHRU = 314, - TRY = 315, - CATCH = 316, - CATCHRESUME = 317, - FINALLY = 318, - THROW = 319, - THROWRESUME = 320, - AT = 321, - ASM = 322, - ALIGNAS = 323, - ALIGNOF = 324, - ATOMIC = 325, - GENERIC = 326, - NORETURN = 327, - STATICASSERT = 328, - THREADLOCAL = 329, - IDENTIFIER = 330, - QUOTED_IDENTIFIER = 331, - TYPEDEFname = 332, - TYPEGENname = 333, - ATTR_IDENTIFIER = 334, - ATTR_TYPEDEFname = 335, - ATTR_TYPEGENname = 336, - INTEGERconstant = 337, - CHARACTERconstant = 338, - STRINGliteral = 339, - REALDECIMALconstant = 340, - REALFRACTIONconstant = 341, - FLOATINGconstant = 342, - ZERO = 343, - ONE = 344, - ARROW = 345, - ICR = 346, - DECR = 347, - LS = 348, - RS = 349, - LE = 350, - GE = 351, - EQ = 352, - NE = 353, - ANDAND = 354, - OROR = 355, - ELLIPSIS = 356, - MULTassign = 357, - DIVassign = 358, - MODassign = 359, - PLUSassign = 360, - MINUSassign = 361, - LSassign = 362, - RSassign = 363, - ANDassign = 364, - ERassign = 365, - ORassign = 366, - ATassign = 367, - THEN = 368 - }; -#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 ZERO_T 279 -#define ONE_T 280 -#define VALIST 281 -#define BOOL 282 -#define COMPLEX 283 -#define IMAGINARY 284 -#define TYPEOF 285 -#define LABEL 286 -#define ENUM 287 -#define STRUCT 288 -#define UNION 289 -#define OTYPE 290 -#define FTYPE 291 -#define DTYPE 292 -#define TTYPE 293 -#define TRAIT 294 -#define SIZEOF 295 -#define OFFSETOF 296 -#define ATTRIBUTE 297 -#define EXTENSION 298 -#define IF 299 -#define ELSE 300 -#define SWITCH 301 -#define CASE 302 -#define DEFAULT 303 -#define DO 304 -#define WHILE 305 -#define FOR 306 -#define BREAK 307 -#define CONTINUE 308 -#define GOTO 309 -#define RETURN 310 -#define CHOOSE 311 -#define DISABLE 312 -#define ENABLE 313 -#define FALLTHRU 314 -#define TRY 315 -#define CATCH 316 -#define CATCHRESUME 317 -#define FINALLY 318 -#define THROW 319 -#define THROWRESUME 320 -#define AT 321 -#define ASM 322 -#define ALIGNAS 323 -#define ALIGNOF 324 -#define ATOMIC 325 -#define GENERIC 326 -#define NORETURN 327 -#define STATICASSERT 328 -#define THREADLOCAL 329 -#define IDENTIFIER 330 -#define QUOTED_IDENTIFIER 331 -#define TYPEDEFname 332 -#define TYPEGENname 333 -#define ATTR_IDENTIFIER 334 -#define ATTR_TYPEDEFname 335 -#define ATTR_TYPEGENname 336 -#define INTEGERconstant 337 -#define CHARACTERconstant 338 -#define STRINGliteral 339 -#define REALDECIMALconstant 340 -#define REALFRACTIONconstant 341 -#define FLOATINGconstant 342 -#define ZERO 343 -#define ONE 344 -#define ARROW 345 -#define ICR 346 -#define DECR 347 -#define LS 348 -#define RS 349 -#define LE 350 -#define GE 351 -#define EQ 352 -#define NE 353 -#define ANDAND 354 -#define OROR 355 -#define ELLIPSIS 356 -#define MULTassign 357 -#define DIVassign 358 -#define MODassign 359 -#define PLUSassign 360 -#define MINUSassign 361 -#define LSassign 362 -#define RSassign 363 -#define ANDassign 364 -#define ERassign 365 -#define ORassign 366 -#define ATassign 367 -#define THEN 368 - - - - -#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED -typedef union YYSTYPE -{ - -/* Line 2068 of yacc.c */ -#line 139 "parser.yy" - - Token tok; - ParseNode * pn; - ExpressionNode * en; - DeclarationNode * decl; - DeclarationNode::Aggregate aggKey; - DeclarationNode::TypeClass tclass; - StatementNode * sn; - ConstantExpr * constant; - ForCtl * fctl; - LabelNode * label; - InitializerNode * in; - OperKinds op; - std::string * str; - bool flag; - - - -/* Line 2068 of yacc.c */ -#line 295 "Parser/parser.h" -} YYSTYPE; -# define YYSTYPE_IS_TRIVIAL 1 -# define yystype YYSTYPE /* obsolescent; will be withdrawn */ -# define YYSTYPE_IS_DECLARED 1 -#endif - -extern YYSTYPE yylval; - - Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/Parser/parser.yy (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Sat Sep 1 20:22:55 2001 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Feb 28 09:58:10 2017 -// Update Count : 2208 +// Last Modified On : Sun Mar 5 15:48:24 2017 +// Update Count : 2227 // @@ -91,10 +91,12 @@ // 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 EXTERN STATIC AUTO REGISTER +%token THREADLOCAL // C11 +%token INLINE FORTRAN // C99, extension ISO/IEC 9899:1999 Section J.5.9(1) +%token NORETURN // C11 %token CONST VOLATILE %token RESTRICT // C99 -%token FORALL LVALUE // CFA +%token ATOMIC // C11 +%token FORALL LVALUE MUTEX // CFA %token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED ZERO_T ONE_T %token VALIST // GCC @@ -102,5 +104,5 @@ %token TYPEOF LABEL // GCC %token ENUM STRUCT UNION -%token OTYPE FTYPE DTYPE TTYPE TRAIT // CFA +%token OTYPE FTYPE DTYPE TTYPE TRAIT // CFA %token SIZEOF OFFSETOF %token ATTRIBUTE EXTENSION // GCC @@ -108,5 +110,5 @@ %token CHOOSE DISABLE ENABLE FALLTHRU TRY CATCH CATCHRESUME FINALLY THROW THROWRESUME AT // CFA %token ASM // C99, extension ISO/IEC 9899:1999 Section J.5.10(1) -%token ALIGNAS ALIGNOF ATOMIC GENERIC NORETURN STATICASSERT THREADLOCAL // C11 +%token ALIGNAS ALIGNOF GENERIC STATICASSERT // C11 // names and constants: lexer differentiates between identifier and typedef names @@ -1400,13 +1402,15 @@ type_qualifier_name: CONST - { $$ = DeclarationNode::newQualifier( DeclarationNode::Const ); } + { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Const ); } | RESTRICT - { $$ = DeclarationNode::newQualifier( DeclarationNode::Restrict ); } + { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Restrict ); } | VOLATILE - { $$ = DeclarationNode::newQualifier( DeclarationNode::Volatile ); } + { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Volatile ); } | LVALUE // CFA - { $$ = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); } + { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Lvalue ); } + | MUTEX + { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Mutex ); } | ATOMIC - { $$ = DeclarationNode::newQualifier( DeclarationNode::Atomic ); } + { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Atomic ); } | FORALL '(' { @@ -1448,14 +1452,13 @@ | REGISTER { $$ = DeclarationNode::newStorageClass( DeclarationNode::Register ); } - | INLINE // C99 - //{ $$ = DeclarationNode::newStorageClass( DeclarationNode::Inline ); } - { $$ = new DeclarationNode; $$->isInline = true; } - | FORTRAN // C99 - { $$ = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); } - | NORETURN // C11 - //{ $$ = DeclarationNode::newStorageClass( DeclarationNode::Noreturn ); } - { $$ = new DeclarationNode; $$->isNoreturn = true; } | THREADLOCAL // C11 { $$ = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); } + // Put function specifiers here to simplify parsing rules, but separate them semantically. + | INLINE // C99 + { $$ = DeclarationNode::newFuncSpecifier( DeclarationNode::Inline ); } + | FORTRAN // C99 + { $$ = DeclarationNode::newFuncSpecifier( DeclarationNode::Fortran ); } + | NORETURN // C11 + { $$ = DeclarationNode::newFuncSpecifier( DeclarationNode::Noreturn ); } ; @@ -2033,5 +2036,5 @@ { $$ = $3->addQualifiers( $1 ); } | type_declaring_list ',' type_declarator - { $$ = $1->appendList( $3->copyStorageClasses( $1 ) ); } + { $$ = $1->appendList( $3->copySpecifiers( $1 ) ); } ; Index: src/ResolvExpr/Unify.cc =================================================================== --- src/ResolvExpr/Unify.cc (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/ResolvExpr/Unify.cc (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Sun May 17 12:27:10 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Mar 2 17:37:05 2016 -// Update Count : 37 +// Last Modified On : Mon Mar 6 23:37:38 2017 +// Update Count : 39 // @@ -541,5 +541,5 @@ flatten( dcl->get_type(), back_inserter( types ) ); for ( Type * t : types ) { - dst.push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, t, nullptr ) ); + dst.push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::C, nullptr, t, nullptr ) ); } delete dcl; Index: src/SymTab/Autogen.cc =================================================================== --- src/SymTab/Autogen.cc (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/SymTab/Autogen.cc (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Thu Mar 03 15:45:56 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Feb 16 15:02:50 2017 -// Update Count : 13 +// Last Modified On : Tue Mar 7 07:42:44 2017 +// Update Count : 51 // @@ -125,5 +125,5 @@ FunctionType * genDefaultType( Type * paramType ) { FunctionType *ftype = new FunctionType( Type::Qualifiers(), false ); - ObjectDecl *dstParam = new ObjectDecl( "_dst", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), paramType->clone() ), nullptr ); + ObjectDecl *dstParam = new ObjectDecl( "_dst", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), paramType->clone() ), nullptr ); ftype->get_parameters().push_back( dstParam ); @@ -134,5 +134,5 @@ FunctionType * genCopyType( Type * paramType ) { FunctionType *ftype = genDefaultType( paramType ); - ObjectDecl *srcParam = new ObjectDecl( "_src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr ); + ObjectDecl *srcParam = new ObjectDecl( "_src", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr ); ftype->get_parameters().push_back( srcParam ); return ftype; @@ -142,5 +142,5 @@ FunctionType * genAssignType( Type * paramType ) { FunctionType *ftype = genCopyType( paramType ); - ObjectDecl *returnVal = new ObjectDecl( "_ret", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr ); + ObjectDecl *returnVal = new ObjectDecl( "_ret", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr ); ftype->get_returnVals().push_back( returnVal ); return ftype; @@ -161,7 +161,9 @@ // Routines at global scope marked "static" to prevent multiple definitions in separate translation units // because each unit generates copies of the default routines for each aggregate. - DeclarationNode::StorageClass sc = functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static; +// DeclarationNode::StorageClass sc = functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static; + DeclarationNode::StorageClasses scs = functionNesting > 0 ? DeclarationNode::StorageClasses() : DeclarationNode::StorageClasses( DeclarationNode::StaticClass ); LinkageSpec::Spec spec = isIntrinsic ? LinkageSpec::Intrinsic : LinkageSpec::AutoGen; - FunctionDecl * decl = new FunctionDecl( fname, sc, spec, ftype, new CompoundStmt( noLabels ), true, false ); + FunctionDecl * decl = new FunctionDecl( fname, scs, spec, ftype, new CompoundStmt( noLabels ), + std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::InlineSpec ) ); decl->fixUniqueId(); return decl; @@ -458,5 +460,5 @@ continue; } - memCtorType->get_parameters().push_back( new ObjectDecl( member->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, member->get_type()->clone(), 0 ) ); + memCtorType->get_parameters().push_back( new ObjectDecl( member->get_name(), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, member->get_type()->clone(), 0 ) ); FunctionDecl * ctor = genFunc( "?{}", memCtorType->clone(), functionNesting ); makeStructFieldCtorBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), ctor, isDynamicLayout ); @@ -538,5 +540,5 @@ for ( Declaration * member : aggregateDecl->get_members() ) { if ( DeclarationWithType * field = dynamic_cast< DeclarationWithType * >( member ) ) { - ObjectDecl * srcParam = new ObjectDecl( "src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, field->get_type()->clone(), 0 ); + ObjectDecl * srcParam = new ObjectDecl( "src", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, field->get_type()->clone(), 0 ); FunctionType * memCtorType = ctorType->clone(); @@ -603,6 +605,6 @@ TypeInstType *typeInst = new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), false ); typeInst->set_baseType( typeDecl ); - ObjectDecl *src = new ObjectDecl( "_src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, typeInst->clone(), nullptr ); - ObjectDecl *dst = new ObjectDecl( "_dst", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), typeInst->clone() ), nullptr ); + ObjectDecl *src = new ObjectDecl( "_src", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, typeInst->clone(), nullptr ); + ObjectDecl *dst = new ObjectDecl( "_dst", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), typeInst->clone() ), nullptr ); std::list< Statement * > stmts; @@ -616,5 +618,5 @@ } // if FunctionType *type = new FunctionType( Type::Qualifiers(), false ); - type->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, typeInst, 0 ) ); + type->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, typeInst, 0 ) ); type->get_parameters().push_back( dst ); type->get_parameters().push_back( src ); @@ -715,10 +717,14 @@ if ( TypeInstType * ty = dynamic_cast< TypeInstType * >( t ) ) { if ( ! done.count( ty->get_baseType() ) ) { - TypeDecl * newDecl = new TypeDecl( ty->get_baseType()->get_name(), DeclarationNode::NoStorageClass, nullptr, TypeDecl::Any ); + TypeDecl * newDecl = new TypeDecl( ty->get_baseType()->get_name(), DeclarationNode::StorageClasses(), nullptr, TypeDecl::Any ); TypeInstType * inst = new TypeInstType( Type::Qualifiers(), newDecl->get_name(), newDecl ); - newDecl->get_assertions().push_back( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, genAssignType( inst ), nullptr, true, false ) ); - newDecl->get_assertions().push_back( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, genDefaultType( inst ), nullptr, true, false ) ); - newDecl->get_assertions().push_back( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, genCopyType( inst ), nullptr, true, false ) ); - newDecl->get_assertions().push_back( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, genDefaultType( inst ), nullptr, true, false ) ); + newDecl->get_assertions().push_back( new FunctionDecl( "?=?", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, genAssignType( inst ), nullptr, + std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::InlineSpec ) ) ); + newDecl->get_assertions().push_back( new FunctionDecl( "?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, genDefaultType( inst ), nullptr, + std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::InlineSpec ) ) ); + newDecl->get_assertions().push_back( new FunctionDecl( "?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, genCopyType( inst ), nullptr, + std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::InlineSpec ) ) ); + newDecl->get_assertions().push_back( new FunctionDecl( "^?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, genDefaultType( inst ), nullptr, + std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::InlineSpec ) ) ); typeParams.push_back( newDecl ); done.insert( ty->get_baseType() ); Index: src/SymTab/Autogen.h =================================================================== --- src/SymTab/Autogen.h (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/SymTab/Autogen.h (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Sun May 17 21:53:34 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Feb 1 16:31:00 2017 -// Update Count : 2 +// Last Modified On : Mon Mar 6 23:33:01 2017 +// Update Count : 4 // @@ -102,5 +102,5 @@ } - ObjectDecl *index = new ObjectDecl( indexName.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin, std::list() ) ); + ObjectDecl *index = new ObjectDecl( indexName.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin, std::list() ) ); UntypedExpr *cond = new UntypedExpr( cmp ); Index: src/SymTab/FixFunction.cc =================================================================== --- src/SymTab/FixFunction.cc (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/SymTab/FixFunction.cc (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Sun May 17 16:19:49 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Mar 2 17:31:10 2016 -// Update Count : 3 +// Last Modified On : Mon Mar 6 23:36:59 2017 +// Update Count : 6 // @@ -21,9 +21,8 @@ namespace SymTab { - FixFunction::FixFunction() : isVoid( false ) { - } + FixFunction::FixFunction() : isVoid( false ) {} DeclarationWithType * FixFunction::mutate(FunctionDecl *functionDecl) { - ObjectDecl *pointer = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClass(), functionDecl->get_linkage(), 0, new PointerType( Type::Qualifiers(), functionDecl->get_type()->clone() ), 0, functionDecl->get_attributes() ); + ObjectDecl *pointer = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClasses(), functionDecl->get_linkage(), 0, new PointerType( Type::Qualifiers(), functionDecl->get_type()->clone() ), 0, functionDecl->get_attributes() ); functionDecl->get_attributes().clear(); delete functionDecl; Index: src/SymTab/Indexer.cc =================================================================== --- src/SymTab/Indexer.cc (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/SymTab/Indexer.cc (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Sun May 17 21:37:33 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Feb 16 14:59:19 2017 -// Update Count : 13 +// Last Modified On : Tue Mar 7 07:45:32 2017 +// Update Count : 16 // @@ -738,5 +738,5 @@ ObjectDecl *newobj = dynamic_cast< ObjectDecl* >( added ); ObjectDecl *oldobj = dynamic_cast< ObjectDecl* >( existing ); - if ( newobj->get_storageClass() != DeclarationNode::Extern && oldobj->get_storageClass() != DeclarationNode::Extern ) { + if ( ! newobj->get_storageClasses()[ DeclarationNode::Extern ] && ! oldobj->get_storageClasses()[ DeclarationNode::Extern ] ) { throw SemanticError( "duplicate object definition for ", added ); } // if Index: src/SymTab/Validate.cc =================================================================== --- src/SymTab/Validate.cc (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/SymTab/Validate.cc (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Sun May 17 21:50:04 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Feb 23 21:33:55 2017 -// Update Count : 318 +// Last Modified On : Tue Mar 7 07:51:36 2017 +// Update Count : 349 // @@ -97,5 +97,4 @@ class ReturnTypeFixer final : public Visitor { public: - typedef Visitor Parent; using Parent::visit; @@ -104,5 +103,4 @@ virtual void visit( FunctionDecl * functionDecl ); - virtual void visit( FunctionType * ftype ); }; @@ -161,5 +159,4 @@ private: virtual void visit( FunctionDecl * functionDecl ); - virtual void visit( ReturnStmt * returnStmt ); @@ -211,5 +208,5 @@ class CompoundLiteral final : public GenPoly::DeclMutator { - DeclarationNode::StorageClass storageclass = DeclarationNode::NoStorageClass; + DeclarationNode::StorageClasses storageClasses; using GenPoly::DeclMutator::mutate; @@ -660,7 +657,7 @@ // Note, qualifiers on the typedef are superfluous for the forward declaration. if ( StructInstType *aggDecl = dynamic_cast< StructInstType * >( tyDecl->get_base() ) ) { - return aggDecl->get_baseStruct() ? Mutator::mutate( aggDecl->get_baseStruct() ) : new StructDecl( aggDecl->get_name() ); + return new StructDecl( aggDecl->get_name() ); } else if ( UnionInstType *aggDecl = dynamic_cast< UnionInstType * >( tyDecl->get_base() ) ) { - return aggDecl->get_baseUnion() ? Mutator::mutate( aggDecl->get_baseUnion() ) : new UnionDecl( aggDecl->get_name() ); + return new UnionDecl( aggDecl->get_name() ); } else if ( EnumInstType *enumDecl = dynamic_cast< EnumInstType * >( tyDecl->get_base() ) ) { return new EnumDecl( enumDecl->get_name() ); @@ -691,14 +688,12 @@ DeclarationWithType *ret = Mutator::mutate( objDecl ); typedefNames.endScope(); - // is the type a function? - if ( FunctionType *funtype = dynamic_cast( ret->get_type() ) ) { + + if ( FunctionType *funtype = dynamic_cast( ret->get_type() ) ) { // function type? // replace the current object declaration with a function declaration - FunctionDecl * newDecl = new FunctionDecl( ret->get_name(), ret->get_storageClass(), ret->get_linkage(), funtype, 0, ret->get_isInline(), ret->get_isNoreturn(), objDecl->get_attributes() ); + FunctionDecl * newDecl = new FunctionDecl( ret->get_name(), ret->get_storageClasses(), ret->get_linkage(), funtype, 0, objDecl->get_attributes(), ret->get_funcSpec() ); objDecl->get_attributes().clear(); objDecl->set_type( nullptr ); delete objDecl; return newDecl; - } else if ( objDecl->get_isInline() || objDecl->get_isNoreturn() ) { - throw SemanticError( "invalid inline or _Noreturn specification in declaration of ", objDecl ); } // if return ret; @@ -759,5 +754,5 @@ type = new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ); } // if - TypedefDeclPtr tyDecl( new TypedefDecl( aggDecl->get_name(), DeclarationNode::NoStorageClass, type ) ); + TypedefDeclPtr tyDecl( new TypedefDecl( aggDecl->get_name(), DeclarationNode::StorageClasses(), type ) ); typedefNames[ aggDecl->get_name() ] = std::make_pair( std::move( tyDecl ), scopeLevel ); } // if @@ -813,7 +808,6 @@ DeclarationWithType * CompoundLiteral::mutate( ObjectDecl *objectDecl ) { - storageclass = objectDecl->get_storageClass(); + storageClasses = objectDecl->get_storageClasses(); DeclarationWithType * temp = Mutator::mutate( objectDecl ); - storageclass = DeclarationNode::NoStorageClass; return temp; } @@ -824,5 +818,5 @@ static UniqueName indexName( "_compLit" ); - ObjectDecl *tempvar = new ObjectDecl( indexName.newName(), storageclass, LinkageSpec::C, 0, compLitExpr->get_type(), compLitExpr->get_initializer() ); + ObjectDecl *tempvar = new ObjectDecl( indexName.newName(), storageClasses, LinkageSpec::C, 0, compLitExpr->get_type(), compLitExpr->get_initializer() ); compLitExpr->set_type( 0 ); compLitExpr->set_initializer( 0 ); @@ -863,5 +857,5 @@ TupleType * tupleType = safe_dynamic_cast< TupleType * >( ResolvExpr::extractResultType( ftype ) ); // ensure return value is not destructed by explicitly creating an empty ListInit node wherein maybeConstruct is false. - ObjectDecl * newRet = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, tupleType, new ListInit( std::list(), noDesignators, false ) ); + ObjectDecl * newRet = new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, tupleType, new ListInit( std::list(), noDesignators, false ) ); deleteAll( retVals ); retVals.clear(); Index: src/SynTree/AggregateDecl.cc =================================================================== --- src/SynTree/AggregateDecl.cc (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/SynTree/AggregateDecl.cc (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Sun May 17 23:56:39 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Feb 6 15:31:23 2017 -// Update Count : 17 +// Last Modified On : Tue Mar 7 07:31:47 2017 +// Update Count : 19 // @@ -20,5 +20,5 @@ -AggregateDecl::AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes ) : Parent( name, DeclarationNode::NoStorageClass, LinkageSpec::Cforall ), body( false ), attributes( attributes ) { +AggregateDecl::AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes ) : Parent( name, DeclarationNode::StorageClasses(), LinkageSpec::Cforall ), body( false ), attributes( attributes ) { } Index: src/SynTree/Declaration.cc =================================================================== --- src/SynTree/Declaration.cc (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/SynTree/Declaration.cc (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Feb 9 14:28:05 2017 -// Update Count : 16 +// Last Modified On : Tue Mar 7 07:31:11 2017 +// Update Count : 23 // @@ -27,10 +27,10 @@ static IdMapType idMap; -Declaration::Declaration( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Spec linkage ) - : name( name ), storageClass( sc ), linkage( linkage ), isInline( false ), isNoreturn( false ), uniqueId( 0 ) { +Declaration::Declaration( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage ) + : name( name ), storageClasses( scs ), linkage( linkage ), uniqueId( 0 ) { } Declaration::Declaration( const Declaration &other ) - : name( other.name ), storageClass( other.storageClass ), linkage( other.linkage ), isInline( other.isInline ), isNoreturn( other.isNoreturn ), uniqueId( other.uniqueId ) { + : name( other.name ), storageClasses( other.storageClasses ), linkage( other.linkage ), uniqueId( other.uniqueId ) { } @@ -66,5 +66,5 @@ -AsmDecl::AsmDecl( AsmStmt *stmt ) : Declaration( "", DeclarationNode::NoStorageClass, LinkageSpec::C ), stmt( stmt ) { +AsmDecl::AsmDecl( AsmStmt *stmt ) : Declaration( "", DeclarationNode::StorageClasses(), LinkageSpec::C ), stmt( stmt ) { } Index: src/SynTree/Declaration.h =================================================================== --- src/SynTree/Declaration.h (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/SynTree/Declaration.h (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Feb 16 14:53:35 2017 -// Update Count : 57 +// Last Modified On : Tue Mar 7 07:40:42 2017 +// Update Count : 113 // @@ -28,5 +28,5 @@ class Declaration : public BaseSyntaxNode { public: - Declaration( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Spec linkage ); + Declaration( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage ); Declaration( const Declaration &other ); virtual ~Declaration(); @@ -34,13 +34,12 @@ const std::string &get_name() const { return name; } void set_name( std::string newValue ) { name = newValue; } - DeclarationNode::StorageClass get_storageClass() const { return storageClass; } - void set_storageClass( DeclarationNode::StorageClass newValue ) { storageClass = newValue; } + + DeclarationNode::StorageClasses get_storageClasses() const { return storageClasses; } + LinkageSpec::Spec get_linkage() const { return linkage; } void set_linkage( LinkageSpec::Spec newValue ) { linkage = newValue; } - bool get_isInline() const { return isInline; } - void set_isInline( bool newValue ) { isInline = newValue; } - bool get_isNoreturn() const { return isNoreturn; } - void set_isNoreturn( bool newValue ) { isNoreturn = newValue; } + UniqueId get_uniqueId() const { return uniqueId; } + bool get_extension() const { return extension; } Declaration *set_extension( bool exten ) { extension = exten; return this; } @@ -57,7 +56,6 @@ private: std::string name; - DeclarationNode::StorageClass storageClass; + DeclarationNode::StorageClasses storageClasses; LinkageSpec::Spec linkage; - bool isInline, isNoreturn; UniqueId uniqueId; bool extension = false; @@ -66,5 +64,5 @@ class DeclarationWithType : public Declaration { public: - DeclarationWithType( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes ); + DeclarationWithType( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, DeclarationNode::FuncSpecifiers fs ); DeclarationWithType( const DeclarationWithType &other ); virtual ~DeclarationWithType(); @@ -83,4 +81,7 @@ std::list< Attribute * >& get_attributes() { return attributes; } const std::list< Attribute * >& get_attributes() const { return attributes; } + + DeclarationNode::FuncSpecifiers get_funcSpec() const { return fs; } + //void set_functionSpecifiers( DeclarationNode::FuncSpecifiers newValue ) { fs = newValue; } virtual DeclarationWithType *clone() const = 0; @@ -97,4 +98,5 @@ ConstantExpr *asmName; std::list< Attribute * > attributes; + DeclarationNode::FuncSpecifiers fs; }; @@ -102,5 +104,6 @@ typedef DeclarationWithType Parent; public: - ObjectDecl( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init, const std::list< Attribute * > attributes = std::list< Attribute * >(), bool isInline = false, bool isNoreturn = false ); + ObjectDecl( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init, + const std::list< Attribute * > attributes = std::list< Attribute * >(), DeclarationNode::FuncSpecifiers fs = DeclarationNode::FuncSpecifiers() ); ObjectDecl( const ObjectDecl &other ); virtual ~ObjectDecl(); @@ -129,5 +132,6 @@ typedef DeclarationWithType Parent; public: - FunctionDecl( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements, bool isInline, bool isNoreturn, const std::list< Attribute * > attributes = std::list< Attribute * >() ); + FunctionDecl( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements, + const std::list< Attribute * > attributes = std::list< Attribute * >(), DeclarationNode::FuncSpecifiers fs = DeclarationNode::FuncSpecifiers() ); FunctionDecl( const FunctionDecl &other ); virtual ~FunctionDecl(); @@ -154,5 +158,5 @@ typedef Declaration Parent; public: - NamedTypeDecl( const std::string &name, DeclarationNode::StorageClass sc, Type *type ); + NamedTypeDecl( const std::string &name, DeclarationNode::StorageClasses scs, Type *type ); NamedTypeDecl( const NamedTypeDecl &other ); virtual ~NamedTypeDecl(); @@ -189,5 +193,5 @@ }; - TypeDecl( const std::string &name, DeclarationNode::StorageClass sc, Type *type, Kind kind ); + TypeDecl( const std::string &name, DeclarationNode::StorageClasses scs, Type *type, Kind kind ); TypeDecl( const TypeDecl &other ); @@ -210,5 +214,5 @@ typedef NamedTypeDecl Parent; public: - TypedefDecl( const std::string &name, DeclarationNode::StorageClass sc, Type *type ) : Parent( name, sc, type ) {} + TypedefDecl( const std::string &name, DeclarationNode::StorageClasses scs, Type *type ) : Parent( name, scs, type ) {} TypedefDecl( const TypedefDecl &other ) : Parent( other ) {} Index: src/SynTree/DeclarationWithType.cc =================================================================== --- src/SynTree/DeclarationWithType.cc (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/SynTree/DeclarationWithType.cc (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Dec 13 14:49:43 2016 -// Update Count : 7 +// Last Modified On : Tue Mar 7 07:32:14 2017 +// Update Count : 23 // @@ -19,10 +19,10 @@ #include "Common/utility.h" -DeclarationWithType::DeclarationWithType( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes ) - : Declaration( name, sc, linkage ), asmName( nullptr ), attributes( attributes ) { +DeclarationWithType::DeclarationWithType( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, DeclarationNode::FuncSpecifiers fs ) + : Declaration( name, scs, linkage ), asmName( nullptr ), attributes( attributes ), fs( fs ) { } DeclarationWithType::DeclarationWithType( const DeclarationWithType &other ) - : Declaration( other ), mangleName( other.mangleName ), scopeLevel( other.scopeLevel ) { + : Declaration( other ), mangleName( other.mangleName ), scopeLevel( other.scopeLevel ), fs( other.fs ) { cloneAll( other.attributes, attributes ); asmName = maybeClone( other.asmName ); Index: src/SynTree/FunctionDecl.cc =================================================================== --- src/SynTree/FunctionDecl.cc (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/SynTree/FunctionDecl.cc (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Feb 16 15:01:52 2017 -// Update Count : 23 +// Last Modified On : Tue Mar 7 07:54:58 2017 +// Update Count : 68 // @@ -26,10 +26,7 @@ extern bool translation_unit_nomain; -FunctionDecl::FunctionDecl( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements, bool isInline, bool isNoreturn, std::list< Attribute * > attributes ) - : Parent( name, sc, linkage, attributes ), type( type ), statements( statements ) { - set_isInline( isInline ); - set_isNoreturn( isNoreturn ); - // this is a brazen hack to force the function "main" to have Cforall linkage - // because we want to replace the main even if it is inside an extern +FunctionDecl::FunctionDecl( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements, std::list< Attribute * > attributes, DeclarationNode::FuncSpecifiers fs ) + : Parent( name, scs, linkage, attributes, fs ), type( type ), statements( statements ) { + // hack forcing the function "main" to have Cforall linkage to replace main even if it is inside an extern if ( name == "main" ) { set_linkage( CodeGen::FixMain::mainLinkage() ); @@ -38,5 +35,5 @@ FunctionDecl::FunctionDecl( const FunctionDecl &other ) - : Parent( other ), type( maybeClone( other.type ) ), statements( maybeClone( other.statements ) ) { + : Parent( other ), type( maybeClone( other.type ) ), statements( maybeClone( other.statements ) ) { } @@ -65,16 +62,10 @@ os << LinkageSpec::linkageName( get_linkage() ) << " "; } // if - if ( get_isInline() ) { - os << "inline "; - } // if - if ( get_isNoreturn() ) { - os << "_Noreturn "; - } // if printAll( get_attributes(), os, indent ); - if ( get_storageClass() != DeclarationNode::NoStorageClass ) { - os << DeclarationNode::storageName[ get_storageClass() ] << ' '; - } // if + DeclarationNode::print_StorageClass( os, get_storageClasses() ); + DeclarationNode::print_FuncSpec( os, get_funcSpec() ); + if ( get_type() ) { get_type()->print( os, indent ); @@ -97,16 +88,10 @@ os << get_name() << ": "; } // if - if ( get_isInline() ) { - os << "inline "; - } // if - if ( get_isNoreturn() ) { - os << "_Noreturn "; - } // if // xxx - should printShort print attributes? - if ( get_storageClass() != DeclarationNode::NoStorageClass ) { - os << DeclarationNode::storageName[ get_storageClass() ] << ' '; - } // if + DeclarationNode::print_StorageClass( os, get_storageClasses() ); + DeclarationNode::print_FuncSpec( os, get_funcSpec() ); + if ( get_type() ) { get_type()->print( os, indent ); Index: src/SynTree/NamedTypeDecl.cc =================================================================== --- src/SynTree/NamedTypeDecl.cc (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/SynTree/NamedTypeDecl.cc (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Jun 13 08:13:55 2015 -// Update Count : 3 +// Last Modified On : Tue Mar 7 07:39:41 2017 +// Update Count : 10 // @@ -18,6 +18,6 @@ #include "Common/utility.h" -NamedTypeDecl::NamedTypeDecl( const std::string &name, DeclarationNode::StorageClass sc, Type *base ) - : Parent( name, sc, LinkageSpec::Cforall ), base( base ) {} +NamedTypeDecl::NamedTypeDecl( const std::string &name, DeclarationNode::StorageClasses scs, Type *base ) + : Parent( name, scs, LinkageSpec::Cforall ), base( base ) {} NamedTypeDecl::NamedTypeDecl( const NamedTypeDecl &other ) @@ -39,7 +39,5 @@ os << get_name() << ": "; } // if - if ( get_storageClass() != DeclarationNode::NoStorageClass ) { - os << DeclarationNode::storageName[ get_storageClass() ] << ' '; - } // if + DeclarationNode::print_StorageClass( os, get_storageClasses() ); os << typeString(); if ( base ) { @@ -63,7 +61,5 @@ os << get_name() << ": "; } // if - if ( get_storageClass() != DeclarationNode::NoStorageClass ) { - os << DeclarationNode::storageName[ get_storageClass() ] << ' '; - } // if + DeclarationNode::print_StorageClass( os, get_storageClasses() ); os << typeString(); if ( base ) { Index: src/SynTree/ObjectDecl.cc =================================================================== --- src/SynTree/ObjectDecl.cc (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/SynTree/ObjectDecl.cc (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Oct 1 23:05:56 2016 -// Update Count : 32 +// Last Modified On : Tue Mar 7 07:55:24 2017 +// Update Count : 54 // @@ -22,8 +22,6 @@ #include "Statement.h" -ObjectDecl::ObjectDecl( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init, const std::list< Attribute * > attributes, bool isInline, bool isNoreturn ) - : Parent( name, sc, linkage, attributes ), type( type ), init( init ), bitfieldWidth( bitfieldWidth ) { - set_isInline( isInline ); - set_isNoreturn( isNoreturn ); +ObjectDecl::ObjectDecl( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init, const std::list< Attribute * > attributes, DeclarationNode::FuncSpecifiers fs ) + : Parent( name, scs, linkage, attributes, fs ), type( type ), init( init ), bitfieldWidth( bitfieldWidth ) { } @@ -49,7 +47,5 @@ printAll( get_attributes(), os, indent ); - if ( get_storageClass() != DeclarationNode::NoStorageClass ) { - os << DeclarationNode::storageName[ get_storageClass() ] << ' '; - } // if + DeclarationNode::print_StorageClass( os, get_storageClasses() ); if ( get_type() ) { @@ -85,7 +81,5 @@ // xxx - should printShort print attributes? - if ( get_storageClass() != DeclarationNode::NoStorageClass ) { - os << DeclarationNode::storageName[ get_storageClass() ] << ' '; - } // if + DeclarationNode::print_StorageClass( os, get_storageClasses() ); if ( get_type() ) { Index: src/SynTree/Type.h =================================================================== --- src/SynTree/Type.h (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/SynTree/Type.h (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Feb 23 16:38:53 2017 -// Update Count : 34 +// Last Modified On : Wed Mar 1 09:11:45 2017 +// Update Count : 41 // @@ -21,5 +21,4 @@ #include "SynTree.h" #include "Visitor.h" -#include "Common/utility.h" class Type : public BaseSyntaxNode { @@ -213,5 +212,4 @@ bool get_isVarArgs() const { return isVarArgs; } void set_isVarArgs( bool newValue ) { isVarArgs = newValue; } - bool isTtype() const; Index: src/SynTree/TypeDecl.cc =================================================================== --- src/SynTree/TypeDecl.cc (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/SynTree/TypeDecl.cc (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Jun 13 08:14:35 2015 -// Update Count : 2 +// Last Modified On : Tue Mar 7 07:39:09 2017 +// Update Count : 4 // @@ -18,5 +18,5 @@ #include "Common/utility.h" -TypeDecl::TypeDecl( const std::string &name, DeclarationNode::StorageClass sc, Type *type, Kind kind ) : Parent( name, sc, type ), kind( kind ), sized( kind == Any || kind == Ttype ) { +TypeDecl::TypeDecl( const std::string &name, DeclarationNode::StorageClasses scs, Type *type, Kind kind ) : Parent( name, scs, type ), kind( kind ), sized( kind == Any || kind == Ttype ) { } Index: src/Tuples/TupleAssignment.cc =================================================================== --- src/Tuples/TupleAssignment.cc (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/Tuples/TupleAssignment.cc (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Feb 1 16:40:16 2017 -// Update Count : 3 +// Last Modified On : Mon Mar 6 23:40:14 2017 +// Update Count : 5 // @@ -240,5 +240,5 @@ ObjectDecl * TupleAssignSpotter::Matcher::newObject( UniqueName & namer, Expression * expr ) { assert( expr->has_result() && ! expr->get_result()->isVoid() ); - ObjectDecl * ret = new ObjectDecl( namer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, expr->get_result()->clone(), new SingleInit( expr->clone() ) ); + ObjectDecl * ret = new ObjectDecl( namer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, expr->get_result()->clone(), new SingleInit( expr->clone() ) ); ConstructorInit * ctorInit = InitTweak::genCtorInit( ret ); ret->set_init( ctorInit ); Index: src/Tuples/TupleExpansion.cc =================================================================== --- src/Tuples/TupleExpansion.cc (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/Tuples/TupleExpansion.cc (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Feb 1 16:40:40 2017 -// Update Count : 3 +// Last Modified On : Tue Mar 7 07:43:56 2017 +// Update Count : 12 // @@ -187,5 +187,5 @@ } BasicType * boolType = new BasicType( Type::Qualifiers(), BasicType::Bool ); - ObjectDecl * finished = new ObjectDecl( toString( "_unq_expr_finished_", id ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::Bool ), new SingleInit( new ConstantExpr( Constant( boolType->clone(), "0" ) ), noDesignators ) ); + ObjectDecl * finished = new ObjectDecl( toString( "_unq_expr_finished_", id ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::Bool ), new SingleInit( new ConstantExpr( Constant( boolType->clone(), "0" ) ), noDesignators ) ); addDeclaration( finished ); // (finished ? _unq_expr_N : (_unq_expr_N = get_expr()>, finished = 1, _unq_expr_N)) @@ -221,11 +221,11 @@ decl->set_body( true ); for ( size_t i = 0; i < tupleSize; ++i ) { - TypeDecl * tyParam = new TypeDecl( toString("tuple_param_", i), DeclarationNode::NoStorageClass, nullptr, TypeDecl::Any ); - decl->get_members().push_back( new ObjectDecl( toString("field_", i), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, new TypeInstType( Type::Qualifiers(), tyParam->get_name(), tyParam ), nullptr ) ); + TypeDecl * tyParam = new TypeDecl( toString( "tuple_param_", i ), DeclarationNode::StorageClasses(), nullptr, TypeDecl::Any ); + decl->get_members().push_back( new ObjectDecl( toString("field_", i ), DeclarationNode::StorageClasses(), LinkageSpec::C, nullptr, new TypeInstType( Type::Qualifiers(), tyParam->get_name(), tyParam ), nullptr ) ); decl->get_parameters().push_back( tyParam ); } if ( tupleSize == 0 ) { // empty structs are not standard C. Add a dummy field to empty tuples to silence warnings when a compound literal Tuple0 is created. - decl->get_members().push_back( new ObjectDecl( "dummy", DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) ); + decl->get_members().push_back( new ObjectDecl( "dummy", DeclarationNode::StorageClasses(), LinkageSpec::C, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) ); } typeMap[tupleSize] = decl; Index: src/benchmark/Makefile.am =================================================================== --- src/benchmark/Makefile.am (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/benchmark/Makefile.am (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -18,5 +18,5 @@ CFLAGS = AM_CFLAGS = -g -Wall -Wno-unused-function -O2 -CC = @CFA_BINDIR@/cfa +CC = @CFA_BINDIR@/@CFA_NAME@ noinst_PROGRAMS = bench ctxswitch-coroutine ctxswitch-thread Index: src/benchmark/Makefile.in =================================================================== --- src/benchmark/Makefile.in (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/benchmark/Makefile.in (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -94,5 +94,5 @@ AWK = @AWK@ BACKEND_CC = @BACKEND_CC@ -CC = @CFA_BINDIR@/cfa +CC = @CFA_BINDIR@/@CFA_NAME@ CCAS = @CCAS@ CCASDEPMODE = @CCASDEPMODE@ @@ -104,4 +104,5 @@ CFA_INCDIR = @CFA_INCDIR@ CFA_LIBDIR = @CFA_LIBDIR@ +CFA_NAME = @CFA_NAME@ CFA_PREFIX = @CFA_PREFIX@ Index: src/driver/Makefile.am =================================================================== --- src/driver/Makefile.am (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/driver/Makefile.am (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -28,11 +28,19 @@ endif -bin_PROGRAMS = cfa +noinst_PROGRAMS = cfa cfa_SOURCES = cfa.cc +install-exec-hook: + @echo " $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) cfa '$(CFA_BINDIR)/$(CFA_NAME)'"; \ + $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) cfa $(CFA_BINDIR)/$(CFA_NAME) || exit $$? + +uninstall-hook: + @echo " ( cd '$(CFA_BINDIR)' && rm -f $(CFA_NAME) )"; \ + cd "$(CFA_BINDIR)" && rm -f $(CFA_NAME) + # put into lib for now -cc1libdir = ${libdir} +cc1libdir = ${CFA_LIBDIR} cc1lib_PROGRAMS = cc1 cc1_SOURCES = cc1.cc -MAINTAINERCLEANFILES = @CFA_PREFIX@/bin/${bin_PROGRAMS} @CFA_PREFIX@/lib/${cc1lib_PROGRAMS} +MAINTAINERCLEANFILES = $(CFA_BINDIR)/$(CFA_NAME) @CFA_PREFIX@/lib/${cc1lib_PROGRAMS} Index: src/driver/Makefile.in =================================================================== --- src/driver/Makefile.in (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/driver/Makefile.in (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -41,5 +41,5 @@ @BUILD_DEBUG_TRUE@am__append_2 = -DHAVE_LIBCFA_DEBUG @BUILD_RELEASE_TRUE@am__append_3 = -DHAVE_LIBCFA_RELEASE -bin_PROGRAMS = cfa$(EXEEXT) +noinst_PROGRAMS = cfa$(EXEEXT) cc1lib_PROGRAMS = cc1$(EXEEXT) subdir = src/driver @@ -53,6 +53,6 @@ CONFIG_CLEAN_FILES = CONFIG_CLEAN_VPATH_FILES = -am__installdirs = "$(DESTDIR)$(bindir)" "$(DESTDIR)$(cc1libdir)" -PROGRAMS = $(bin_PROGRAMS) $(cc1lib_PROGRAMS) +am__installdirs = "$(DESTDIR)$(cc1libdir)" +PROGRAMS = $(cc1lib_PROGRAMS) $(noinst_PROGRAMS) am_cc1_OBJECTS = cc1.$(OBJEXT) cc1_OBJECTS = $(am_cc1_OBJECTS) @@ -106,4 +106,5 @@ CFA_INCDIR = @CFA_INCDIR@ CFA_LIBDIR = @CFA_LIBDIR@ +CFA_NAME = @CFA_NAME@ CFA_PREFIX = @CFA_PREFIX@ CFLAGS = @CFLAGS@ @@ -212,7 +213,7 @@ # put into lib for now -cc1libdir = ${libdir} +cc1libdir = ${CFA_LIBDIR} cc1_SOURCES = cc1.cc -MAINTAINERCLEANFILES = @CFA_PREFIX@/bin/${bin_PROGRAMS} @CFA_PREFIX@/lib/${cc1lib_PROGRAMS} +MAINTAINERCLEANFILES = $(CFA_BINDIR)/$(CFA_NAME) @CFA_PREFIX@/lib/${cc1lib_PROGRAMS} all: all-am @@ -249,41 +250,4 @@ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh $(am__aclocal_m4_deps): -install-binPROGRAMS: $(bin_PROGRAMS) - @$(NORMAL_INSTALL) - test -z "$(bindir)" || $(MKDIR_P) "$(DESTDIR)$(bindir)" - @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \ - for p in $$list; do echo "$$p $$p"; done | \ - sed 's/$(EXEEXT)$$//' | \ - while read p p1; do if test -f $$p; \ - then echo "$$p"; echo "$$p"; else :; fi; \ - done | \ - sed -e 'p;s,.*/,,;n;h' -e 's|.*|.|' \ - -e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \ - sed 'N;N;N;s,\n, ,g' | \ - $(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \ - { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \ - if ($$2 == $$4) files[d] = files[d] " " $$1; \ - else { print "f", $$3 "/" $$4, $$1; } } \ - END { for (d in files) print "f", d, files[d] }' | \ - while read type dir files; do \ - if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \ - test -z "$$files" || { \ - echo " $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \ - $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \ - } \ - ; done - -uninstall-binPROGRAMS: - @$(NORMAL_UNINSTALL) - @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \ - files=`for p in $$list; do echo "$$p"; done | \ - sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \ - -e 's/$$/$(EXEEXT)/' `; \ - test -n "$$list" || exit 0; \ - echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \ - cd "$(DESTDIR)$(bindir)" && rm -f $$files - -clean-binPROGRAMS: - -test -z "$(bin_PROGRAMS)" || rm -f $(bin_PROGRAMS) install-cc1libPROGRAMS: $(cc1lib_PROGRAMS) @$(NORMAL_INSTALL) @@ -323,4 +287,7 @@ clean-cc1libPROGRAMS: -test -z "$(cc1lib_PROGRAMS)" || rm -f $(cc1lib_PROGRAMS) + +clean-noinstPROGRAMS: + -test -z "$(noinst_PROGRAMS)" || rm -f $(noinst_PROGRAMS) cc1$(EXEEXT): $(cc1_OBJECTS) $(cc1_DEPENDENCIES) $(EXTRA_cc1_DEPENDENCIES) @rm -f cc1$(EXEEXT) @@ -439,5 +406,5 @@ all-am: Makefile $(PROGRAMS) installdirs: - for dir in "$(DESTDIR)$(bindir)" "$(DESTDIR)$(cc1libdir)"; do \ + for dir in "$(DESTDIR)$(cc1libdir)"; do \ test -z "$$dir" || $(MKDIR_P) "$$dir"; \ done @@ -475,5 +442,5 @@ clean: clean-am -clean-am: clean-binPROGRAMS clean-cc1libPROGRAMS clean-generic \ +clean-am: clean-cc1libPROGRAMS clean-generic clean-noinstPROGRAMS \ mostlyclean-am @@ -502,6 +469,7 @@ install-dvi-am: -install-exec-am: install-binPROGRAMS - +install-exec-am: + @$(NORMAL_INSTALL) + $(MAKE) $(AM_MAKEFLAGS) install-exec-hook install-html: install-html-am @@ -541,15 +509,16 @@ ps-am: -uninstall-am: uninstall-binPROGRAMS uninstall-cc1libPROGRAMS - -.MAKE: install-am install-strip - -.PHONY: CTAGS GTAGS all all-am check check-am clean clean-binPROGRAMS \ - clean-cc1libPROGRAMS clean-generic ctags distclean \ - distclean-compile distclean-generic distclean-tags distdir dvi \ - dvi-am html html-am info info-am install install-am \ - install-binPROGRAMS install-cc1libPROGRAMS install-data \ - install-data-am install-dvi install-dvi-am install-exec \ - install-exec-am install-html install-html-am install-info \ +uninstall-am: uninstall-cc1libPROGRAMS + @$(NORMAL_INSTALL) + $(MAKE) $(AM_MAKEFLAGS) uninstall-hook +.MAKE: install-am install-exec-am install-strip uninstall-am + +.PHONY: CTAGS GTAGS all all-am check check-am clean \ + clean-cc1libPROGRAMS clean-generic clean-noinstPROGRAMS ctags \ + distclean distclean-compile distclean-generic distclean-tags \ + distdir dvi dvi-am html html-am info info-am install \ + install-am install-cc1libPROGRAMS install-data install-data-am \ + install-dvi install-dvi-am install-exec install-exec-am \ + install-exec-hook install-html install-html-am install-info \ install-info-am install-man install-pdf install-pdf-am \ install-ps install-ps-am install-strip installcheck \ @@ -557,6 +526,14 @@ maintainer-clean-generic mostlyclean mostlyclean-compile \ mostlyclean-generic pdf pdf-am ps ps-am tags uninstall \ - uninstall-am uninstall-binPROGRAMS uninstall-cc1libPROGRAMS - + uninstall-am uninstall-cc1libPROGRAMS uninstall-hook + + +install-exec-hook: + @echo " $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) cfa '$(CFA_BINDIR)/$(CFA_NAME)'"; \ + $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) cfa $(CFA_BINDIR)/$(CFA_NAME) || exit $$? + +uninstall-hook: + @echo " ( cd '$(CFA_BINDIR)' && rm -f $(CFA_NAME) )"; \ + cd "$(CFA_BINDIR)" && rm -f $(CFA_NAME) # Tell versions [3.59,3.63) of GNU make to not export all variables. Index: src/examples/Makefile.am =================================================================== --- src/examples/Makefile.am (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/examples/Makefile.am (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -18,5 +18,5 @@ CFLAGS = AM_CFLAGS = -g -Wall -Wno-unused-function -O2 -CC = @CFA_BINDIR@/cfa +CC = @CFA_BINDIR@/@CFA_NAME@ noinst_PROGRAMS = fstream_test vector_test avl_test Bench # build but do not install Index: src/examples/Makefile.in =================================================================== --- src/examples/Makefile.in (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/examples/Makefile.in (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -105,5 +105,5 @@ AWK = @AWK@ BACKEND_CC = @BACKEND_CC@ -CC = @CFA_BINDIR@/cfa +CC = @CFA_BINDIR@/@CFA_NAME@ CCAS = @CCAS@ CCASDEPMODE = @CCASDEPMODE@ @@ -115,4 +115,5 @@ CFA_INCDIR = @CFA_INCDIR@ CFA_LIBDIR = @CFA_LIBDIR@ +CFA_NAME = @CFA_NAME@ CFA_PREFIX = @CFA_PREFIX@ Index: src/examples/rational.cc =================================================================== --- src/examples/rational.cc (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ (revision ) @@ -1,198 +1,0 @@ -#include "rationalnumber.h" - -#include -#include // exit -using namespace std; - -static struct { - int gcd, con, copy, des, assn, rel, add, sub, mul, div, in, out; -} stats; // implicitly initialized to 0 - -static int gcd( int a, int b ) { - for ( ;; ) { - int r = a % b; - if ( r == 0 ) break; - a = b; - b = r; - } // for - stats.gcd += 1; - return b; -} // gcd - -void Rationalnumber::statistics() { - cerr - << "gcd:" << stats.gcd << '\t' - << "con:" << stats.con << '\t' - << "copy:" << stats.copy << '\t' - << "des:" << stats.des << '\t' - << "assn:" << stats.assn << '\t' - << "rel:" << stats.rel << '\t' - << "add:" << stats.add << '\t' - << "sub:" << stats.sub << '\t' - << "mul:" << stats.mul << '\t' - << "div:" << stats.div << '\t' - << "in:" << stats.in << '\t' - << "out:" << stats.out - << endl; -} // Rationalnumber::statistics - -bool Rationalnumber::eq( Rationalnumber &r ) { - return num * r.denom == denom * r.num; -} // Rationalnumber::Rationalnumber::eq - -bool Rationalnumber::lt( Rationalnumber &r ) { - //int temp1 = denom * r.denom, temp2 = num * r.denom, temp3 = denom * r.num; - //return temp1 > 0 && temp2 < temp3 || temp1 < 0 && temp2 > temp3; - // if denominator is always > 0, only this check is necessary - return num * r.denom < denom * r.num; -} // Rationalnumber::Rationalnumber::lt - -void Rationalnumber::common1( int n, int d ) { - num = n; - denom = d; - stats.con += 1; -} // Rationalnumber::common1 - -int Rationalnumber::common2( int &n, int &d ) { - if ( d == 0 ) { - cerr << "Invalid rational number construction: denominator cannot be equal to 0." << endl; - exit( EXIT_FAILURE ); - } // exit - if ( d < 0 ) { d = -d; n = -n; } // move sign to numerator - return gcd( abs( n ), d ); // simplify -} // Rationalnumber::common2 - -Rationalnumber::Rationalnumber() { - common1( 0, 1 ); -} // Rationalnumber::Rationalnumber - -Rationalnumber::Rationalnumber( int n ) { - common1( n, 1 ); -} // Rationalnumber::Rationalnumber - -Rationalnumber::Rationalnumber( int n, int d ) { - int temp = common2( n, d ); - common1( n / temp, d / temp ); -} // Rationalnumber::Rationalnumber - -Rationalnumber::Rationalnumber( const Rationalnumber &c ) { - num = c.num; - denom = c.denom; - stats.copy += 1; -} // Rationalnumber::Rationalnumber - -Rationalnumber::~Rationalnumber() { - stats.des += 1; -} // Rationalnumber::~Rationalnumber - -Rationalnumber &Rationalnumber::operator=( const Rationalnumber &r ) { - num = r.num; - denom = r.denom; - stats.assn += 1; - return *this; -} // Rationalnumber::operator= - -int Rationalnumber::numerator() const { - return num; -} // Rationalnumber::numerator - -int Rationalnumber::numerator( int n ) { - int prev = num; - int temp = gcd( abs( n ), denom ); // simplify - num = n / temp; - denom = denom / temp; - return prev; -} // Rationalnumber::numerator - -int Rationalnumber::denominator() const { - return denom; -} // Rationalnumber::denominator - -int Rationalnumber::denominator( int d ) { - int prev = denom; - int temp = common2( num, d ); - num = num / temp; - denom = d / temp; - return prev; -} // Rationalnumber::denominator - -bool operator==( Rationalnumber l, Rationalnumber r ) { - stats.rel += 1; - return l.eq( r ); -} // operator== - -bool operator!=( Rationalnumber l, Rationalnumber r ) { - stats.rel += 1; - return ! ( l.eq( r ) ); -} // operator!= - -bool operator<( Rationalnumber l, Rationalnumber r ) { - stats.rel += 1; - return l.lt( r ); -} // operator< - -bool operator<=( Rationalnumber l, Rationalnumber r ) { - stats.rel += 1; - return l.lt( r ) || l.eq( r ); -} // operator<= - -bool operator>( Rationalnumber l, Rationalnumber r ) { - stats.rel += 1; - return ! ( l.lt( r ) || l.eq( r ) ); -} // operator> - -bool operator>=( Rationalnumber l, Rationalnumber r ) { - stats.rel += 1; - return ! ( l.lt( r ) ); -} // operator>= - -Rationalnumber Rationalnumber::operator-() { - return Rationalnumber( -num, denom ); -} // Rationalnumber::operator- - -Rationalnumber operator+( Rationalnumber l, Rationalnumber r ) { - stats.add += 1; - if ( l.denom == r.denom ) { // special case - return Rationalnumber( l.num + r.num, l.denom ); - } else { - return Rationalnumber( l.num * r.denom + l.denom * r.num, l.denom * r.denom ); - } // if -} // operator+ - -Rationalnumber operator-( Rationalnumber l, Rationalnumber r ) { - stats.sub += 1; - if ( l.denom == r.denom ) { // special case - return Rationalnumber( l.num - r.num, l.denom ); - } else { - return Rationalnumber( l.num * r.denom - l.denom * r.num, l.denom * r.denom ); - } // if -} // operator- - -Rationalnumber operator*( Rationalnumber l, Rationalnumber r ) { - stats.mul += 1; - return Rationalnumber( l.num * r.num, l.denom * r.denom ); -} // operator* - -Rationalnumber operator/( Rationalnumber l, Rationalnumber r ) { - stats.div += 1; - if ( r.num < 0 ) { r.num = -r.num; r.denom = -r.denom; } - return Rationalnumber( l.num * r.denom, l.denom * r.num ); -} // operator/ - -istream &operator>>( istream &is, Rationalnumber &r ) { - stats.in += 1; - is >> r.num >> r.denom; - int temp = Rationalnumber::common2( r.num, r.denom ); - r.num /= temp; - r.denom /= temp; - return is; -} // operator>> - -ostream &operator<<( ostream &os, Rationalnumber r ) { - stats.out += 1; - return os << r.num << "/" << r.denom; -} // operator<< - -// Local Variables: // -// compile-command: "make rationalnumber" // -// End: // Index: src/libcfa/Makefile.am =================================================================== --- src/libcfa/Makefile.am (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/libcfa/Makefile.am (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -18,4 +18,5 @@ AUTOMAKE_OPTIONS = subdir-objects +libdir = ${CFA_LIBDIR} lib_LIBRARIES = @@ -67,5 +68,4 @@ ${libobjs} : ${abs_top_srcdir}/src/driver/cfa-cpp ${cfalib_DATA} # add dependency to cfa-cpp so all libraries are rebuilt with new translator - libcfa_a_SOURCES = ${libsrc} libcfa_a_CFLAGS = -nodebug -O2 @@ -75,5 +75,5 @@ stdhdr = ${shell echo stdhdr/*} -cfa_includedir = $(includedir)/cfa +cfa_includedir = $(CFA_INCDIR) nobase_cfa_include_HEADERS = ${headers} ${stdhdr} concurrency/invoke.h @@ -81,3 +81,3 @@ maintainer-clean-local: - -rm -rf ${includedir}/* + -rm -rf ${CFA_INCDIR} ${CFA_LIBDIR} Index: src/libcfa/Makefile.in =================================================================== --- src/libcfa/Makefile.in (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/libcfa/Makefile.in (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -201,4 +201,5 @@ CFA_INCDIR = @CFA_INCDIR@ CFA_LIBDIR = @CFA_LIBDIR@ +CFA_NAME = @CFA_NAME@ CFA_PREFIX = @CFA_PREFIX@ CFLAGS = -quiet -no-include-stdhdr -XCFA -t -B${abs_top_srcdir}/src/driver ${EXTRA_FLAGS} @@ -281,5 +282,5 @@ infodir = @infodir@ install_sh = @install_sh@ -libdir = @libdir@ +libdir = ${CFA_LIBDIR} libexecdir = @libexecdir@ localedir = @localedir@ @@ -315,5 +316,5 @@ libcfa_d_a_CFLAGS = -debug -O0 stdhdr = ${shell echo stdhdr/*} -cfa_includedir = $(includedir)/cfa +cfa_includedir = $(CFA_INCDIR) nobase_cfa_include_HEADERS = ${headers} ${stdhdr} concurrency/invoke.h CLEANFILES = libcfa-prelude.c @@ -1160,5 +1161,5 @@ maintainer-clean-local: - -rm -rf ${includedir}/* + -rm -rf ${CFA_INCDIR} ${CFA_LIBDIR} # Tell versions [3.59,3.63) of GNU make to not export all variables. Index: src/libcfa/iostream =================================================================== --- src/libcfa/iostream (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/libcfa/iostream (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Feb 24 21:09:09 2017 -// Update Count : 94 +// Last Modified On : Mon Mar 6 20:51:35 2017 +// Update Count : 98 // @@ -68,6 +68,9 @@ forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const void * ); +// tuples +forall( dtype ostype, otype T, ttype Params | ostream( ostype ) | writeable( T ) | { ostype * ?|?( ostype *, Params ); } ) ostype * ?|?( ostype * os, T arg, Params rest ); + +// manipulators forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, ostype * (*)( ostype * ) ); -// manipulators forall( dtype ostype | ostream( ostype ) ) ostype * endl( ostype * ); forall( dtype ostype | ostream( ostype ) ) ostype * sepOn( ostype * ); Index: src/libcfa/iostream.c =================================================================== --- src/libcfa/iostream.c (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/libcfa/iostream.c (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Feb 24 21:09:59 2017 -// Update Count : 307 +// Last Modified On : Mon Mar 6 20:52:02 2017 +// Update Count : 313 // @@ -155,13 +155,13 @@ enum { Open = 1, Close, OpenClose }; static const unsigned char mask[256] = { - // opening delimiters + // opening delimiters, no space after ['('] : Open, ['['] : Open, ['{'] : Open, - ['$'] : Open, [(unsigned char)'£'] : Open, [(unsigned char)'¥'] : Open, + ['$'] : Open, ['='] : Open, [(unsigned char)'£'] : Open, [(unsigned char)'¥'] : Open, [(unsigned char)'¡'] : Open, [(unsigned char)'¿'] : Open, [(unsigned char)'«'] : Open, - // closing delimiters + // closing delimiters, no space before [','] : Close, ['.'] : Close, [':'] : Close, [';'] : Close, ['!'] : Close, ['?'] : Close, [')'] : Close, [']'] : Close, ['}'] : Close, ['%'] : Close, [(unsigned char)'¢'] : Close, [(unsigned char)'»'] : Close, - // opening-closing delimiters + // opening-closing delimiters, no space before or after ['\''] : OpenClose, ['`'] : OpenClose, ['"'] : OpenClose, [' '] : OpenClose, ['\f'] : OpenClose, ['\n'] : OpenClose, ['\r'] : OpenClose, ['\t'] : OpenClose, ['\v'] : OpenClose, // isspace @@ -198,4 +198,13 @@ +// tuples +forall( dtype ostype, otype T, ttype Params | ostream( ostype ) | writeable( T ) | { ostype * ?|?( ostype *, Params ); } ) +ostype * ?|?( ostype * os, T arg, Params rest ) { + os | arg | ", "; + os | rest; +} // ?|? + + +// manipulators forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype * os, ostype * (* manip)( ostype * ) ) { Index: src/libcfa/stdlib =================================================================== --- src/libcfa/stdlib (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/libcfa/stdlib (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Thu Jan 28 17:12:35 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Feb 24 21:07:16 2017 -// Update Count : 101 +// Last Modified On : Sat Mar 4 22:03:54 2017 +// Update Count : 102 // Index: src/libcfa/stdlib.c =================================================================== --- src/libcfa/stdlib.c (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/libcfa/stdlib.c (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -10,6 +10,6 @@ // Created On : Thu Jan 28 17:10:29 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Feb 24 21:08:11 2017 -// Update Count : 171 +// Last Modified On : Sat Mar 4 22:02:22 2017 +// Update Count : 172 // Index: src/prelude/Makefile.am =================================================================== --- src/prelude/Makefile.am (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/prelude/Makefile.am (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -19,5 +19,5 @@ # put into lib for now -cfalibdir = ${libdir} +cfalibdir = ${CFA_LIBDIR} cfalib_DATA = builtins.cf extras.cf prelude.cf bootloader.c noinst_DATA = ../libcfa/libcfa-prelude.c Index: src/prelude/Makefile.in =================================================================== --- src/prelude/Makefile.in (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/prelude/Makefile.in (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -105,4 +105,5 @@ CFA_INCDIR = @CFA_INCDIR@ CFA_LIBDIR = @CFA_LIBDIR@ +CFA_NAME = @CFA_NAME@ CFA_PREFIX = @CFA_PREFIX@ CFLAGS = @CFLAGS@ @@ -209,5 +210,5 @@ # put into lib for now -cfalibdir = ${libdir} +cfalibdir = ${CFA_LIBDIR} cfalib_DATA = builtins.cf extras.cf prelude.cf bootloader.c noinst_DATA = ../libcfa/libcfa-prelude.c Index: src/prelude/builtins.c =================================================================== --- src/prelude/builtins.c (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ (revision ) @@ -1,284 +1,0 @@ -#define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT, COND) TYPE(NAME) -#define FUNC_SIMPLE(RETURN, NAME, ARGS...) RETURN NAME(ARGS); -#define BT_LAST(NAME) FUNC_SIMPLE(void, NAME) - -#define BT_BOOL _Bool -#define BT_UINTMAX unsigned long int -#define BT_UINT16 short int -#define BT_UINT32 int -#define BT_UINT64 long long int -#define BT_UINT unsigned int -#define BT_INTMAX long int -#define BT_INTPTR int * -#define BT_WINT unsigned int -#define BT_INT int -#define BT_ULONGLONG unsigned long long -#define BT_ULONG unsigned long -#define BT_UNSIGNED unsigned -#define BT_COMPLEX_LONGDOUBLE _Complex long double -#define BT_COMPLEX_DOUBLE _Complex double -#define BT_COMPLEX_FLOAT _Complex float -#define BT_LONGDOUBLEPTR long double * -#define BT_LONGDOUBLE long double -#define BT_LONGLONG long long -#define BT_LONG long -#define BT_DFLOAT32 __Unsupported -#define BT_DFLOAT64 __Unsupported -#define BT_DFLOAT128 __Unsupported -#define BT_DOUBLEPTR double * -#define BT_DOUBLE double -#define BT_FLOATPTR float * -#define BT_FLOAT128X __Unsupported -#define BT_FLOAT128 __Unsupported -#define BT_FLOAT64X __Unsupported -#define BT_FLOAT64 __Unsupported -#define BT_FLOAT32X __Unsupported -#define BT_FLOAT32 __Unsupported -#define BT_FLOAT16 __Unsupported -#define BT_FLOAT float -#define BT_CONST_VPTR const volatile void * -#define BT_CONST_PTR const void * -#define BT_CONST_STRING const char * -#define BT_CONST_TM_PTR const struct tm * -#define BT_PTR_FN_VOID_VAR_PTR_SIZE -#define BT_PTR_CONST_STRING char *const -#define BT_PTRMODE_PTR -#define BT_PTRPTR void ** -#define BT_VPTR volatile void * -#define BT_PTR void * -#define BT_VOID void -#define BT_STRING char * -#define BT_FILEPTR struct _IO_FILE * -#define BT_SIZE unsigned long -#define BT_VAR ... -#define BT_VALIST_ARG __builtin_va_list -#define BT_VALIST_REF __builtin_va_list -#define BT_UNWINDWORD void * -#define BT_WORD -#define BT_SSIZE long int -#define BT_PID int -#define BT_I16 __int128 -#define BT_I8 long long int -#define BT_I4 int -#define BT_I2 short -#define BT_I1 char - -#define BT_FN_INT_INT_INT_INT_INT_INT_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_INT, BT_INT, BT_INT, BT_INT, BT_INT, BT_VAR) -#define BT_FN_INT_LONG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_LONG) -#define BT_FN_SIZE_STRING_SIZE_CONST_STRING_CONST_PTR(NAME) FUNC_SIMPLE(BT_SIZE, NAME, BT_STRING, BT_SIZE, BT_CONST_STRING, BT_CONST_PTR) -#define BT_FN_VOID_VPTR_I4_INT(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_VPTR, BT_I4, BT_INT) -#define BT_FN_I1_VPTR_I1_INT(NAME) FUNC_SIMPLE(BT_I1, NAME, BT_VPTR, BT_I1, BT_INT) -#define BT_FN_INT(NAME) FUNC_SIMPLE(BT_INT, NAME) -#define BT_FN_STRING_CONST_STRING_CONST_STRING(NAME) FUNC_SIMPLE(BT_STRING, NAME, BT_CONST_STRING, BT_CONST_STRING) -#define BT_FN_PTR_CONST_PTR_SIZE_VAR(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_CONST_PTR, BT_SIZE, BT_VAR) -#define BT_FN_INT_ULONGLONG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_ULONGLONG) -#define BT_FN_INT_CONST_STRING_CONST_STRING_SIZE(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_CONST_STRING, BT_SIZE) -#define BT_FN_INT_CONST_STRING_PTR_CONST_STRING_PTR_CONST_STRING(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_PTR_CONST_STRING, BT_PTR_CONST_STRING) -#define BT_FN_STRING_STRING_CONST_STRING_SIZE(NAME) FUNC_SIMPLE(BT_STRING, NAME, BT_STRING, BT_CONST_STRING, BT_SIZE) -#define BT_FN_VOID_PTR_SIZE(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_PTR, BT_SIZE) -#define BT_FN_INTMAX_INTMAX(NAME) FUNC_SIMPLE(BT_INTMAX, NAME, BT_INTMAX) -#define BT_FN_SIZE_CONST_PTR_SIZE_SIZE_FILEPTR(NAME) FUNC_SIMPLE(BT_SIZE, NAME, BT_CONST_PTR, BT_SIZE, BT_SIZE, BT_FILEPTR) -#define BT_FN_PTR_PTR_CONST_PTR_SIZE_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_PTR, BT_CONST_PTR, BT_SIZE, BT_SIZE) -#define BT_FN_VOID_VALIST_REF_VALIST_ARG(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_VALIST_REF, BT_VALIST_ARG) -#define BT_FN_LONGDOUBLE_CONST_STRING(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_CONST_STRING) -#define BT_FN_LONGLONG_FLOAT(NAME) FUNC_SIMPLE(BT_LONGLONG, NAME, BT_FLOAT) -#define BT_FN_DFLOAT32(NAME) FUNC_SIMPLE(BT_DFLOAT32, NAME) -#define BT_FN_INT_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_LONGDOUBLE) -#define BT_FN_BOOL_VPTR_I2_I2(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_VPTR, BT_I2, BT_I2) -#define BT_FN_FLOAT_FLOAT_FLOATPTR(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_FLOATPTR) -#define BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_LONGDOUBLE, BT_LONGDOUBLE, BT_LONGDOUBLE) -#define BT_FN_VOID_PTR_INT(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_PTR, BT_INT) -#define BT_FN_LONG_LONG(NAME) FUNC_SIMPLE(BT_LONG, NAME, BT_LONG) -#define BT_FN_INT_DOUBLE(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_DOUBLE) -#define BT_FN_BOOL_VPTR_PTR_I16_BOOL_INT_INT(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_VPTR, BT_PTR, BT_I16, BT_BOOL, BT_INT, BT_INT) -#define BT_FN_UINT(NAME) FUNC_SIMPLE(BT_UINT, NAME) -#define BT_FN_DOUBLE_DOUBLE_INT(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_INT) -#define BT_FN_VOID_LONGDOUBLE_LONGDOUBLEPTR_LONGDOUBLEPTR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_LONGDOUBLE, BT_LONGDOUBLEPTR, BT_LONGDOUBLEPTR) -#define BT_FN_INT_INT_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_INT, BT_CONST_STRING, BT_VAR) -#define BT_FN_BOOL_INT_INT_INTPTR(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_INT, BT_INT, BT_INTPTR) -#define BT_FN_DFLOAT32_DFLOAT32(NAME) FUNC_SIMPLE(BT_DFLOAT32, NAME, BT_DFLOAT32) -#define BT_FN_VOID_VAR(NAME) FUNC_SIMPLE(BT_VOID, NAME) -#define BT_FN_INT_CONST_STRING_FILEPTR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_FILEPTR) -#define BT_FN_VOID_INT(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_INT) -#define BT_FN_DFLOAT128_CONST_STRING(NAME) FUNC_SIMPLE(BT_DFLOAT128, NAME, BT_CONST_STRING) -#define BT_FN_BOOL_VPTR_I16_I16(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_VPTR, BT_I16, BT_I16) -#define BT_FN_BOOL_LONG_LONG_LONGPTR(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_LONG, BT_LONG, BT_LONG, BT_PTR) -#define BT_FN_INT_DFLOAT64(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_DFLOAT64) -#define BT_FN_LONG_FLOAT(NAME) FUNC_SIMPLE(BT_LONG, NAME, BT_FLOAT) -#define BT_FN_CONST_STRING(NAME) FUNC_SIMPLE(BT_CONST_STRING, NAME) -#define BT_FN_SIZE_CONST_STRING_CONST_STRING(NAME) FUNC_SIMPLE(BT_SIZE, NAME, BT_CONST_STRING, BT_CONST_STRING) -#define BT_FN_COMPLEX_FLOAT_FLOAT(NAME) FUNC_SIMPLE(BT_COMPLEX_FLOAT, NAME, BT_FLOAT) -#define BT_FN_VOID_SIZE_VPTR_PTR_PTR_INT(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_SIZE, BT_VPTR, BT_PTR, BT_PTR, BT_INT) -#define BT_FN_STRING_CONST_STRING_CONST_STRING_INT(NAME) FUNC_SIMPLE(BT_STRING, NAME, BT_CONST_STRING, BT_CONST_STRING, BT_INT) -#define BT_FN_INT_CONST_STRING_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_CONST_STRING, BT_VAR) -#define BT_FN_LONGDOUBLE_LONGDOUBLE_INT(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_LONGDOUBLE, BT_INT) -#define BT_FN_BOOL_VPTR_I1_I1(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_VPTR, BT_I1, BT_I1) -#define BT_FN_DOUBLE_DOUBLE_DOUBLEPTR(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_DOUBLEPTR) -#define BT_FN_DOUBLE_DOUBLE_DOUBLE(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_DOUBLE) -#define BT_FN_LONGDOUBLE_LONGDOUBLE_LONG(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_LONGDOUBLE, BT_LONG) -#define BT_FN_I16_VPTR_I16_INT(NAME) FUNC_SIMPLE(BT_I16, NAME, BT_VPTR, BT_I16, BT_INT) -#define BT_FN_INT_STRING_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_CONST_STRING, BT_VALIST_ARG) -#define BT_FN_INT_STRING_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_CONST_STRING, BT_VAR) -#define BT_FN_UINT64_UINT64(NAME) FUNC_SIMPLE(BT_UINT64, NAME, BT_UINT64) -#define BT_FN_BOOL_VPTR_PTR_I2_BOOL_INT_INT(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_VPTR, BT_PTR, BT_I2, BT_BOOL, BT_INT, BT_INT) -#define BT_FN_PTR_PTR_CONST_PTR_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_PTR, BT_CONST_PTR, BT_SIZE) -#define BT_FN_STRING_CONST_STRING_INT(NAME) FUNC_SIMPLE(BT_STRING, NAME, BT_CONST_STRING, BT_INT) -#define BT_FN_FLOAT_FLOAT_LONG(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_LONG) -#define BT_FN_FLOAT_CONST_STRING(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_CONST_STRING) -#define BT_FN_FLOAT_FLOAT_INTPTR(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_INTPTR) -#define BT_FN_INT_STRING_SIZE_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_SIZE, BT_CONST_STRING, BT_VALIST_ARG) -#define BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_COMPLEX_LONGDOUBLE, NAME, BT_COMPLEX_LONGDOUBLE, BT_COMPLEX_LONGDOUBLE) -#define BT_FN_INT_LONGLONG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_LONGLONG) -#define BT_FN_DOUBLE_DOUBLE_DOUBLE_DOUBLE(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_DOUBLE, BT_DOUBLE) -#define BT_FN_PTR_PTR(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_PTR) -#define BT_FN_I1_VPTR_I1_I1(NAME) FUNC_SIMPLE(BT_I1, NAME, BT_VPTR, BT_I1, BT_I1) -#define BT_FN_LONGDOUBLE_COMPLEX_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_COMPLEX_LONGDOUBLE) -#define BT_FN_FLOAT_FLOAT_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_LONGDOUBLE) -#define BT_FN_DOUBLE_CONST_STRING(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_CONST_STRING) -#define BT_FN_DFLOAT128(NAME) FUNC_SIMPLE(BT_DFLOAT128, NAME) -#define BT_FN_I16_CONST_VPTR_INT(NAME) FUNC_SIMPLE(BT_I16, NAME, BT_CONST_VPTR, BT_INT) -#define BT_FN_FLOAT_FLOAT_FLOAT_FLOAT(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_FLOAT, BT_FLOAT) -#define BT_FN_INT_STRING_INT_SIZE_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_INT, BT_SIZE, BT_CONST_STRING, BT_VAR) -#define BT_FN_SIZE_CONST_PTR_INT(NAME) FUNC_SIMPLE(BT_SIZE, NAME, BT_CONST_PTR, BT_INT) -#define BT_FN_DOUBLE_DOUBLE_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_LONGDOUBLE) -#define BT_FN_LONG_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONG, NAME, BT_LONGDOUBLE) -#define BT_FN_BOOL_SIZE_CONST_VPTR(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_SIZE, BT_CONST_VPTR) -#define BT_FN_I16_VPTR_I16(NAME) FUNC_SIMPLE(BT_I16, NAME, BT_VPTR, BT_I16) -#define BT_FN_VOID_VPTR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_VPTR) -#define BT_FN_DOUBLE(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME) -#define BT_FN_VOID_PTRMODE_PTR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_PTRMODE_PTR) -#define BT_FN_WINT_WINT(NAME) FUNC_SIMPLE(BT_WINT, NAME, BT_WINT) -#define BT_FN_BOOL_VPTR_I8_I8(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_VPTR, BT_I8, BT_I8) -#define BT_FN_LONGDOUBLE_LONGDOUBLE_INTPTR(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_LONGDOUBLE, BT_INTPTR) -#define BT_FN_DOUBLE_DOUBLE_INTPTR(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_INTPTR) -#define BT_FN_FLOAT_COMPLEX_FLOAT(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_COMPLEX_FLOAT) -#define BT_FN_BOOL_VPTR_PTR_I8_BOOL_INT_INT(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_VPTR, BT_PTR, BT_I8, BT_BOOL, BT_INT, BT_INT) -#define BT_FN_I4_CONST_VPTR_INT(NAME) FUNC_SIMPLE(BT_I4, NAME, BT_CONST_VPTR, BT_INT) -#define BT_FN_INT_WINT(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_WINT) -#define BT_FN_VOID_DOUBLE_DOUBLEPTR_DOUBLEPTR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_DOUBLE, BT_DOUBLEPTR, BT_DOUBLEPTR) -#define BT_FN_I8_VPTR_I8_INT(NAME) FUNC_SIMPLE(BT_I8, NAME, BT_VPTR, BT_I8, BT_INT) -#define BT_FN_VOID_PTR_WORD_WORD_PTR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_PTR, BT_WORD, BT_WORD, BT_PTR) -#define BT_FN_I4_VPTR_I4_I4(NAME) FUNC_SIMPLE(BT_I4, NAME, BT_VPTR, BT_I4, BT_I4) -#define BT_FN_PTR_CONST_PTR_INT_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_CONST_PTR, BT_INT, BT_SIZE) -#define BT_FN_INT_UINTMAX(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_UINTMAX) -#define BT_FN_BOOL_ULONGLONG_ULONGLONG_ULONGLONGPTR(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_ULONGLONG, BT_ULONGLONG, BT_ULONGLONG, BT_PTR) -#define BT_FN_LONGLONG_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONGLONG, NAME, BT_LONGDOUBLE) -#define BT_FN_FLOAT_FLOAT(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT) -#define BT_FN_INT_INT_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_INT, BT_CONST_STRING, BT_VALIST_ARG) -#define BT_FN_STRING_STRING_CONST_STRING_SIZE_SIZE(NAME) FUNC_SIMPLE(BT_STRING, NAME, BT_STRING, BT_CONST_STRING, BT_SIZE, BT_SIZE) -#define BT_FN_INT_DFLOAT128(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_DFLOAT128) -#define BT_FN_PTR_PTR_FN_VOID_VAR_PTR_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_PTR_FN_VOID_VAR_PTR_SIZE) -#define BT_FN_PTR_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_SIZE) -#define BT_FN_DFLOAT32_CONST_STRING(NAME) FUNC_SIMPLE(BT_DFLOAT32, NAME, BT_CONST_STRING) -#define BT_FN_LONG_LONG_LONG(NAME) FUNC_SIMPLE(BT_LONG, NAME, BT_LONG, BT_LONG) -#define BT_FN_VOID_VPTR_I8_INT(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_VPTR, BT_I8, BT_INT) -#define BT_FN_INT_STRING_SIZE_INT_SIZE_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_SIZE, BT_INT, BT_SIZE, BT_CONST_STRING, BT_VAR) -#define BT_FN_BOOL_VAR(NAME) FUNC_SIMPLE(BT_BOOL, NAME) -#define BT_FN_INT_FILEPTR_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_FILEPTR, BT_CONST_STRING, BT_VAR) -#define BT_FN_COMPLEX_DOUBLE_DOUBLE(NAME) FUNC_SIMPLE(BT_COMPLEX_DOUBLE, NAME, BT_DOUBLE) -#define BT_FN_INT_ULONG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_ULONG) -#define BT_FN_STRING_CONST_STRING_SIZE(NAME) FUNC_SIMPLE(BT_STRING, NAME, BT_CONST_STRING, BT_SIZE) -#define BT_FN_VOID(NAME) FUNC_SIMPLE(BT_VOID, NAME) -#define BT_FN_INT_DFLOAT32(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_DFLOAT32) -#define BT_FN_VOID_SIZE_CONST_VPTR_PTR_INT(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_SIZE, BT_CONST_VPTR, BT_PTR, BT_INT) -#define BT_FN_UNWINDWORD_PTR(NAME) FUNC_SIMPLE(BT_UNWINDWORD, NAME, BT_PTR) -#define BT_FN_I1_CONST_VPTR_INT(NAME) FUNC_SIMPLE(BT_I1, NAME, BT_CONST_VPTR, BT_INT) -#define BT_FN_INT_STRING_SIZE_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_SIZE, BT_CONST_STRING, BT_VAR) -#define BT_FN_STRING_CONST_STRING(NAME) FUNC_SIMPLE(BT_STRING, NAME, BT_CONST_STRING) -#define BT_FN_PTR_SIZE_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_SIZE, BT_SIZE) -#define BT_FN_VOID_VPTR_INT(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_VPTR, BT_INT) -#define BT_FN_FLOAT(NAME) FUNC_SIMPLE(BT_FLOAT, NAME) -#define BT_FN_PTR_VAR(NAME) FUNC_SIMPLE(BT_PTR, NAME) -#define BT_FN_I8_CONST_VPTR_INT(NAME) FUNC_SIMPLE(BT_I8, NAME, BT_CONST_VPTR, BT_INT) -#define BT_FN_LONG_DOUBLE(NAME) FUNC_SIMPLE(BT_LONG, NAME, BT_DOUBLE) -#define BT_FN_LONGLONG_DOUBLE(NAME) FUNC_SIMPLE(BT_LONGLONG, NAME, BT_DOUBLE) -#define BT_FN_BOOL_VPTR_PTR_I4_BOOL_INT_INT(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_VPTR, BT_PTR, BT_I4, BT_BOOL, BT_INT, BT_INT) -#define BT_FN_VOID_CONST_PTR_VAR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_CONST_PTR, BT_VAR) -#define BT_FN_DOUBLE_DOUBLE_LONG(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_LONG) -#define BT_FN_DOUBLE_DOUBLE_DOUBLE_INTPTR(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_DOUBLE, BT_INTPTR) -#define BT_FN_LONGDOUBLE_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_LONGDOUBLE) -#define BT_FN_INT_PTR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_PTR) -#define BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE_INTPTR(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_LONGDOUBLE, BT_LONGDOUBLE, BT_INTPTR) -#define BT_FN_BOOL_VPTR_INT(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_VPTR, BT_INT) -#define BT_FN_INT_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_VALIST_ARG) -#define BT_FN_DOUBLE_COMPLEX_DOUBLE(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_COMPLEX_DOUBLE) -#define BT_FN_DOUBLE_DOUBLE(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE) -#define BT_FN_I2_VPTR_I2_INT(NAME) FUNC_SIMPLE(BT_I2, NAME, BT_VPTR, BT_I2, BT_INT) -#define BT_FN_INT_INT_FILEPTR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_INT, BT_FILEPTR) -#define BT_FN_DFLOAT64_DFLOAT64(NAME) FUNC_SIMPLE(BT_DFLOAT64, NAME, BT_DFLOAT64) -#define BT_FN_I8_VPTR_I8(NAME) FUNC_SIMPLE(BT_I8, NAME, BT_VPTR, BT_I8) -#define BT_FN_DOUBLE_INT_DOUBLE(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_INT, BT_DOUBLE) -#define BT_FN_I16_VPTR_I16_I16(NAME) FUNC_SIMPLE(BT_I16, NAME, BT_VPTR, BT_I16, BT_I16) -#define BT_FN_VOID_VPTR_I16_INT(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_VPTR, BT_I16, BT_INT) -#define BT_FN_VOID_VPTR_I1_INT(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_VPTR, BT_I1, BT_INT) -#define BT_FN_DFLOAT64(NAME) FUNC_SIMPLE(BT_DFLOAT64, NAME) -#define BT_FN_FLOAT_INT_FLOAT(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_INT, BT_FLOAT) -#define BT_FN_I2_VPTR_I2_I2(NAME) FUNC_SIMPLE(BT_I2, NAME, BT_VPTR, BT_I2, BT_I2) -#define BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT(NAME) FUNC_SIMPLE(BT_COMPLEX_FLOAT, NAME, BT_COMPLEX_FLOAT) -#define BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_LONGDOUBLE, BT_LONGDOUBLE) -#define BT_FN_VOID_VALIST_REF_VAR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_VALIST_REF, BT_VAR) -#define BT_FN_UINT32_UINT32(NAME) FUNC_SIMPLE(BT_UINT32, NAME, BT_UINT32) -#define BT_FN_FLOAT_FLOAT_FLOAT(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_FLOAT) -#define BT_FN_INT_STRING_INT_SIZE_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_INT, BT_SIZE, BT_CONST_STRING, BT_VALIST_ARG) -#define BT_FN_INT_CONST_PTR_CONST_PTR_SIZE(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_PTR, BT_CONST_PTR, BT_SIZE) -#define BT_FN_PTR(NAME) FUNC_SIMPLE(BT_PTR, NAME) -#define BT_FN_FLOAT_FLOAT_INT(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_INT) -#define BT_FN_INT_UINT(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_UINT) -#define BT_FN_SIZE_CONST_STRING(NAME) FUNC_SIMPLE(BT_SIZE, NAME, BT_CONST_STRING) -#define BT_FN_PTR_PTR_INT_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_PTR, BT_INT, BT_SIZE) -#define BT_FN_I2_VPTR_I2(NAME) FUNC_SIMPLE(BT_I2, NAME, BT_VPTR, BT_I2) -#define BT_FN_UINT16_UINT16(NAME) FUNC_SIMPLE(BT_UINT16, NAME, BT_UINT16) -#define BT_FN_INT_INTMAX(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_INTMAX) -#define BT_FN_VOID_PTR_PTR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_PTR, BT_PTR) -#define BT_FN_STRING_STRING_CONST_STRING(NAME) FUNC_SIMPLE(BT_STRING, NAME, BT_STRING, BT_CONST_STRING) -#define BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE_COMPLEX_DOUBLE(NAME) FUNC_SIMPLE(BT_COMPLEX_DOUBLE, NAME, BT_COMPLEX_DOUBLE, BT_COMPLEX_DOUBLE) -#define BT_FN_I2_CONST_VPTR_INT(NAME) FUNC_SIMPLE(BT_I2, NAME, BT_CONST_VPTR, BT_INT) -#define BT_FN_I1_VPTR_I1(NAME) FUNC_SIMPLE(BT_I1, NAME, BT_VPTR, BT_I1) -#define BT_FN_LONGLONG_LONGLONG(NAME) FUNC_SIMPLE(BT_LONGLONG, NAME, BT_LONGLONG) -#define BT_FN_PID(NAME) FUNC_SIMPLE(BT_PID, NAME) -#define BT_FN_I4_VPTR_I4(NAME) FUNC_SIMPLE(BT_I4, NAME, BT_VPTR, BT_I4) -#define BT_FN_I8_VPTR_I8_I8(NAME) FUNC_SIMPLE(BT_I8, NAME, BT_VPTR, BT_I8, BT_I8) -#define BT_FN_VOID_PTR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_PTR) -#define BT_FN_VOID_VPTR_I2_INT(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_VPTR, BT_I2, BT_INT) -#define BT_FN_VOID_SIZE_VPTR_PTR_INT(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_SIZE, BT_VPTR, BT_PTR, BT_INT) -#define BT_FN_VOID_VALIST_REF(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_VALIST_REF) -#define BT_FN_INT_PTRPTR_SIZE_SIZE(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_PTRPTR, BT_SIZE, BT_SIZE) -#define BT_FN_INT_CONST_STRING_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_CONST_STRING, BT_VALIST_ARG) -#define BT_FN_INT_CONST_STRING(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING) -#define BT_FN_INT_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_VAR) -#define BT_FN_DFLOAT64_CONST_STRING(NAME) FUNC_SIMPLE(BT_DFLOAT64, NAME, BT_CONST_STRING) -#define BT_FN_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME) -#define BT_FN_PTR_PTR_INT_SIZE_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_PTR, BT_INT, BT_SIZE, BT_SIZE) -#define BT_FN_INT_CONST_STRING_CONST_STRING(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_CONST_STRING) -#define BT_FN_COMPLEX_LONGDOUBLE_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_COMPLEX_LONGDOUBLE, NAME, BT_LONGDOUBLE) -#define BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLEPTR(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_LONGDOUBLE, BT_LONGDOUBLEPTR) -#define BT_FN_BOOL_SIZE_VPTR_PTR_PTR_INT_INT(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_SIZE, BT_VPTR, BT_PTR, BT_PTR, BT_INT, BT_INT) -#define BT_FN_BOOL_UINT_UINT_UINTPTR(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_UINT, BT_UINT, BT_UINT, BT_PTR) -#define BT_FN_BOOL_VPTR_I4_I4(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_VPTR, BT_I4, BT_I4) -#define BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT_COMPLEX_FLOAT(NAME) FUNC_SIMPLE(BT_COMPLEX_FLOAT, NAME, BT_COMPLEX_FLOAT, BT_COMPLEX_FLOAT) -#define BT_FN_FLOAT_FLOAT_FLOAT_INTPTR(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_FLOAT, BT_INTPTR) -#define BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE(NAME) FUNC_SIMPLE(BT_COMPLEX_DOUBLE, NAME, BT_COMPLEX_DOUBLE) -#define BT_FN_I4_VPTR_I4_INT(NAME) FUNC_SIMPLE(BT_I4, NAME, BT_VPTR, BT_I4, BT_INT) -#define BT_FN_VOID_CONST_PTR_PTR_SIZE(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_CONST_PTR, BT_PTR, BT_SIZE) -#define BT_FN_DFLOAT128_DFLOAT128(NAME) FUNC_SIMPLE(BT_DFLOAT128, NAME, BT_DFLOAT128) -#define BT_FN_LONGDOUBLE_INT_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_INT, BT_LONGDOUBLE) -#define BT_FN_INT_STRING_SIZE_INT_SIZE_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_SIZE, BT_INT, BT_SIZE, BT_CONST_STRING, BT_VALIST_ARG) -#define BT_FN_INT_FILEPTR_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_FILEPTR, BT_CONST_STRING, BT_VALIST_ARG) -#define BT_FN_INT_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME) -#define BT_FN_INT_CONST_STRING_PTR_CONST_STRING(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_PTR_CONST_STRING) -#define BT_FN_INT_INT(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_INT) -#define BT_FN_VOID_FLOAT_FLOATPTR_FLOATPTR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_FLOAT, BT_FLOATPTR, BT_FLOATPTR) -#define BT_FN_INT_FLOAT(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_FLOAT) -#define BT_FN_INT_FILEPTR_INT_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_FILEPTR, BT_INT, BT_CONST_STRING, BT_VALIST_ARG) -#define BT_FN_INT_FILEPTR_INT_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_FILEPTR, BT_INT, BT_CONST_STRING, BT_VAR) -#define BT_FN_SSIZE_STRING_SIZE_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_SSIZE, NAME, BT_STRING, BT_SIZE, BT_CONST_STRING, BT_VAR) -#define BT_FN_BOOL_LONGLONG_LONGLONG_LONGLONGPTR(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_LONGLONG, BT_LONGLONG, BT_LONGLONG, BT_PTR) -#define BT_FN_PTR_PTR_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_PTR, BT_SIZE) -#define BT_FN_PTR_UINT(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_UINT) -#define BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_COMPLEX_LONGDOUBLE, NAME, BT_COMPLEX_LONGDOUBLE) -#define BT_FN_BOOL_VPTR_PTR_I1_BOOL_INT_INT(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_VPTR, BT_PTR, BT_I1, BT_BOOL, BT_INT, BT_INT) -#define BT_FN_BOOL_ULONG_ULONG_ULONGPTR(NAME) FUNC_SIMPLE(BT_BOOL, NAME, BT_ULONG, BT_ULONG, BT_ULONG, BT_PTR) - -#include "builtins.def" - -extern const char *__PRETTY_FUNCTION__; Index: src/tests/.expect/tupleAssign.txt =================================================================== --- src/tests/.expect/tupleAssign.txt (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/tests/.expect/tupleAssign.txt (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -1,6 +1,12 @@ +u=5 v=6 x=10 y=11 z=[100, 200] u=5 v=6 x=10 y=11 z=[100, 200] u=11 v=10 x=11 y=10 z=[11, 10] +u=11 v=10 x=11 y=10 z=[11, 10] +u=10 v=11 z=[10, 11] u=10 v=11 z=[10, 11] u=123 v=456 z=[111, 222] -d=-2153.12 i=-2153 c=-105 t=[-2153, -2153.12, -2153] -d=-2153.12 i=-2153 c=-105 t=[-2153, -2153.12, -2153] +u=123 v=456 z=[111, 222] +d=94.12 i=94 c=^ t=[94, 94.12, 94] +d=94.12 i=94 c=^ t=[94, 94.12, 94] +d=-94.12 i=-94 c=¢ t=[-94, -94.12, -94] +d=-94.12 i=-94 c=¢ t=[-94, -94.12, -94] Index: src/tests/Makefile.am =================================================================== --- src/tests/Makefile.am (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/tests/Makefile.am (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -30,5 +30,5 @@ EXTRA_FLAGS = CFLAGS = -g -Wall -Wno-unused-function @CFA_FLAGS@ ${EXTRA_FLAGS} -CC = @CFA_BINDIR@/cfa +CC = @CFA_BINDIR@/@CFA_NAME@ .PHONY : list Index: src/tests/Makefile.in =================================================================== --- src/tests/Makefile.in (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/tests/Makefile.in (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -113,5 +113,5 @@ AWK = @AWK@ BACKEND_CC = @BACKEND_CC@ -CC = @CFA_BINDIR@/cfa +CC = @CFA_BINDIR@/@CFA_NAME@ CCAS = @CCAS@ CCASDEPMODE = @CCASDEPMODE@ @@ -123,4 +123,5 @@ CFA_INCDIR = @CFA_INCDIR@ CFA_LIBDIR = @CFA_LIBDIR@ +CFA_NAME = @CFA_NAME@ CFA_PREFIX = @CFA_PREFIX@ CFLAGS = -g -Wall -Wno-unused-function @CFA_FLAGS@ ${EXTRA_FLAGS} Index: src/tests/tupleAssign.c =================================================================== --- src/tests/tupleAssign.c (revision 87c3bef2f36114e3144a18260c66331cd41f4c18) +++ src/tests/tupleAssign.c (revision 3f414ef6d1737bc6e8bd973d98b2964b26c60ba3) @@ -9,8 +9,10 @@ // Author : Rob Schluntz // Created On : Tue Nov 15 17:24:32 2016 -// Last Modified By : Rob Schluntz -// Last Modified On : Tue Nov 15 17:27:28 2016 -// Update Count : 3 +// Last Modified By : Peter A. Buhr +// Last Modified On : Mon Mar 6 21:23:58 2017 +// Update Count : 34 // + +#include int main() { @@ -21,18 +23,21 @@ // swap x, y and store the new [x, y] in [u, v] and in z; - printf("u=%d v=%d x=%d y=%d z=[%d, %d]\n", u, v, x, y, z); + printf( "u=%d v=%d x=%d y=%d z=[%d, %d]\n", u, v, x, y, z ); + sout | "u=" | u | "v=" | v | "x=" | x | "y=" | y | "z=[" | z | "]" | endl; z = [u, v] = [x, y] = [y, x]; - printf("u=%d v=%d x=%d y=%d z=[%d, %d]\n", u, v, x, y, z); + printf( "u=%d v=%d x=%d y=%d z=[%d, %d]\n", u, v, x, y, z ); + sout | "u=" | u | "v=" | v | "x=" | x | "y=" | y | "z=[" | z | "]" | endl; // shuffle elements -- v = z.0, z.0 = z.1, z.1 = u, u = v [v, z, u] = [z, u, v]; - printf("u=%d v=%d z=[%d, %d]\n", u, v, z); + printf( "u=%d v=%d z=[%d, %d]\n", u, v, z ); + sout | "u=" | u | "v=" | v | "z=[" | z | "]" | endl; // multiple assignment with tuple expression on right z = [111, 222]; [u, v] = [123, 456]; - printf("u=%d v=%d z=[%d, %d]\n", u, v, z); + printf( "u=%d v=%d z=[%d, %d]\n", u, v, z ); + sout | "u=" | u | "v=" | v | "z=[" | z | "]" | endl; } - { // test mass assignment @@ -48,8 +53,10 @@ // no conversion from X to integral types, so this serves as a santiy // check that as long as this compiles, ?=?(_, x) is not generated. - [t, x, d, i, c, x] = (double)-2153.12; - printf("d=%lg i=%d c=%d t=[%d, %lg, %d]\n", d, i, (int)c, t); - [x, c, i, d, x, t] = (double)-2153.12; - printf("d=%lg i=%d c=%d t=[%d, %lg, %d]\n", d, i, (int)c, t); + [t, x, d, i, c, x] = (double)94.12; + printf( "d=%lg i=%d c=%c t=[%d, %lg, %d]\n", d, i, (int)c, t ); + sout | "d=" | d | "i=" | i | "c=" | c | ' ' | "t=[" | t | "]" | endl; + [x, c, i, d, x, t] = (double)-94.12; + printf( "d=%lg i=%d c=%c t=[%d, %lg, %d]\n", d, i, c, t ); + sout | "d=" | d | "i=" | i | "c=" | c | ' ' | "t=[" | t | "]" | endl; } }