From 452957a271cc975e2114ac6bbf006e8c7566e858 Mon Sep 17 00:00:00 2001 From: Philipp Paulweber Date: Sun, 30 Jul 2017 10:47:44 +0200 Subject: [PATCH] Implementation Definition * added AST node for implementation definition and its new syntax rules * added new grammar tokens 'implements', 'for', and 'this', which are needed to fully describe the definition and implementation details about implemented structures and/or features (aka. traits) * related to ref #35 --- src/GrammarParser.yy | 57 +- src/GrammarToken.hpp | 3 + src/ast/Definition.cpp | 36 + src/ast/Definition.h | 23 + src/ast/EmptyVisitor.cpp | 4 + src/ast/EmptyVisitor.h | 1 + src/ast/Node.cpp | 4 + src/ast/Node.h | 3 + src/ast/RecursiveVisitor.cpp | 7 + src/ast/RecursiveVisitor.h | 1 + src/ast/Visitor.h | 2 + src/transform/AstDumpSourcePass.cpp | 19 + src/various/Grammar.org | 16 +- src/various/GrammarLexer.cpp | 604 +- src/various/GrammarParser.cpp | 2927 +++--- src/various/GrammarParser.output | 13704 +++++++++++++------------- src/various/GrammarParser.tab.h | 958 +- 17 files changed, 9536 insertions(+), 8833 deletions(-) diff --git a/src/GrammarParser.yy b/src/GrammarParser.yy index 188b763de..1286c5f31 100644 --- a/src/GrammarParser.yy +++ b/src/GrammarParser.yy @@ -175,6 +175,9 @@ END 0 "end of file" %type FeatureDefinition %type FeatureDeclarationOrDefinition %type FeatureDeclarationsAndDefinitions +%type ImplementationDefinition +%type ImplementationDefinitionDefinition +%type ImplementationDefinitionDefinitions %type DeclarationDefinition // expressions @@ -311,6 +314,10 @@ Definition { $$ = $1; } +| ImplementationDefinition + { + $$ = $1; + } | error // error recovery { $$ = nullptr; @@ -587,10 +594,10 @@ FeatureDeclarationOrDefinition FeatureDeclarationsAndDefinitions -: FeatureDeclarationsAndDefinitions COMMA FeatureDeclarationOrDefinition +: FeatureDeclarationsAndDefinitions FeatureDeclarationOrDefinition { auto definitions = $1; - definitions->add( $3 ); + definitions->add( $2 ); $$ = definitions; } | FeatureDeclarationOrDefinition @@ -602,6 +609,48 @@ FeatureDeclarationsAndDefinitions ; +ImplementationDefinition +: IMPLEMENTS IdentifierPath FOR Type EQUAL LCURPAREN ImplementationDefinitionDefinitions RCURPAREN + { + $$ = Ast::make< ImplementationDefinition >( @$, $2, $4, $7 ); + } +| IMPLEMENTS Type EQUAL LCURPAREN ImplementationDefinitionDefinitions RCURPAREN + { + const auto name = Ast::make< Identifier >( @$, "" ); + const auto path = asIdentifierPath( name ); + $$ = Ast::make< ImplementationDefinition >( @$, path, $2, $5 ); + } +; + + +ImplementationDefinitionDefinition +: DerivedDefinition + { + $$ = $1; + } +| RuleDefinition + { + $$ = $1; + } +; + + +ImplementationDefinitionDefinitions +: ImplementationDefinitionDefinitions ImplementationDefinitionDefinition + { + auto definitions = $1; + definitions->add( $2 ); + $$ = definitions; + } +| ImplementationDefinitionDefinition + { + auto definitions = Ast::make< Definitions >( @$ ); + definitions->add( $1 ); + $$ = definitions; + } +; + + DeclarationDefinition : DERIVED Identifier COLON MaybeFunctionParameters MAPS Type { @@ -671,6 +720,10 @@ IdentifierPath { $$ = Ast::make< IdentifierPath >( @$, $2, IdentifierPath::Type::RELATIVE ); } +| THIS DOT DotSeparatedIdentifiers + { + $$ = Ast::make< IdentifierPath >( @$, $3, IdentifierPath::Type::THIS ); + } ; diff --git a/src/GrammarToken.hpp b/src/GrammarToken.hpp index bde87c907..ed51882a8 100644 --- a/src/GrammarToken.hpp +++ b/src/GrammarToken.hpp @@ -37,6 +37,9 @@ DEFINED "defined" { return Parser::make_DEFINED(loc); } STRUCTURE "structure" { return Parser::make_STRUCTURE(loc); } FEATURE "feature" { return Parser::make_FEATURE(loc); } +IMPLEMENTS "implements" { return Parser::make_IMPLEMENTS(loc); } +FOR "for" { return Parser::make_FOR(loc); } +THIS "this" { return Parser::make_THIS(loc); } SEQ "seq" { return Parser::make_SEQ(loc); } ENDSEQ "endseq" { return Parser::make_ENDSEQ(loc); } diff --git a/src/ast/Definition.cpp b/src/ast/Definition.cpp index 2e68a3137..6f8095490 100644 --- a/src/ast/Definition.cpp +++ b/src/ast/Definition.cpp @@ -352,6 +352,42 @@ void FeatureDefinition::accept( Visitor& visitor ) visitor.visit( *this ); } +// +// +// ImplementationDefinition +// + +ImplementationDefinition::ImplementationDefinition( + const IdentifierPath::Ptr& path, + const Type::Ptr& type, + const Definitions::Ptr& definitions ) +: Definition( Node::ID::IMPLEMENTATION_DEFINITION, *path->identifiers()->end() ) +, m_path( path ) +, m_type( type ) +, m_definitions( definitions ) +{ +} + +const IdentifierPath::Ptr& ImplementationDefinition::path( void ) const +{ + return m_path; +} + +const Type::Ptr& ImplementationDefinition::type( void ) const +{ + return m_type; +} + +const Definitions::Ptr& ImplementationDefinition::definitions( void ) const +{ + return m_definitions; +} + +void ImplementationDefinition::accept( Visitor& visitor ) +{ + visitor.visit( *this ); +} + // // // DeclarationDefinition diff --git a/src/ast/Definition.h b/src/ast/Definition.h index 3c231904f..a43e33cb0 100644 --- a/src/ast/Definition.h +++ b/src/ast/Definition.h @@ -251,6 +251,29 @@ namespace libcasm_fe const Definitions::Ptr m_definitions; }; + class ImplementationDefinition final : public Definition + { + public: + using Ptr = std::shared_ptr< ImplementationDefinition >; + + ImplementationDefinition( const IdentifierPath::Ptr& path, + const Type::Ptr& type, + const Definitions::Ptr& definitions ); + + const IdentifierPath::Ptr& path( void ) const; + + const Type::Ptr& type( void ) const; + + const Definitions::Ptr& definitions( void ) const; + + void accept( Visitor& visitor ) override final; + + private: + const IdentifierPath::Ptr m_path; + const Type::Ptr m_type; + const Definitions::Ptr m_definitions; + }; + class DeclarationDefinition final : public Definition { public: diff --git a/src/ast/EmptyVisitor.cpp b/src/ast/EmptyVisitor.cpp index a49f83517..75a2322e9 100644 --- a/src/ast/EmptyVisitor.cpp +++ b/src/ast/EmptyVisitor.cpp @@ -62,6 +62,10 @@ void EmptyVisitor::visit( FeatureDefinition& ) { } +void EmptyVisitor::visit( ImplementationDefinition& ) +{ +} + void EmptyVisitor::visit( DeclarationDefinition& ) { } diff --git a/src/ast/EmptyVisitor.h b/src/ast/EmptyVisitor.h index 9209e106a..4a7834a34 100644 --- a/src/ast/EmptyVisitor.h +++ b/src/ast/EmptyVisitor.h @@ -44,6 +44,7 @@ namespace libcasm_fe void visit( EnumerationDefinition& node ) override; void visit( StructureDefinition& node ) override; void visit( FeatureDefinition& node ) override; + void visit( ImplementationDefinition& node ) override; void visit( DeclarationDefinition& node ) override; void visit( ValueAtom& node ) override; diff --git a/src/ast/Node.cpp b/src/ast/Node.cpp index 46459f63d..16c22dba2 100644 --- a/src/ast/Node.cpp +++ b/src/ast/Node.cpp @@ -85,6 +85,10 @@ std::string Node::description( void ) const { return "feature"; } + case ID::IMPLEMENTATION_DEFINITION: + { + return "implementation"; + } case ID::DECLARATION_DEFINITION: { return "declaration"; diff --git a/src/ast/Node.h b/src/ast/Node.h index 0d69ad7f8..91081ef6a 100644 --- a/src/ast/Node.h +++ b/src/ast/Node.h @@ -57,6 +57,7 @@ namespace libcasm_fe ENUMERATION_DEFINITION, STRUCTURE_DEFINITION, FEATURE_DEFINITION, + IMPLEMENTATION_DEFINITION, DECLARATION_DEFINITION, // expressions @@ -209,6 +210,8 @@ namespace libcasm_fe { ABSOLUTE, /**< absolute namespace + identifier path */ RELATIVE, /**< path started with a dot, needs to be resolved */ + THIS, /**< path started with a 'this' and dot, needs to be + resolved */ }; public: diff --git a/src/ast/RecursiveVisitor.cpp b/src/ast/RecursiveVisitor.cpp index 431f8b276..bfb3a08d1 100644 --- a/src/ast/RecursiveVisitor.cpp +++ b/src/ast/RecursiveVisitor.cpp @@ -90,6 +90,13 @@ void RecursiveVisitor::visit( FeatureDefinition& node ) node.definitions()->accept( *this ); } +void RecursiveVisitor::visit( ImplementationDefinition& node ) +{ + node.identifier()->accept( *this ); + node.type()->accept( *this ); + node.definitions()->accept( *this ); +} + void RecursiveVisitor::visit( DeclarationDefinition& node ) { node.identifier()->accept( *this ); diff --git a/src/ast/RecursiveVisitor.h b/src/ast/RecursiveVisitor.h index 65c536d5d..4bb65e921 100644 --- a/src/ast/RecursiveVisitor.h +++ b/src/ast/RecursiveVisitor.h @@ -44,6 +44,7 @@ namespace libcasm_fe void visit( EnumerationDefinition& node ) override; void visit( StructureDefinition& node ) override; void visit( FeatureDefinition& node ) override; + void visit( ImplementationDefinition& node ) override; void visit( DeclarationDefinition& node ) override; void visit( ValueAtom& node ) override; diff --git a/src/ast/Visitor.h b/src/ast/Visitor.h index d640cbf39..b61273472 100644 --- a/src/ast/Visitor.h +++ b/src/ast/Visitor.h @@ -39,6 +39,7 @@ namespace libcasm_fe class EnumerationDefinition; class StructureDefinition; class FeatureDefinition; + class ImplementationDefinition; class DeclarationDefinition; class ValueAtom; @@ -99,6 +100,7 @@ namespace libcasm_fe virtual void visit( EnumerationDefinition& node ) = 0; virtual void visit( StructureDefinition& node ) = 0; virtual void visit( FeatureDefinition& node ) = 0; + virtual void visit( ImplementationDefinition& node ) = 0; virtual void visit( DeclarationDefinition& node ) = 0; virtual void visit( ValueAtom& node ) = 0; diff --git a/src/transform/AstDumpSourcePass.cpp b/src/transform/AstDumpSourcePass.cpp index 67b437ff9..3aeb03e70 100644 --- a/src/transform/AstDumpSourcePass.cpp +++ b/src/transform/AstDumpSourcePass.cpp @@ -132,6 +132,7 @@ class AstDumpSourceVisitor final : public Visitor void visit( EnumerationDefinition& node ) override; void visit( StructureDefinition& node ) override; void visit( FeatureDefinition& node ) override; + void visit( ImplementationDefinition& node ) override; void visit( DeclarationDefinition& node ) override; void visit( ValueAtom& node ) override; @@ -352,6 +353,24 @@ void AstDumpSourceVisitor::visit( FeatureDefinition& node ) m_stream << "}"; } +void AstDumpSourceVisitor::visit( ImplementationDefinition& node ) +{ + m_stream << "implements "; + if( node.identifier()->name() != "" ) + { + node.identifier()->accept( *this ); + m_stream << " for "; + } + node.type()->accept( *this ); + m_stream << " =\n{"; + for( auto& e : *node.definitions() ) + { + m_stream << "\n "; + e->accept( *this ); + } + m_stream << "}"; +} + void AstDumpSourceVisitor::visit( DeclarationDefinition& node ) { m_stream << " "; diff --git a/src/various/Grammar.org b/src/various/Grammar.org index 289464fdc..37ec003ac 100644 --- a/src/various/Grammar.org +++ b/src/various/Grammar.org @@ -9,6 +9,7 @@ Definition | EnumerationDefinition | StructureDefinition | FeatureDefinition +| ImplementationDefinition | error // error recovery AttributedDefinition @@ -78,9 +79,21 @@ FeatureDeclarationOrDefinition | RuleDefinition FeatureDeclarationsAndDefinitions -: FeatureDeclarationsAndDefinitions COMMA FeatureDeclarationOrDefinition +: FeatureDeclarationsAndDefinitions FeatureDeclarationOrDefinition | FeatureDeclarationOrDefinition +ImplementationDefinition +: IMPLEMENTS IdentifierPath FOR Type EQUAL LCURPAREN ImplementationDefinitionDefinitions RCURPAREN +| IMPLEMENTS Type EQUAL LCURPAREN ImplementationDefinitionDefinitions RCURPAREN + +ImplementationDefinitionDefinition +: DerivedDefinition +| RuleDefinition + +ImplementationDefinitionDefinitions +: ImplementationDefinitionDefinitions ImplementationDefinitionDefinition +| ImplementationDefinitionDefinition + DeclarationDefinition : DERIVED Identifier COLON MaybeFunctionParameters MAPS Type | RULE Identifier COLON MaybeFunctionParameters MAPS Type @@ -100,6 +113,7 @@ DotSeparatedIdentifiers IdentifierPath : DotSeparatedIdentifiers %prec ABSOLUTE_PATH | DOT DotSeparatedIdentifiers +| THIS DOT DotSeparatedIdentifiers Variable : Identifier COLON Type diff --git a/src/various/GrammarLexer.cpp b/src/various/GrammarLexer.cpp index 1d89247f0..5d1e98e9f 100644 --- a/src/various/GrammarLexer.cpp +++ b/src/various/GrammarLexer.cpp @@ -322,8 +322,8 @@ int yyFlexLexer::yylex() (yy_hold_char) = *yy_cp; \ *yy_cp = '\0'; \ (yy_c_buf_p) = yy_cp; -#define YY_NUM_RULES 94 -#define YY_END_OF_BUFFER 95 +#define YY_NUM_RULES 97 +#define YY_END_OF_BUFFER 98 /* This struct is not used in this scanner, but its presence is necessary. */ struct yy_trans_info @@ -331,35 +331,36 @@ struct yy_trans_info flex_int32_t yy_verify; flex_int32_t yy_nxt; }; -static const flex_int16_t yy_accept[250] = +static const flex_int16_t yy_accept[258] = { 0, - 0, 0, 0, 0, 0, 0, 86, 86, 95, 93, - 76, 77, 93, 85, 62, 64, 48, 49, 60, 45, - 57, 46, 66, 61, 4, 4, 54, 58, 47, 59, - 56, 75, 75, 50, 51, 63, 55, 75, 75, 75, - 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, - 75, 75, 75, 75, 52, 93, 53, 79, 80, 84, - 83, 84, 84, 86, 87, 92, 94, 76, 77, 70, - 67, 65, 81, 78, 4, 0, 4, 0, 0, 0, - 69, 71, 68, 72, 75, 75, 75, 75, 75, 75, - 26, 75, 75, 75, 75, 75, 75, 75, 75, 28, - - 75, 22, 75, 75, 75, 32, 41, 75, 75, 75, - 75, 75, 75, 75, 75, 75, 75, 73, 74, 84, - 84, 82, 86, 90, 91, 88, 89, 4, 5, 1, - 3, 2, 75, 40, 75, 75, 75, 75, 75, 75, - 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, - 75, 21, 44, 18, 75, 16, 75, 75, 75, 75, - 75, 75, 42, 0, 1, 1, 3, 0, 3, 2, - 2, 6, 27, 31, 75, 75, 75, 75, 30, 75, - 75, 9, 75, 75, 75, 75, 75, 75, 75, 7, - 75, 10, 20, 75, 29, 39, 75, 36, 0, 5, - - 3, 75, 75, 75, 75, 75, 75, 75, 38, 75, - 75, 75, 34, 75, 75, 75, 75, 37, 3, 3, - 24, 75, 75, 75, 19, 17, 35, 75, 23, 75, - 75, 75, 75, 75, 33, 13, 8, 15, 75, 43, - 75, 25, 75, 11, 75, 75, 12, 14, 0 + 0, 0, 0, 0, 0, 0, 89, 89, 98, 96, + 79, 80, 96, 88, 65, 67, 51, 52, 63, 48, + 60, 49, 69, 64, 4, 4, 57, 61, 50, 62, + 59, 78, 78, 53, 54, 66, 58, 78, 78, 78, + 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, + 78, 78, 78, 78, 55, 96, 56, 82, 83, 87, + 86, 87, 87, 89, 90, 95, 97, 79, 80, 73, + 70, 68, 84, 81, 4, 0, 4, 0, 0, 0, + 72, 74, 71, 75, 78, 78, 78, 78, 78, 78, + 29, 78, 78, 78, 78, 78, 78, 78, 78, 31, + + 78, 25, 78, 78, 78, 35, 44, 78, 78, 78, + 78, 78, 78, 78, 78, 78, 78, 76, 77, 87, + 87, 85, 89, 93, 94, 91, 92, 4, 5, 1, + 3, 2, 78, 43, 78, 78, 78, 78, 78, 78, + 78, 78, 78, 78, 78, 17, 78, 78, 78, 78, + 78, 24, 47, 21, 78, 19, 78, 78, 78, 78, + 78, 78, 78, 45, 0, 1, 1, 3, 0, 3, + 2, 2, 6, 30, 34, 78, 78, 78, 78, 33, + 78, 78, 9, 78, 78, 78, 78, 78, 78, 78, + 7, 78, 10, 23, 78, 32, 18, 42, 78, 39, + + 0, 5, 3, 78, 78, 78, 78, 78, 78, 78, + 41, 78, 78, 78, 37, 78, 78, 78, 78, 78, + 40, 3, 3, 27, 78, 78, 78, 22, 20, 38, + 78, 26, 78, 78, 78, 78, 78, 78, 36, 13, + 8, 15, 78, 78, 46, 78, 28, 78, 11, 78, + 78, 78, 78, 12, 14, 16, 0 } ; static const YY_CHAR yy_ec[256] = @@ -405,71 +406,73 @@ static const YY_CHAR yy_meta[65] = 7, 1, 1, 1 } ; -static const flex_int16_t yy_base[258] = +static const flex_int16_t yy_base[266] = { 0, - 0, 0, 367, 366, 62, 64, 66, 68, 368, 371, - 74, 364, 344, 371, 371, 371, 371, 371, 371, 371, - 371, 342, 349, 66, 97, 71, 341, 340, 338, 338, - 371, 0, 334, 371, 371, 371, 0, 308, 40, 40, - 46, 41, 306, 51, 313, 304, 43, 314, 296, 66, - 54, 302, 305, 299, 286, 284, 371, 371, 371, 343, - 371, 342, 329, 0, 371, 371, 111, 116, 341, 371, - 371, 371, 371, 371, 116, 108, 122, 93, 125, 0, - 371, 371, 371, 371, 0, 310, 300, 73, 290, 49, - 0, 285, 90, 293, 290, 297, 282, 285, 286, 0, - - 281, 286, 288, 274, 273, 0, 0, 274, 279, 273, - 279, 270, 280, 265, 279, 264, 265, 371, 371, 314, - 313, 371, 0, 371, 371, 371, 371, 137, 131, 145, - 160, 308, 284, 0, 266, 270, 261, 106, 265, 267, - 114, 260, 253, 252, 250, 265, 263, 261, 254, 245, - 246, 0, 0, 0, 256, 0, 246, 240, 246, 252, - 251, 248, 0, 168, 173, 175, 180, 153, 186, 284, - 283, 0, 0, 0, 235, 232, 238, 229, 0, 246, - 242, 0, 228, 240, 225, 233, 224, 224, 232, 231, - 236, 0, 0, 234, 0, 0, 230, 0, 189, 192, - - 204, 230, 224, 228, 227, 214, 209, 206, 0, 203, - 206, 174, 0, 176, 177, 160, 158, 0, 207, 210, - 0, 157, 159, 158, 0, 0, 0, 152, 0, 138, - 129, 127, 130, 108, 0, 0, 0, 0, 114, 0, - 111, 0, 104, 0, 77, 93, 0, 0, 371, 229, - 236, 243, 245, 252, 259, 64, 263 + 0, 0, 375, 374, 62, 64, 66, 68, 376, 379, + 74, 372, 352, 379, 379, 379, 379, 379, 379, 379, + 379, 350, 357, 66, 97, 71, 349, 348, 346, 346, + 379, 0, 342, 379, 379, 379, 0, 316, 40, 40, + 46, 41, 314, 51, 321, 312, 43, 322, 304, 66, + 54, 310, 313, 307, 294, 292, 379, 379, 379, 351, + 379, 350, 337, 0, 379, 379, 111, 116, 349, 379, + 379, 379, 379, 379, 116, 108, 122, 93, 125, 0, + 379, 379, 379, 379, 0, 318, 308, 73, 298, 49, + 0, 293, 90, 301, 298, 305, 290, 293, 294, 0, + + 289, 294, 296, 282, 281, 0, 0, 282, 287, 281, + 287, 278, 102, 274, 288, 273, 274, 379, 379, 323, + 322, 379, 0, 379, 379, 379, 379, 141, 135, 138, + 154, 317, 293, 0, 275, 279, 270, 123, 274, 276, + 113, 269, 262, 261, 259, 274, 272, 270, 263, 254, + 255, 0, 0, 0, 265, 0, 255, 249, 255, 249, + 260, 259, 256, 0, 162, 167, 169, 174, 177, 181, + 292, 291, 0, 0, 0, 243, 240, 246, 237, 0, + 254, 250, 0, 236, 248, 233, 241, 232, 232, 158, + 240, 245, 0, 0, 243, 0, 0, 0, 239, 0, + + 188, 191, 194, 239, 233, 237, 236, 224, 224, 221, + 0, 221, 226, 227, 0, 223, 228, 230, 213, 211, + 0, 206, 209, 0, 205, 218, 214, 0, 0, 0, + 210, 0, 171, 178, 165, 171, 175, 159, 0, 0, + 0, 0, 165, 153, 0, 140, 0, 129, 0, 110, + 89, 95, 81, 0, 0, 0, 379, 228, 235, 242, + 244, 251, 258, 64, 262 } ; -static const flex_int16_t yy_def[258] = +static const flex_int16_t yy_def[266] = { 0, - 249, 1, 250, 250, 251, 251, 252, 252, 249, 249, - 249, 249, 249, 249, 249, 249, 249, 249, 249, 249, - 249, 249, 249, 249, 249, 249, 249, 249, 249, 249, - 249, 253, 253, 249, 249, 249, 253, 253, 253, 253, - 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, - 253, 253, 253, 253, 249, 249, 249, 249, 249, 254, - 249, 254, 249, 255, 249, 249, 249, 249, 249, 249, - 249, 249, 249, 249, 249, 249, 249, 249, 249, 256, - 249, 249, 249, 249, 253, 253, 253, 253, 253, 253, - 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, - - 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, - 253, 253, 253, 253, 253, 253, 253, 249, 249, 254, - 254, 249, 255, 249, 249, 249, 249, 249, 249, 249, - 249, 257, 253, 253, 253, 253, 253, 253, 253, 253, - 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, - 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, - 253, 253, 253, 249, 249, 249, 249, 249, 249, 257, - 257, 253, 253, 253, 253, 253, 253, 253, 253, 253, - 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, - 253, 253, 253, 253, 253, 253, 253, 253, 249, 249, - - 249, 253, 253, 253, 253, 253, 253, 253, 253, 253, - 253, 253, 253, 253, 253, 253, 253, 253, 249, 249, - 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, - 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, - 253, 253, 253, 253, 253, 253, 253, 253, 0, 249, - 249, 249, 249, 249, 249, 249, 249 + 257, 1, 258, 258, 259, 259, 260, 260, 257, 257, + 257, 257, 257, 257, 257, 257, 257, 257, 257, 257, + 257, 257, 257, 257, 257, 257, 257, 257, 257, 257, + 257, 261, 261, 257, 257, 257, 261, 261, 261, 261, + 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, + 261, 261, 261, 261, 257, 257, 257, 257, 257, 262, + 257, 262, 257, 263, 257, 257, 257, 257, 257, 257, + 257, 257, 257, 257, 257, 257, 257, 257, 257, 264, + 257, 257, 257, 257, 261, 261, 261, 261, 261, 261, + 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, + + 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, + 261, 261, 261, 261, 261, 261, 261, 257, 257, 262, + 262, 257, 263, 257, 257, 257, 257, 257, 257, 257, + 257, 265, 261, 261, 261, 261, 261, 261, 261, 261, + 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, + 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, + 261, 261, 261, 261, 257, 257, 257, 257, 257, 257, + 265, 265, 261, 261, 261, 261, 261, 261, 261, 261, + 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, + 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, + + 257, 257, 257, 261, 261, 261, 261, 261, 261, 261, + 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, + 261, 257, 257, 261, 261, 261, 261, 261, 261, 261, + 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, + 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, + 261, 261, 261, 261, 261, 261, 0, 257, 257, 257, + 257, 257, 257, 257, 257 } ; -static const flex_int16_t yy_nxt[436] = +static const flex_int16_t yy_nxt[444] = { 0, 10, 11, 12, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 26, 27, @@ -485,43 +488,44 @@ static const flex_int16_t yy_nxt[436] = 102, 67, 139, 67, 75, 94, 103, 114, 110, 130, 130, 76, 111, 77, 77, 77, 124, 68, 125, 68, 135, 112, 78, 75, 129, 129, 129, 136, 79, 75, - 80, 141, 128, 128, 128, 248, 76, 247, 77, 77, - 77, 131, 131, 131, 75, 176, 142, 129, 129, 129, - 79, 177, 165, 128, 128, 128, 80, 246, 245, 164, - 126, 166, 166, 244, 243, 180, 127, 167, 181, 201, - 201, 201, 242, 164, 241, 168, 169, 169, 169, 199, - 165, 199, 165, 240, 200, 200, 200, 167, 239, 166, - 166, 166, 166, 167, 238, 168, 169, 169, 169, 237, - - 236, 168, 169, 169, 169, 200, 200, 200, 200, 200, - 200, 219, 235, 234, 219, 233, 232, 219, 231, 230, - 220, 220, 220, 220, 220, 220, 220, 220, 220, 58, - 58, 58, 58, 58, 58, 58, 60, 60, 60, 60, - 60, 60, 60, 64, 64, 64, 64, 64, 64, 64, - 85, 85, 120, 229, 120, 120, 228, 120, 120, 123, - 227, 226, 123, 123, 123, 123, 171, 225, 171, 224, - 223, 222, 221, 218, 217, 216, 215, 214, 213, 212, - 211, 210, 209, 208, 207, 206, 205, 204, 203, 202, - 170, 170, 198, 197, 196, 195, 194, 193, 192, 191, - - 190, 189, 188, 187, 186, 185, 184, 183, 182, 179, - 178, 175, 174, 173, 172, 170, 121, 121, 163, 162, - 161, 160, 159, 158, 157, 156, 155, 154, 153, 152, - 151, 150, 149, 148, 147, 146, 145, 144, 143, 140, - 137, 134, 133, 69, 122, 121, 121, 119, 118, 117, - 116, 115, 109, 108, 105, 104, 99, 87, 86, 84, - 83, 82, 81, 72, 71, 70, 69, 249, 59, 59, - 9, 249, 249, 249, 249, 249, 249, 249, 249, 249, - 249, 249, 249, 249, 249, 249, 249, 249, 249, 249, - 249, 249, 249, 249, 249, 249, 249, 249, 249, 249, - - 249, 249, 249, 249, 249, 249, 249, 249, 249, 249, - 249, 249, 249, 249, 249, 249, 249, 249, 249, 249, - 249, 249, 249, 249, 249, 249, 249, 249, 249, 249, - 249, 249, 249, 249, 249 + 80, 141, 128, 128, 128, 256, 76, 255, 77, 77, + 77, 131, 131, 131, 159, 166, 142, 160, 75, 254, + 79, 129, 129, 129, 167, 167, 80, 128, 128, 128, + 126, 168, 177, 165, 181, 253, 127, 182, 178, 169, + 170, 170, 170, 201, 166, 201, 166, 165, 202, 202, + 202, 168, 252, 167, 167, 167, 167, 251, 168, 169, + 170, 170, 170, 203, 203, 203, 169, 170, 170, 170, + + 216, 222, 250, 217, 202, 202, 202, 202, 202, 202, + 223, 223, 223, 222, 249, 248, 222, 247, 246, 245, + 244, 243, 223, 223, 223, 223, 223, 223, 58, 58, + 58, 58, 58, 58, 58, 60, 60, 60, 60, 60, + 60, 60, 64, 64, 64, 64, 64, 64, 64, 85, + 85, 120, 242, 120, 120, 241, 120, 120, 123, 240, + 239, 123, 123, 123, 123, 172, 238, 172, 237, 236, + 235, 234, 233, 232, 231, 230, 229, 228, 227, 226, + 225, 224, 221, 220, 219, 218, 215, 214, 213, 212, + 211, 210, 209, 208, 207, 206, 205, 204, 171, 171, + + 200, 199, 198, 197, 196, 195, 194, 193, 192, 191, + 190, 189, 188, 187, 186, 185, 184, 183, 180, 179, + 176, 175, 174, 173, 171, 121, 121, 164, 163, 162, + 161, 158, 157, 156, 155, 154, 153, 152, 151, 150, + 149, 148, 147, 146, 145, 144, 143, 140, 137, 134, + 133, 69, 122, 121, 121, 119, 118, 117, 116, 115, + 109, 108, 105, 104, 99, 87, 86, 84, 83, 82, + 81, 72, 71, 70, 69, 257, 59, 59, 9, 257, + 257, 257, 257, 257, 257, 257, 257, 257, 257, 257, + 257, 257, 257, 257, 257, 257, 257, 257, 257, 257, + + 257, 257, 257, 257, 257, 257, 257, 257, 257, 257, + 257, 257, 257, 257, 257, 257, 257, 257, 257, 257, + 257, 257, 257, 257, 257, 257, 257, 257, 257, 257, + 257, 257, 257, 257, 257, 257, 257, 257, 257, 257, + 257, 257, 257 } ; -static const flex_int16_t yy_chk[436] = +static const flex_int16_t yy_chk[444] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -529,7 +533,7 @@ static const flex_int16_t yy_chk[436] = 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 5, 5, 6, 6, 7, 256, + 1, 1, 1, 1, 5, 5, 6, 6, 7, 264, 8, 7, 5, 8, 6, 11, 24, 11, 26, 39, 42, 24, 40, 42, 39, 26, 47, 26, 26, 26, 40, 42, 90, 41, 44, 41, 47, 42, 51, 44, @@ -537,40 +541,41 @@ static const flex_int16_t yy_chk[436] = 44, 7, 90, 8, 25, 41, 44, 51, 50, 78, 78, 25, 50, 25, 25, 25, 67, 68, 67, 68, 88, 50, 25, 75, 76, 76, 76, 88, 25, 77, - 25, 93, 75, 75, 75, 246, 77, 245, 77, 77, - 77, 79, 79, 79, 128, 138, 93, 129, 129, 129, - 25, 138, 130, 128, 128, 128, 25, 243, 241, 129, - 67, 130, 130, 239, 234, 141, 67, 131, 141, 168, - 168, 168, 233, 129, 232, 131, 131, 131, 131, 164, - 165, 164, 166, 231, 164, 164, 164, 167, 230, 165, - 165, 166, 166, 169, 228, 167, 167, 167, 167, 224, - - 223, 169, 169, 169, 169, 199, 199, 199, 200, 200, - 200, 201, 222, 217, 219, 216, 215, 220, 214, 212, - 201, 201, 201, 219, 219, 219, 220, 220, 220, 250, - 250, 250, 250, 250, 250, 250, 251, 251, 251, 251, - 251, 251, 251, 252, 252, 252, 252, 252, 252, 252, - 253, 253, 254, 211, 254, 254, 210, 254, 254, 255, - 208, 207, 255, 255, 255, 255, 257, 206, 257, 205, - 204, 203, 202, 197, 194, 191, 190, 189, 188, 187, - 186, 185, 184, 183, 181, 180, 178, 177, 176, 175, - 171, 170, 162, 161, 160, 159, 158, 157, 155, 151, - - 150, 149, 148, 147, 146, 145, 144, 143, 142, 140, - 139, 137, 136, 135, 133, 132, 121, 120, 117, 116, - 115, 114, 113, 112, 111, 110, 109, 108, 105, 104, - 103, 102, 101, 99, 98, 97, 96, 95, 94, 92, - 89, 87, 86, 69, 63, 62, 60, 56, 55, 54, - 53, 52, 49, 48, 46, 45, 43, 38, 33, 30, - 29, 28, 27, 23, 22, 13, 12, 9, 4, 3, - 249, 249, 249, 249, 249, 249, 249, 249, 249, 249, - 249, 249, 249, 249, 249, 249, 249, 249, 249, 249, - 249, 249, 249, 249, 249, 249, 249, 249, 249, 249, - - 249, 249, 249, 249, 249, 249, 249, 249, 249, 249, - 249, 249, 249, 249, 249, 249, 249, 249, 249, 249, - 249, 249, 249, 249, 249, 249, 249, 249, 249, 249, - 249, 249, 249, 249, 249 + 25, 93, 75, 75, 75, 253, 77, 252, 77, 77, + 77, 79, 79, 79, 113, 130, 93, 113, 128, 251, + 25, 129, 129, 129, 130, 130, 25, 128, 128, 128, + 67, 131, 138, 129, 141, 250, 67, 141, 138, 131, + 131, 131, 131, 165, 166, 165, 167, 129, 165, 165, + 165, 168, 248, 166, 166, 167, 167, 246, 170, 168, + 168, 168, 168, 169, 169, 169, 170, 170, 170, 170, + + 190, 203, 244, 190, 201, 201, 201, 202, 202, 202, + 203, 203, 203, 222, 243, 238, 223, 237, 236, 235, + 234, 233, 222, 222, 222, 223, 223, 223, 258, 258, + 258, 258, 258, 258, 258, 259, 259, 259, 259, 259, + 259, 259, 260, 260, 260, 260, 260, 260, 260, 261, + 261, 262, 231, 262, 262, 227, 262, 262, 263, 226, + 225, 263, 263, 263, 263, 265, 220, 265, 219, 218, + 217, 216, 214, 213, 212, 210, 209, 208, 207, 206, + 205, 204, 199, 195, 192, 191, 189, 188, 187, 186, + 185, 184, 182, 181, 179, 178, 177, 176, 172, 171, + + 163, 162, 161, 160, 159, 158, 157, 155, 151, 150, + 149, 148, 147, 146, 145, 144, 143, 142, 140, 139, + 137, 136, 135, 133, 132, 121, 120, 117, 116, 115, + 114, 112, 111, 110, 109, 108, 105, 104, 103, 102, + 101, 99, 98, 97, 96, 95, 94, 92, 89, 87, + 86, 69, 63, 62, 60, 56, 55, 54, 53, 52, + 49, 48, 46, 45, 43, 38, 33, 30, 29, 28, + 27, 23, 22, 13, 12, 9, 4, 3, 257, 257, + 257, 257, 257, 257, 257, 257, 257, 257, 257, 257, + 257, 257, 257, 257, 257, 257, 257, 257, 257, 257, + + 257, 257, 257, 257, 257, 257, 257, 257, 257, 257, + 257, 257, 257, 257, 257, 257, 257, 257, 257, 257, + 257, 257, 257, 257, 257, 257, 257, 257, 257, 257, + 257, 257, 257, 257, 257, 257, 257, 257, 257, 257, + 257, 257, 257 } ; /* The intent behind this definition is that it'll catch @@ -622,11 +627,11 @@ using namespace libcasm_fe; // Code run each time a pattern is matched. #define YY_USER_ACTION loc.columns( yyleng ); -#line 625 "src/various/GrammarLexer.cpp" +#line 630 "src/various/GrammarLexer.cpp" /* %option debug */ #define YY_NO_INPUT 1 -#line 629 "src/various/GrammarLexer.cpp" +#line 634 "src/various/GrammarLexer.cpp" #define INITIAL 0 #define LCOMMENT 1 @@ -769,7 +774,7 @@ YY_DECL loc.step(); -#line 772 "src/various/GrammarLexer.cpp" +#line 777 "src/various/GrammarLexer.cpp" while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ { @@ -796,13 +801,13 @@ YY_DECL 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 >= 250 ) + if ( yy_current_state >= 258 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; ++yy_cp; } - while ( yy_current_state != 249 ); + while ( yy_current_state != 257 ); yy_cp = (yy_last_accepting_cpos); yy_current_state = (yy_last_accepting_state); @@ -909,338 +914,353 @@ YY_RULE_SETUP YY_BREAK case 16: YY_RULE_SETUP -#line 100 "obj/src/GrammarLexer.l" -{ return Parser::make_SEQ(loc); } +#line 99 "obj/src/GrammarLexer.l" +{ return Parser::make_IMPLEMENTS(loc); } YY_BREAK case 17: YY_RULE_SETUP -#line 101 "obj/src/GrammarLexer.l" -{ return Parser::make_ENDSEQ(loc); } +#line 100 "obj/src/GrammarLexer.l" +{ return Parser::make_FOR(loc); } YY_BREAK case 18: YY_RULE_SETUP -#line 102 "obj/src/GrammarLexer.l" -{ return Parser::make_PAR(loc); } +#line 101 "obj/src/GrammarLexer.l" +{ return Parser::make_THIS(loc); } YY_BREAK case 19: YY_RULE_SETUP #line 103 "obj/src/GrammarLexer.l" -{ return Parser::make_ENDPAR(loc); } +{ return Parser::make_SEQ(loc); } YY_BREAK case 20: YY_RULE_SETUP -#line 105 "obj/src/GrammarLexer.l" -{ return Parser::make_SKIP(loc); } +#line 104 "obj/src/GrammarLexer.l" +{ return Parser::make_ENDSEQ(loc); } YY_BREAK case 21: YY_RULE_SETUP -#line 106 "obj/src/GrammarLexer.l" -{ return Parser::make_LET(loc); } +#line 105 "obj/src/GrammarLexer.l" +{ return Parser::make_PAR(loc); } YY_BREAK case 22: YY_RULE_SETUP -#line 107 "obj/src/GrammarLexer.l" -{ return Parser::make_IN(loc); } +#line 106 "obj/src/GrammarLexer.l" +{ return Parser::make_ENDPAR(loc); } YY_BREAK case 23: YY_RULE_SETUP #line 108 "obj/src/GrammarLexer.l" -{ return Parser::make_FORALL(loc); } +{ return Parser::make_SKIP(loc); } YY_BREAK case 24: YY_RULE_SETUP #line 109 "obj/src/GrammarLexer.l" -{ return Parser::make_CHOOSE(loc); } +{ return Parser::make_LET(loc); } YY_BREAK case 25: YY_RULE_SETUP #line 110 "obj/src/GrammarLexer.l" -{ return Parser::make_ITERATE(loc); } +{ return Parser::make_IN(loc); } YY_BREAK case 26: YY_RULE_SETUP #line 111 "obj/src/GrammarLexer.l" -{ return Parser::make_DO(loc); } +{ return Parser::make_FORALL(loc); } YY_BREAK case 27: YY_RULE_SETUP #line 112 "obj/src/GrammarLexer.l" -{ return Parser::make_CALL(loc); } +{ return Parser::make_CHOOSE(loc); } YY_BREAK case 28: YY_RULE_SETUP #line 113 "obj/src/GrammarLexer.l" -{ return Parser::make_IF(loc); } +{ return Parser::make_ITERATE(loc); } YY_BREAK case 29: YY_RULE_SETUP #line 114 "obj/src/GrammarLexer.l" -{ return Parser::make_THEN(loc); } +{ return Parser::make_DO(loc); } YY_BREAK case 30: YY_RULE_SETUP #line 115 "obj/src/GrammarLexer.l" -{ return Parser::make_ELSE(loc); } +{ return Parser::make_CALL(loc); } YY_BREAK case 31: YY_RULE_SETUP #line 116 "obj/src/GrammarLexer.l" -{ return Parser::make_CASE(loc); } +{ return Parser::make_IF(loc); } YY_BREAK case 32: YY_RULE_SETUP #line 117 "obj/src/GrammarLexer.l" -{ return Parser::make_OF(loc); } +{ return Parser::make_THEN(loc); } YY_BREAK case 33: YY_RULE_SETUP #line 118 "obj/src/GrammarLexer.l" -{ return Parser::make_DEFAULT(loc); } +{ return Parser::make_ELSE(loc); } YY_BREAK case 34: YY_RULE_SETUP #line 119 "obj/src/GrammarLexer.l" -{ return Parser::make_HOLDS(loc); } +{ return Parser::make_CASE(loc); } YY_BREAK case 35: YY_RULE_SETUP #line 120 "obj/src/GrammarLexer.l" -{ return Parser::make_EXISTS(loc); } +{ return Parser::make_OF(loc); } YY_BREAK case 36: YY_RULE_SETUP #line 121 "obj/src/GrammarLexer.l" -{ return Parser::make_WITH(loc); } +{ return Parser::make_DEFAULT(loc); } YY_BREAK case 37: YY_RULE_SETUP -#line 123 "obj/src/GrammarLexer.l" -{ return Parser::make_UNDEF(loc); } +#line 122 "obj/src/GrammarLexer.l" +{ return Parser::make_HOLDS(loc); } YY_BREAK case 38: YY_RULE_SETUP -#line 124 "obj/src/GrammarLexer.l" -{ return Parser::make_FALSE(loc); } +#line 123 "obj/src/GrammarLexer.l" +{ return Parser::make_EXISTS(loc); } YY_BREAK case 39: YY_RULE_SETUP -#line 125 "obj/src/GrammarLexer.l" -{ return Parser::make_TRUE(loc); } +#line 124 "obj/src/GrammarLexer.l" +{ return Parser::make_WITH(loc); } YY_BREAK case 40: YY_RULE_SETUP -#line 127 "obj/src/GrammarLexer.l" -{ return Parser::make_AND(loc); } +#line 126 "obj/src/GrammarLexer.l" +{ return Parser::make_UNDEF(loc); } YY_BREAK case 41: YY_RULE_SETUP -#line 128 "obj/src/GrammarLexer.l" -{ return Parser::make_OR(loc); } +#line 127 "obj/src/GrammarLexer.l" +{ return Parser::make_FALSE(loc); } YY_BREAK case 42: YY_RULE_SETUP -#line 129 "obj/src/GrammarLexer.l" -{ return Parser::make_XOR(loc); } +#line 128 "obj/src/GrammarLexer.l" +{ return Parser::make_TRUE(loc); } YY_BREAK case 43: YY_RULE_SETUP #line 130 "obj/src/GrammarLexer.l" -{ return Parser::make_IMPLIES(loc); } +{ return Parser::make_AND(loc); } YY_BREAK case 44: YY_RULE_SETUP #line 131 "obj/src/GrammarLexer.l" -{ return Parser::make_NOT(loc); } +{ return Parser::make_OR(loc); } YY_BREAK case 45: YY_RULE_SETUP -#line 133 "obj/src/GrammarLexer.l" -{ return Parser::make_PLUS(loc); } +#line 132 "obj/src/GrammarLexer.l" +{ return Parser::make_XOR(loc); } YY_BREAK case 46: YY_RULE_SETUP -#line 134 "obj/src/GrammarLexer.l" -{ return Parser::make_MINUS(loc); } +#line 133 "obj/src/GrammarLexer.l" +{ return Parser::make_IMPLIES(loc); } YY_BREAK case 47: YY_RULE_SETUP -#line 135 "obj/src/GrammarLexer.l" -{ return Parser::make_EQUAL(loc); } +#line 134 "obj/src/GrammarLexer.l" +{ return Parser::make_NOT(loc); } YY_BREAK case 48: YY_RULE_SETUP #line 136 "obj/src/GrammarLexer.l" -{ return Parser::make_LPAREN(loc); } +{ return Parser::make_PLUS(loc); } YY_BREAK case 49: YY_RULE_SETUP #line 137 "obj/src/GrammarLexer.l" -{ return Parser::make_RPAREN(loc); } +{ return Parser::make_MINUS(loc); } YY_BREAK case 50: YY_RULE_SETUP #line 138 "obj/src/GrammarLexer.l" -{ return Parser::make_LSQPAREN(loc); } +{ return Parser::make_EQUAL(loc); } YY_BREAK case 51: YY_RULE_SETUP #line 139 "obj/src/GrammarLexer.l" -{ return Parser::make_RSQPAREN(loc); } +{ return Parser::make_LPAREN(loc); } YY_BREAK case 52: YY_RULE_SETUP #line 140 "obj/src/GrammarLexer.l" -{ return Parser::make_LCURPAREN(loc); } +{ return Parser::make_RPAREN(loc); } YY_BREAK case 53: YY_RULE_SETUP #line 141 "obj/src/GrammarLexer.l" -{ return Parser::make_RCURPAREN(loc); } +{ return Parser::make_LSQPAREN(loc); } YY_BREAK case 54: YY_RULE_SETUP #line 142 "obj/src/GrammarLexer.l" -{ return Parser::make_COLON(loc); } +{ return Parser::make_RSQPAREN(loc); } YY_BREAK case 55: YY_RULE_SETUP #line 143 "obj/src/GrammarLexer.l" -{ return Parser::make_UNDERLINE(loc); } +{ return Parser::make_LCURPAREN(loc); } YY_BREAK case 56: YY_RULE_SETUP #line 144 "obj/src/GrammarLexer.l" -{ return Parser::make_AT(loc); } +{ return Parser::make_RCURPAREN(loc); } YY_BREAK case 57: YY_RULE_SETUP #line 145 "obj/src/GrammarLexer.l" -{ return Parser::make_COMMA(loc); } +{ return Parser::make_COLON(loc); } YY_BREAK case 58: YY_RULE_SETUP #line 146 "obj/src/GrammarLexer.l" -{ return Parser::make_LESSER(loc); } +{ return Parser::make_UNDERLINE(loc); } YY_BREAK case 59: YY_RULE_SETUP #line 147 "obj/src/GrammarLexer.l" -{ return Parser::make_GREATER(loc); } +{ return Parser::make_AT(loc); } YY_BREAK case 60: YY_RULE_SETUP #line 148 "obj/src/GrammarLexer.l" -{ return Parser::make_ASTERIX(loc); } +{ return Parser::make_COMMA(loc); } YY_BREAK case 61: YY_RULE_SETUP #line 149 "obj/src/GrammarLexer.l" -{ return Parser::make_SLASH(loc); } +{ return Parser::make_LESSER(loc); } YY_BREAK case 62: YY_RULE_SETUP #line 150 "obj/src/GrammarLexer.l" -{ return Parser::make_PERCENT(loc); } +{ return Parser::make_GREATER(loc); } YY_BREAK case 63: YY_RULE_SETUP #line 151 "obj/src/GrammarLexer.l" -{ return Parser::make_CARET(loc); } +{ return Parser::make_ASTERIX(loc); } YY_BREAK case 64: YY_RULE_SETUP #line 152 "obj/src/GrammarLexer.l" -{ return Parser::make_MARK(loc); } +{ return Parser::make_SLASH(loc); } YY_BREAK case 65: YY_RULE_SETUP -#line 154 "obj/src/GrammarLexer.l" -{ return Parser::make_DOTDOT(loc); } +#line 153 "obj/src/GrammarLexer.l" +{ return Parser::make_PERCENT(loc); } YY_BREAK case 66: YY_RULE_SETUP -#line 155 "obj/src/GrammarLexer.l" -{ return Parser::make_DOT(loc); } +#line 154 "obj/src/GrammarLexer.l" +{ return Parser::make_CARET(loc); } YY_BREAK case 67: YY_RULE_SETUP -#line 156 "obj/src/GrammarLexer.l" -{ return Parser::make_MAPS(loc); } +#line 155 "obj/src/GrammarLexer.l" +{ return Parser::make_MARK(loc); } YY_BREAK case 68: YY_RULE_SETUP #line 157 "obj/src/GrammarLexer.l" -{ return Parser::make_ARROW(loc); } +{ return Parser::make_DOTDOT(loc); } YY_BREAK case 69: YY_RULE_SETUP #line 158 "obj/src/GrammarLexer.l" -{ return Parser::make_UPDATE(loc); } +{ return Parser::make_DOT(loc); } YY_BREAK case 70: YY_RULE_SETUP #line 159 "obj/src/GrammarLexer.l" -{ return Parser::make_NEQUAL(loc); } +{ return Parser::make_MAPS(loc); } YY_BREAK case 71: YY_RULE_SETUP #line 160 "obj/src/GrammarLexer.l" -{ return Parser::make_LESSEQ(loc); } +{ return Parser::make_ARROW(loc); } YY_BREAK case 72: YY_RULE_SETUP #line 161 "obj/src/GrammarLexer.l" -{ return Parser::make_GREATEREQ(loc); } +{ return Parser::make_UPDATE(loc); } YY_BREAK case 73: YY_RULE_SETUP #line 162 "obj/src/GrammarLexer.l" -{ return Parser::make_SEQ_BRACKET(loc); } +{ return Parser::make_NEQUAL(loc); } YY_BREAK case 74: YY_RULE_SETUP #line 163 "obj/src/GrammarLexer.l" -{ return Parser::make_ENDSEQ_BRACKET(loc); } +{ return Parser::make_LESSEQ(loc); } YY_BREAK case 75: YY_RULE_SETUP -#line 167 "obj/src/GrammarLexer.l" +#line 164 "obj/src/GrammarLexer.l" +{ return Parser::make_GREATEREQ(loc); } + YY_BREAK +case 76: +YY_RULE_SETUP +#line 165 "obj/src/GrammarLexer.l" +{ return Parser::make_SEQ_BRACKET(loc); } + YY_BREAK +case 77: +YY_RULE_SETUP +#line 166 "obj/src/GrammarLexer.l" +{ return Parser::make_ENDSEQ_BRACKET(loc); } + YY_BREAK +case 78: +YY_RULE_SETUP +#line 170 "obj/src/GrammarLexer.l" { return Parser::make_IDENTIFIER( yytext, loc ); } YY_BREAK -case 76: +case 79: YY_RULE_SETUP -#line 171 "obj/src/GrammarLexer.l" +#line 174 "obj/src/GrammarLexer.l" { // ignore spaces loc.step(); } YY_BREAK -case 77: -/* rule 77 can match eol */ +case 80: +/* rule 80 can match eol */ YY_RULE_SETUP -#line 175 "obj/src/GrammarLexer.l" +#line 178 "obj/src/GrammarLexer.l" { // ignore newlines loc.lines( yyleng ); loc.step(); } YY_BREAK -case 78: +case 81: YY_RULE_SETUP -#line 180 "obj/src/GrammarLexer.l" +#line 183 "obj/src/GrammarLexer.l" { // single-line comments BEGIN( LCOMMENT ); } YY_BREAK -case 79: +case 82: YY_RULE_SETUP -#line 183 "obj/src/GrammarLexer.l" +#line 186 "obj/src/GrammarLexer.l" YY_BREAK -case 80: -/* rule 80 can match eol */ +case 83: +/* rule 83 can match eol */ YY_RULE_SETUP -#line 184 "obj/src/GrammarLexer.l" +#line 187 "obj/src/GrammarLexer.l" { BEGIN( INITIAL ); loc.lines( 1 ); @@ -1248,127 +1268,127 @@ YY_RULE_SETUP } YY_BREAK case YY_STATE_EOF(LCOMMENT): -#line 189 "obj/src/GrammarLexer.l" +#line 192 "obj/src/GrammarLexer.l" { BEGIN( INITIAL ); } YY_BREAK -case 81: +case 84: YY_RULE_SETUP -#line 193 "obj/src/GrammarLexer.l" +#line 196 "obj/src/GrammarLexer.l" { // multi-line comments BEGIN( COMMENT ); } YY_BREAK -case 82: +case 85: YY_RULE_SETUP -#line 196 "obj/src/GrammarLexer.l" +#line 199 "obj/src/GrammarLexer.l" { BEGIN( INITIAL ); } YY_BREAK -case 83: -/* rule 83 can match eol */ +case 86: +/* rule 86 can match eol */ YY_RULE_SETUP -#line 199 "obj/src/GrammarLexer.l" +#line 202 "obj/src/GrammarLexer.l" { loc.lines( 1 ); } YY_BREAK -case 84: +case 87: YY_RULE_SETUP -#line 202 "obj/src/GrammarLexer.l" +#line 205 "obj/src/GrammarLexer.l" YY_BREAK case YY_STATE_EOF(COMMENT): -#line 203 "obj/src/GrammarLexer.l" +#line 206 "obj/src/GrammarLexer.l" { BEGIN( INITIAL ); log.error( {loc}, "multiline comment not terminated", Code::SyntaxErrorUnclosedComment ); yyterminate(); } YY_BREAK -case 85: +case 88: YY_RULE_SETUP -#line 209 "obj/src/GrammarLexer.l" +#line 212 "obj/src/GrammarLexer.l" { // strings BEGIN( STRING ); strbuf.clear(); } YY_BREAK -case 86: +case 89: YY_RULE_SETUP -#line 213 "obj/src/GrammarLexer.l" +#line 216 "obj/src/GrammarLexer.l" { /* eat all tokens */ strbuf.append( yytext ); } YY_BREAK -case 87: -/* rule 87 can match eol */ +case 90: +/* rule 90 can match eol */ YY_RULE_SETUP -#line 216 "obj/src/GrammarLexer.l" +#line 219 "obj/src/GrammarLexer.l" { loc.lines( 1 ); } YY_BREAK -case 88: +case 91: YY_RULE_SETUP -#line 219 "obj/src/GrammarLexer.l" +#line 222 "obj/src/GrammarLexer.l" { strbuf.append( "\n" ); } YY_BREAK -case 89: +case 92: YY_RULE_SETUP -#line 222 "obj/src/GrammarLexer.l" +#line 225 "obj/src/GrammarLexer.l" { strbuf.append( "\t" ); } YY_BREAK -case 90: +case 93: YY_RULE_SETUP -#line 225 "obj/src/GrammarLexer.l" +#line 228 "obj/src/GrammarLexer.l" { strbuf.append( "\"" ); } YY_BREAK -case 91: +case 94: YY_RULE_SETUP -#line 228 "obj/src/GrammarLexer.l" +#line 231 "obj/src/GrammarLexer.l" { strbuf.append( "\'" ); } YY_BREAK case YY_STATE_EOF(STRING): -#line 231 "obj/src/GrammarLexer.l" +#line 234 "obj/src/GrammarLexer.l" { BEGIN( INITIAL ); log.error( {loc}, "string not terminated", Code::SyntaxErrorUnclosedString ); yyterminate(); } YY_BREAK -case 92: +case 95: YY_RULE_SETUP -#line 236 "obj/src/GrammarLexer.l" +#line 239 "obj/src/GrammarLexer.l" { BEGIN( INITIAL ); return Parser::make_STRING( strbuf, loc ); } YY_BREAK -case 93: +case 96: YY_RULE_SETUP -#line 241 "obj/src/GrammarLexer.l" +#line 244 "obj/src/GrammarLexer.l" { log.error( {loc}, "unrecognized character `" + std::string( yytext ) + "`", Code::SyntaxErrorUnrecognizedCharacter ); } YY_BREAK -case 94: +case 97: YY_RULE_SETUP -#line 246 "obj/src/GrammarLexer.l" +#line 249 "obj/src/GrammarLexer.l" YY_FATAL_ERROR( "flex scanner jammed" ); YY_BREAK -#line 1371 "src/various/GrammarLexer.cpp" +#line 1391 "src/various/GrammarLexer.cpp" case YY_STATE_EOF(INITIAL): yyterminate(); @@ -1782,7 +1802,7 @@ int yyFlexLexer::yy_get_next_buffer() 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 >= 250 ) + if ( yy_current_state >= 258 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; @@ -1810,11 +1830,11 @@ int yyFlexLexer::yy_get_next_buffer() 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 >= 250 ) + if ( yy_current_state >= 258 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; - yy_is_jam = (yy_current_state == 249); + yy_is_jam = (yy_current_state == 257); return yy_is_jam ? 0 : yy_current_state; } @@ -2324,7 +2344,7 @@ void yyfree (void * ptr ) #define YYTABLES_NAME "yytables" -#line 246 "obj/src/GrammarLexer.l" +#line 249 "obj/src/GrammarLexer.l" Lexer::Lexer( Logger& log, std::istream& in, std::ostream& out ) diff --git a/src/various/GrammarParser.cpp b/src/various/GrammarParser.cpp index b9e19ce02..f2565d006 100644 --- a/src/various/GrammarParser.cpp +++ b/src/various/GrammarParser.cpp @@ -328,259 +328,265 @@ namespace libcasm_fe { { switch (that.type_get ()) { - case 158: // Attribute + case 164: // Attribute value.move< Attribute::Ptr > (that.value); break; - case 159: // Attributes + case 165: // Attributes value.move< Attributes::Ptr > (that.value); break; - case 160: // BasicAttribute + case 166: // BasicAttribute value.move< BasicAttribute::Ptr > (that.value); break; - case 114: // BasicType + case 120: // BasicType value.move< BasicType::Ptr > (that.value); break; - case 154: // BlockRule + case 160: // BlockRule value.move< BlockRule::Ptr > (that.value); break; - case 157: // CallRule + case 163: // CallRule value.move< CallRule::Ptr > (that.value); break; - case 148: // CaseLabel + case 154: // CaseLabel value.move< Case::Ptr > (that.value); break; - case 147: // CaseRule + case 153: // CaseRule value.move< CaseRule::Ptr > (that.value); break; - case 149: // CaseLabels + case 155: // CaseLabels value.move< Cases::Ptr > (that.value); break; - case 139: // ChooseExpression + case 145: // ChooseExpression value.move< ChooseExpression::Ptr > (that.value); break; - case 152: // ChooseRule + case 158: // ChooseRule value.move< ChooseRule::Ptr > (that.value); break; - case 115: // ComposedType + case 121: // ComposedType value.move< ComposedType::Ptr > (that.value); break; - case 138: // ConditionalExpression + case 144: // ConditionalExpression value.move< ConditionalExpression::Ptr > (that.value); break; - case 146: // ConditionalRule + case 152: // ConditionalRule value.move< ConditionalRule::Ptr > (that.value); break; - case 104: // DeclarationDefinition + case 110: // DeclarationDefinition value.move< DeclarationDefinition::Ptr > (that.value); break; - case 85: // Definition - case 86: // AttributedDefinition - case 102: // FeatureDeclarationOrDefinition + case 88: // Definition + case 89: // AttributedDefinition + case 105: // FeatureDeclarationOrDefinition + case 108: // ImplementationDefinitionDefinition value.move< Definition::Ptr > (that.value); break; - case 87: // Definitions - case 103: // FeatureDeclarationsAndDefinitions + case 90: // Definitions + case 106: // FeatureDeclarationsAndDefinitions + case 109: // ImplementationDefinitionDefinitions value.move< Definitions::Ptr > (that.value); break; - case 98: // DerivedDefinition + case 101: // DerivedDefinition value.move< DerivedDefinition::Ptr > (that.value); break; - case 135: // DirectCallExpression + case 141: // DirectCallExpression value.move< DirectCallExpression::Ptr > (that.value); break; - case 99: // EnumerationDefinition + case 102: // EnumerationDefinition value.move< EnumerationDefinition::Ptr > (that.value); break; - case 141: // ExistentialQuantifierExpression + case 147: // ExistentialQuantifierExpression value.move< ExistentialQuantifierExpression::Ptr > (that.value); break; - case 91: // MaybeDefined - case 119: // Atom - case 128: // Term - case 129: // Expression + case 94: // MaybeDefined + case 125: // Atom + case 134: // Term + case 135: // Expression value.move< Expression::Ptr > (that.value); break; - case 161: // ExpressionAttribute + case 167: // ExpressionAttribute value.move< ExpressionAttribute::Ptr > (that.value); break; - case 132: // Terms - case 133: // Arguments - case 134: // TwoOrMoreArguments + case 138: // Terms + case 139: // Arguments + case 140: // TwoOrMoreArguments value.move< Expressions::Ptr > (that.value); break; - case 101: // FeatureDefinition + case 104: // FeatureDefinition value.move< FeatureDefinition::Ptr > (that.value); break; - case 117: // FixedSizedType + case 123: // FixedSizedType value.move< FixedSizedType::Ptr > (that.value); break; - case 151: // ForallRule + case 157: // ForallRule value.move< ForallRule::Ptr > (that.value); break; - case 88: // FunctionDefinition - case 94: // ProgramFunctionDefinition + case 91: // FunctionDefinition + case 97: // ProgramFunctionDefinition value.move< FunctionDefinition::Ptr > (that.value); break; - case 89: // FunctionDefinitions + case 92: // FunctionDefinitions value.move< FunctionDefinitions::Ptr > (that.value); break; - case 105: // Identifier + case 111: // Identifier value.move< Identifier::Ptr > (that.value); break; - case 108: // IdentifierPath + case 114: // IdentifierPath value.move< IdentifierPath::Ptr > (that.value); break; - case 106: // Identifiers - case 107: // DotSeparatedIdentifiers + case 112: // Identifiers + case 113: // DotSeparatedIdentifiers value.move< Identifiers::Ptr > (that.value); break; - case 136: // IndirectCallExpression + case 107: // ImplementationDefinition + value.move< ImplementationDefinition::Ptr > (that.value); + break; + + case 142: // IndirectCallExpression value.move< IndirectCallExpression::Ptr > (that.value); break; - case 153: // IterateRule + case 159: // IterateRule value.move< IterateRule::Ptr > (that.value); break; - case 137: // LetExpression + case 143: // LetExpression value.move< LetExpression::Ptr > (that.value); break; - case 150: // LetRule + case 156: // LetRule value.move< LetRule::Ptr > (that.value); break; - case 131: // List + case 137: // List value.move< ListExpression::Ptr > (that.value); break; - case 90: // MaybeInitially - case 96: // Initializers - case 97: // MaybeInitializers + case 93: // MaybeInitially + case 99: // Initializers + case 100: // MaybeInitializers value.move< NodeList< UpdateRule >::Ptr > (that.value); break; - case 111: // Parameters - case 112: // MaybeParameters + case 117: // Parameters + case 118: // MaybeParameters value.move< NodeList< VariableDefinition >::Ptr > (that.value); break; - case 130: // Range + case 136: // Range value.move< RangeExpression::Ptr > (that.value); break; - case 127: // Reference + case 133: // Reference value.move< ReferenceAtom::Ptr > (that.value); break; - case 116: // RelationType + case 122: // RelationType value.move< RelationType::Ptr > (that.value); break; - case 143: // Rule + case 149: // Rule value.move< Rule::Ptr > (that.value); break; - case 142: // RuleDefinition + case 148: // RuleDefinition value.move< RuleDefinition::Ptr > (that.value); break; - case 144: // Rules + case 150: // Rules value.move< Rules::Ptr > (that.value); break; - case 155: // SequenceRule + case 161: // SequenceRule value.move< SequenceRule::Ptr > (that.value); break; - case 145: // SkipRule + case 151: // SkipRule value.move< SkipRule::Ptr > (that.value); break; - case 84: // Specification + case 87: // Specification value.move< Specification::Ptr > (that.value); break; - case 100: // StructureDefinition + case 103: // StructureDefinition value.move< StructureDefinition::Ptr > (that.value); break; - case 113: // Type + case 119: // Type value.move< Type::Ptr > (that.value); break; - case 92: // FunctionParameters - case 93: // MaybeFunctionParameters - case 118: // Types + case 95: // FunctionParameters + case 96: // MaybeFunctionParameters + case 124: // Types value.move< Types::Ptr > (that.value); break; - case 120: // Undefined + case 126: // Undefined value.move< UndefAtom::Ptr > (that.value); break; - case 140: // UniversalQuantifierExpression + case 146: // UniversalQuantifierExpression value.move< UniversalQuantifierExpression::Ptr > (that.value); break; - case 95: // Initializer - case 156: // UpdateRule + case 98: // Initializer + case 162: // UpdateRule value.move< UpdateRule::Ptr > (that.value); break; - case 121: // Boolean - case 122: // String - case 123: // BitNumber - case 124: // IntegerNumber - case 125: // FloatingNumber - case 126: // RationalNumber + case 127: // Boolean + case 128: // String + case 129: // BitNumber + case 130: // IntegerNumber + case 131: // FloatingNumber + case 132: // RationalNumber value.move< ValueAtom::Ptr > (that.value); break; - case 109: // Variable - case 110: // AttributedVariable + case 115: // Variable + case 116: // AttributedVariable value.move< VariableDefinition::Ptr > (that.value); break; - case 72: // "binary" - case 73: // "hexadecimal" - case 74: // "integer" - case 75: // "rational" - case 76: // "floating" - case 77: // "string" - case 78: // "identifier" + case 75: // "binary" + case 76: // "hexadecimal" + case 77: // "integer" + case 78: // "rational" + case 79: // "floating" + case 80: // "string" + case 81: // "identifier" value.move< std::string > (that.value); break; @@ -599,259 +605,265 @@ namespace libcasm_fe { state = that.state; switch (that.type_get ()) { - case 158: // Attribute + case 164: // Attribute value.copy< Attribute::Ptr > (that.value); break; - case 159: // Attributes + case 165: // Attributes value.copy< Attributes::Ptr > (that.value); break; - case 160: // BasicAttribute + case 166: // BasicAttribute value.copy< BasicAttribute::Ptr > (that.value); break; - case 114: // BasicType + case 120: // BasicType value.copy< BasicType::Ptr > (that.value); break; - case 154: // BlockRule + case 160: // BlockRule value.copy< BlockRule::Ptr > (that.value); break; - case 157: // CallRule + case 163: // CallRule value.copy< CallRule::Ptr > (that.value); break; - case 148: // CaseLabel + case 154: // CaseLabel value.copy< Case::Ptr > (that.value); break; - case 147: // CaseRule + case 153: // CaseRule value.copy< CaseRule::Ptr > (that.value); break; - case 149: // CaseLabels + case 155: // CaseLabels value.copy< Cases::Ptr > (that.value); break; - case 139: // ChooseExpression + case 145: // ChooseExpression value.copy< ChooseExpression::Ptr > (that.value); break; - case 152: // ChooseRule + case 158: // ChooseRule value.copy< ChooseRule::Ptr > (that.value); break; - case 115: // ComposedType + case 121: // ComposedType value.copy< ComposedType::Ptr > (that.value); break; - case 138: // ConditionalExpression + case 144: // ConditionalExpression value.copy< ConditionalExpression::Ptr > (that.value); break; - case 146: // ConditionalRule + case 152: // ConditionalRule value.copy< ConditionalRule::Ptr > (that.value); break; - case 104: // DeclarationDefinition + case 110: // DeclarationDefinition value.copy< DeclarationDefinition::Ptr > (that.value); break; - case 85: // Definition - case 86: // AttributedDefinition - case 102: // FeatureDeclarationOrDefinition + case 88: // Definition + case 89: // AttributedDefinition + case 105: // FeatureDeclarationOrDefinition + case 108: // ImplementationDefinitionDefinition value.copy< Definition::Ptr > (that.value); break; - case 87: // Definitions - case 103: // FeatureDeclarationsAndDefinitions + case 90: // Definitions + case 106: // FeatureDeclarationsAndDefinitions + case 109: // ImplementationDefinitionDefinitions value.copy< Definitions::Ptr > (that.value); break; - case 98: // DerivedDefinition + case 101: // DerivedDefinition value.copy< DerivedDefinition::Ptr > (that.value); break; - case 135: // DirectCallExpression + case 141: // DirectCallExpression value.copy< DirectCallExpression::Ptr > (that.value); break; - case 99: // EnumerationDefinition + case 102: // EnumerationDefinition value.copy< EnumerationDefinition::Ptr > (that.value); break; - case 141: // ExistentialQuantifierExpression + case 147: // ExistentialQuantifierExpression value.copy< ExistentialQuantifierExpression::Ptr > (that.value); break; - case 91: // MaybeDefined - case 119: // Atom - case 128: // Term - case 129: // Expression + case 94: // MaybeDefined + case 125: // Atom + case 134: // Term + case 135: // Expression value.copy< Expression::Ptr > (that.value); break; - case 161: // ExpressionAttribute + case 167: // ExpressionAttribute value.copy< ExpressionAttribute::Ptr > (that.value); break; - case 132: // Terms - case 133: // Arguments - case 134: // TwoOrMoreArguments + case 138: // Terms + case 139: // Arguments + case 140: // TwoOrMoreArguments value.copy< Expressions::Ptr > (that.value); break; - case 101: // FeatureDefinition + case 104: // FeatureDefinition value.copy< FeatureDefinition::Ptr > (that.value); break; - case 117: // FixedSizedType + case 123: // FixedSizedType value.copy< FixedSizedType::Ptr > (that.value); break; - case 151: // ForallRule + case 157: // ForallRule value.copy< ForallRule::Ptr > (that.value); break; - case 88: // FunctionDefinition - case 94: // ProgramFunctionDefinition + case 91: // FunctionDefinition + case 97: // ProgramFunctionDefinition value.copy< FunctionDefinition::Ptr > (that.value); break; - case 89: // FunctionDefinitions + case 92: // FunctionDefinitions value.copy< FunctionDefinitions::Ptr > (that.value); break; - case 105: // Identifier + case 111: // Identifier value.copy< Identifier::Ptr > (that.value); break; - case 108: // IdentifierPath + case 114: // IdentifierPath value.copy< IdentifierPath::Ptr > (that.value); break; - case 106: // Identifiers - case 107: // DotSeparatedIdentifiers + case 112: // Identifiers + case 113: // DotSeparatedIdentifiers value.copy< Identifiers::Ptr > (that.value); break; - case 136: // IndirectCallExpression + case 107: // ImplementationDefinition + value.copy< ImplementationDefinition::Ptr > (that.value); + break; + + case 142: // IndirectCallExpression value.copy< IndirectCallExpression::Ptr > (that.value); break; - case 153: // IterateRule + case 159: // IterateRule value.copy< IterateRule::Ptr > (that.value); break; - case 137: // LetExpression + case 143: // LetExpression value.copy< LetExpression::Ptr > (that.value); break; - case 150: // LetRule + case 156: // LetRule value.copy< LetRule::Ptr > (that.value); break; - case 131: // List + case 137: // List value.copy< ListExpression::Ptr > (that.value); break; - case 90: // MaybeInitially - case 96: // Initializers - case 97: // MaybeInitializers + case 93: // MaybeInitially + case 99: // Initializers + case 100: // MaybeInitializers value.copy< NodeList< UpdateRule >::Ptr > (that.value); break; - case 111: // Parameters - case 112: // MaybeParameters + case 117: // Parameters + case 118: // MaybeParameters value.copy< NodeList< VariableDefinition >::Ptr > (that.value); break; - case 130: // Range + case 136: // Range value.copy< RangeExpression::Ptr > (that.value); break; - case 127: // Reference + case 133: // Reference value.copy< ReferenceAtom::Ptr > (that.value); break; - case 116: // RelationType + case 122: // RelationType value.copy< RelationType::Ptr > (that.value); break; - case 143: // Rule + case 149: // Rule value.copy< Rule::Ptr > (that.value); break; - case 142: // RuleDefinition + case 148: // RuleDefinition value.copy< RuleDefinition::Ptr > (that.value); break; - case 144: // Rules + case 150: // Rules value.copy< Rules::Ptr > (that.value); break; - case 155: // SequenceRule + case 161: // SequenceRule value.copy< SequenceRule::Ptr > (that.value); break; - case 145: // SkipRule + case 151: // SkipRule value.copy< SkipRule::Ptr > (that.value); break; - case 84: // Specification + case 87: // Specification value.copy< Specification::Ptr > (that.value); break; - case 100: // StructureDefinition + case 103: // StructureDefinition value.copy< StructureDefinition::Ptr > (that.value); break; - case 113: // Type + case 119: // Type value.copy< Type::Ptr > (that.value); break; - case 92: // FunctionParameters - case 93: // MaybeFunctionParameters - case 118: // Types + case 95: // FunctionParameters + case 96: // MaybeFunctionParameters + case 124: // Types value.copy< Types::Ptr > (that.value); break; - case 120: // Undefined + case 126: // Undefined value.copy< UndefAtom::Ptr > (that.value); break; - case 140: // UniversalQuantifierExpression + case 146: // UniversalQuantifierExpression value.copy< UniversalQuantifierExpression::Ptr > (that.value); break; - case 95: // Initializer - case 156: // UpdateRule + case 98: // Initializer + case 162: // UpdateRule value.copy< UpdateRule::Ptr > (that.value); break; - case 121: // Boolean - case 122: // String - case 123: // BitNumber - case 124: // IntegerNumber - case 125: // FloatingNumber - case 126: // RationalNumber + case 127: // Boolean + case 128: // String + case 129: // BitNumber + case 130: // IntegerNumber + case 131: // FloatingNumber + case 132: // RationalNumber value.copy< ValueAtom::Ptr > (that.value); break; - case 109: // Variable - case 110: // AttributedVariable + case 115: // Variable + case 116: // AttributedVariable value.copy< VariableDefinition::Ptr > (that.value); break; - case 72: // "binary" - case 73: // "hexadecimal" - case 74: // "integer" - case 75: // "rational" - case 76: // "floating" - case 77: // "string" - case 78: // "identifier" + case 75: // "binary" + case 76: // "hexadecimal" + case 77: // "integer" + case 78: // "rational" + case 79: // "floating" + case 80: // "string" + case 81: // "identifier" value.copy< std::string > (that.value); break; @@ -1083,259 +1095,265 @@ namespace libcasm_fe { when using variants. */ switch (yyr1_[yyn]) { - case 158: // Attribute + case 164: // Attribute yylhs.value.build< Attribute::Ptr > (); break; - case 159: // Attributes + case 165: // Attributes yylhs.value.build< Attributes::Ptr > (); break; - case 160: // BasicAttribute + case 166: // BasicAttribute yylhs.value.build< BasicAttribute::Ptr > (); break; - case 114: // BasicType + case 120: // BasicType yylhs.value.build< BasicType::Ptr > (); break; - case 154: // BlockRule + case 160: // BlockRule yylhs.value.build< BlockRule::Ptr > (); break; - case 157: // CallRule + case 163: // CallRule yylhs.value.build< CallRule::Ptr > (); break; - case 148: // CaseLabel + case 154: // CaseLabel yylhs.value.build< Case::Ptr > (); break; - case 147: // CaseRule + case 153: // CaseRule yylhs.value.build< CaseRule::Ptr > (); break; - case 149: // CaseLabels + case 155: // CaseLabels yylhs.value.build< Cases::Ptr > (); break; - case 139: // ChooseExpression + case 145: // ChooseExpression yylhs.value.build< ChooseExpression::Ptr > (); break; - case 152: // ChooseRule + case 158: // ChooseRule yylhs.value.build< ChooseRule::Ptr > (); break; - case 115: // ComposedType + case 121: // ComposedType yylhs.value.build< ComposedType::Ptr > (); break; - case 138: // ConditionalExpression + case 144: // ConditionalExpression yylhs.value.build< ConditionalExpression::Ptr > (); break; - case 146: // ConditionalRule + case 152: // ConditionalRule yylhs.value.build< ConditionalRule::Ptr > (); break; - case 104: // DeclarationDefinition + case 110: // DeclarationDefinition yylhs.value.build< DeclarationDefinition::Ptr > (); break; - case 85: // Definition - case 86: // AttributedDefinition - case 102: // FeatureDeclarationOrDefinition + case 88: // Definition + case 89: // AttributedDefinition + case 105: // FeatureDeclarationOrDefinition + case 108: // ImplementationDefinitionDefinition yylhs.value.build< Definition::Ptr > (); break; - case 87: // Definitions - case 103: // FeatureDeclarationsAndDefinitions + case 90: // Definitions + case 106: // FeatureDeclarationsAndDefinitions + case 109: // ImplementationDefinitionDefinitions yylhs.value.build< Definitions::Ptr > (); break; - case 98: // DerivedDefinition + case 101: // DerivedDefinition yylhs.value.build< DerivedDefinition::Ptr > (); break; - case 135: // DirectCallExpression + case 141: // DirectCallExpression yylhs.value.build< DirectCallExpression::Ptr > (); break; - case 99: // EnumerationDefinition + case 102: // EnumerationDefinition yylhs.value.build< EnumerationDefinition::Ptr > (); break; - case 141: // ExistentialQuantifierExpression + case 147: // ExistentialQuantifierExpression yylhs.value.build< ExistentialQuantifierExpression::Ptr > (); break; - case 91: // MaybeDefined - case 119: // Atom - case 128: // Term - case 129: // Expression + case 94: // MaybeDefined + case 125: // Atom + case 134: // Term + case 135: // Expression yylhs.value.build< Expression::Ptr > (); break; - case 161: // ExpressionAttribute + case 167: // ExpressionAttribute yylhs.value.build< ExpressionAttribute::Ptr > (); break; - case 132: // Terms - case 133: // Arguments - case 134: // TwoOrMoreArguments + case 138: // Terms + case 139: // Arguments + case 140: // TwoOrMoreArguments yylhs.value.build< Expressions::Ptr > (); break; - case 101: // FeatureDefinition + case 104: // FeatureDefinition yylhs.value.build< FeatureDefinition::Ptr > (); break; - case 117: // FixedSizedType + case 123: // FixedSizedType yylhs.value.build< FixedSizedType::Ptr > (); break; - case 151: // ForallRule + case 157: // ForallRule yylhs.value.build< ForallRule::Ptr > (); break; - case 88: // FunctionDefinition - case 94: // ProgramFunctionDefinition + case 91: // FunctionDefinition + case 97: // ProgramFunctionDefinition yylhs.value.build< FunctionDefinition::Ptr > (); break; - case 89: // FunctionDefinitions + case 92: // FunctionDefinitions yylhs.value.build< FunctionDefinitions::Ptr > (); break; - case 105: // Identifier + case 111: // Identifier yylhs.value.build< Identifier::Ptr > (); break; - case 108: // IdentifierPath + case 114: // IdentifierPath yylhs.value.build< IdentifierPath::Ptr > (); break; - case 106: // Identifiers - case 107: // DotSeparatedIdentifiers + case 112: // Identifiers + case 113: // DotSeparatedIdentifiers yylhs.value.build< Identifiers::Ptr > (); break; - case 136: // IndirectCallExpression + case 107: // ImplementationDefinition + yylhs.value.build< ImplementationDefinition::Ptr > (); + break; + + case 142: // IndirectCallExpression yylhs.value.build< IndirectCallExpression::Ptr > (); break; - case 153: // IterateRule + case 159: // IterateRule yylhs.value.build< IterateRule::Ptr > (); break; - case 137: // LetExpression + case 143: // LetExpression yylhs.value.build< LetExpression::Ptr > (); break; - case 150: // LetRule + case 156: // LetRule yylhs.value.build< LetRule::Ptr > (); break; - case 131: // List + case 137: // List yylhs.value.build< ListExpression::Ptr > (); break; - case 90: // MaybeInitially - case 96: // Initializers - case 97: // MaybeInitializers + case 93: // MaybeInitially + case 99: // Initializers + case 100: // MaybeInitializers yylhs.value.build< NodeList< UpdateRule >::Ptr > (); break; - case 111: // Parameters - case 112: // MaybeParameters + case 117: // Parameters + case 118: // MaybeParameters yylhs.value.build< NodeList< VariableDefinition >::Ptr > (); break; - case 130: // Range + case 136: // Range yylhs.value.build< RangeExpression::Ptr > (); break; - case 127: // Reference + case 133: // Reference yylhs.value.build< ReferenceAtom::Ptr > (); break; - case 116: // RelationType + case 122: // RelationType yylhs.value.build< RelationType::Ptr > (); break; - case 143: // Rule + case 149: // Rule yylhs.value.build< Rule::Ptr > (); break; - case 142: // RuleDefinition + case 148: // RuleDefinition yylhs.value.build< RuleDefinition::Ptr > (); break; - case 144: // Rules + case 150: // Rules yylhs.value.build< Rules::Ptr > (); break; - case 155: // SequenceRule + case 161: // SequenceRule yylhs.value.build< SequenceRule::Ptr > (); break; - case 145: // SkipRule + case 151: // SkipRule yylhs.value.build< SkipRule::Ptr > (); break; - case 84: // Specification + case 87: // Specification yylhs.value.build< Specification::Ptr > (); break; - case 100: // StructureDefinition + case 103: // StructureDefinition yylhs.value.build< StructureDefinition::Ptr > (); break; - case 113: // Type + case 119: // Type yylhs.value.build< Type::Ptr > (); break; - case 92: // FunctionParameters - case 93: // MaybeFunctionParameters - case 118: // Types + case 95: // FunctionParameters + case 96: // MaybeFunctionParameters + case 124: // Types yylhs.value.build< Types::Ptr > (); break; - case 120: // Undefined + case 126: // Undefined yylhs.value.build< UndefAtom::Ptr > (); break; - case 140: // UniversalQuantifierExpression + case 146: // UniversalQuantifierExpression yylhs.value.build< UniversalQuantifierExpression::Ptr > (); break; - case 95: // Initializer - case 156: // UpdateRule + case 98: // Initializer + case 162: // UpdateRule yylhs.value.build< UpdateRule::Ptr > (); break; - case 121: // Boolean - case 122: // String - case 123: // BitNumber - case 124: // IntegerNumber - case 125: // FloatingNumber - case 126: // RationalNumber + case 127: // Boolean + case 128: // String + case 129: // BitNumber + case 130: // IntegerNumber + case 131: // FloatingNumber + case 132: // RationalNumber yylhs.value.build< ValueAtom::Ptr > (); break; - case 109: // Variable - case 110: // AttributedVariable + case 115: // Variable + case 116: // AttributedVariable yylhs.value.build< VariableDefinition::Ptr > (); break; - case 72: // "binary" - case 73: // "hexadecimal" - case 74: // "integer" - case 75: // "rational" - case 76: // "floating" - case 77: // "string" - case 78: // "identifier" + case 75: // "binary" + case 76: // "hexadecimal" + case 77: // "integer" + case 78: // "rational" + case 79: // "floating" + case 80: // "string" + case 81: // "identifier" yylhs.value.build< std::string > (); break; @@ -1357,7 +1375,7 @@ namespace libcasm_fe { switch (yyn) { case 2: -#line 360 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 +#line 366 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { const std::string& fileName = filePath.substr( filePath.find_last_of( "/\\" ) + 1 ); const std::string& name = fileName.substr( 0, fileName.rfind( "." ) ); @@ -1365,105 +1383,113 @@ namespace libcasm_fe { const auto specificationName = make< Identifier >( yylhs.location, name ); result = Ast::make< Specification >( yylhs.location, specificationName, yystack_[0].value.as< Definitions::Ptr > () ); } -#line 1369 "GrammarParser.cpp" // lalr1.cc:859 +#line 1387 "GrammarParser.cpp" // lalr1.cc:859 break; case 3: -#line 372 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 +#line 378 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< FunctionDefinition::Ptr > (); } -#line 1377 "GrammarParser.cpp" // lalr1.cc:859 +#line 1395 "GrammarParser.cpp" // lalr1.cc:859 break; case 4: -#line 376 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 +#line 382 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< DerivedDefinition::Ptr > (); } -#line 1385 "GrammarParser.cpp" // lalr1.cc:859 +#line 1403 "GrammarParser.cpp" // lalr1.cc:859 break; case 5: -#line 380 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 +#line 386 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< RuleDefinition::Ptr > (); } -#line 1393 "GrammarParser.cpp" // lalr1.cc:859 +#line 1411 "GrammarParser.cpp" // lalr1.cc:859 break; case 6: -#line 384 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 +#line 390 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< EnumerationDefinition::Ptr > (); } -#line 1401 "GrammarParser.cpp" // lalr1.cc:859 +#line 1419 "GrammarParser.cpp" // lalr1.cc:859 break; case 7: -#line 388 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 +#line 394 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< StructureDefinition::Ptr > (); } -#line 1409 "GrammarParser.cpp" // lalr1.cc:859 +#line 1427 "GrammarParser.cpp" // lalr1.cc:859 break; case 8: -#line 392 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 +#line 398 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< FeatureDefinition::Ptr > (); } -#line 1417 "GrammarParser.cpp" // lalr1.cc:859 +#line 1435 "GrammarParser.cpp" // lalr1.cc:859 break; case 9: -#line 396 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 +#line 402 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { - yylhs.value.as< Definition::Ptr > () = nullptr; + yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< ImplementationDefinition::Ptr > (); } -#line 1425 "GrammarParser.cpp" // lalr1.cc:859 +#line 1443 "GrammarParser.cpp" // lalr1.cc:859 break; case 10: -#line 404 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 +#line 406 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + { + yylhs.value.as< Definition::Ptr > () = nullptr; + } +#line 1451 "GrammarParser.cpp" // lalr1.cc:859 + break; + + case 11: +#line 414 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto definition = yystack_[0].value.as< Definition::Ptr > (); definition->setAttributes( yystack_[2].value.as< Attributes::Ptr > () ); yylhs.value.as< Definition::Ptr > () = definition; } -#line 1435 "GrammarParser.cpp" // lalr1.cc:859 +#line 1461 "GrammarParser.cpp" // lalr1.cc:859 break; - case 11: -#line 410 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 12: +#line 420 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< Definition::Ptr > (); } -#line 1443 "GrammarParser.cpp" // lalr1.cc:859 +#line 1469 "GrammarParser.cpp" // lalr1.cc:859 break; - case 12: -#line 418 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 13: +#line 428 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto definitions = yystack_[1].value.as< Definitions::Ptr > (); definitions->add( yystack_[0].value.as< Definition::Ptr > () ); yylhs.value.as< Definitions::Ptr > () = definitions; } -#line 1453 "GrammarParser.cpp" // lalr1.cc:859 +#line 1479 "GrammarParser.cpp" // lalr1.cc:859 break; - case 13: -#line 424 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 14: +#line 434 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto definitions = Ast::make< Definitions >( yylhs.location ); definitions->add( yystack_[0].value.as< Definition::Ptr > () ); yylhs.value.as< Definitions::Ptr > () = definitions; } -#line 1463 "GrammarParser.cpp" // lalr1.cc:859 +#line 1489 "GrammarParser.cpp" // lalr1.cc:859 break; - case 14: -#line 434 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 15: +#line 444 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { const auto identifier = yystack_[6].value.as< Identifier::Ptr > (); @@ -1479,107 +1505,107 @@ namespace libcasm_fe { yylhs.value.as< FunctionDefinition::Ptr > () = function; } -#line 1483 "GrammarParser.cpp" // lalr1.cc:859 +#line 1509 "GrammarParser.cpp" // lalr1.cc:859 break; - case 15: -#line 450 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 16: +#line 460 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< FunctionDefinition::Ptr > () = yystack_[0].value.as< FunctionDefinition::Ptr > (); // `init` special case } -#line 1491 "GrammarParser.cpp" // lalr1.cc:859 +#line 1517 "GrammarParser.cpp" // lalr1.cc:859 break; - case 16: -#line 458 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 17: +#line 468 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto functions = yystack_[2].value.as< FunctionDefinitions::Ptr > (); functions->add( yystack_[0].value.as< FunctionDefinition::Ptr > () ); yylhs.value.as< FunctionDefinitions::Ptr > () = functions; } -#line 1501 "GrammarParser.cpp" // lalr1.cc:859 +#line 1527 "GrammarParser.cpp" // lalr1.cc:859 break; - case 17: -#line 464 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 18: +#line 474 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto functions = Ast::make< FunctionDefinitions >( yylhs.location ); functions->add( yystack_[0].value.as< FunctionDefinition::Ptr > () ); yylhs.value.as< FunctionDefinitions::Ptr > () = functions; } -#line 1511 "GrammarParser.cpp" // lalr1.cc:859 +#line 1537 "GrammarParser.cpp" // lalr1.cc:859 break; - case 18: -#line 474 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 19: +#line 484 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< NodeList< UpdateRule >::Ptr > () = yystack_[1].value.as< NodeList< UpdateRule >::Ptr > (); } -#line 1519 "GrammarParser.cpp" // lalr1.cc:859 +#line 1545 "GrammarParser.cpp" // lalr1.cc:859 break; - case 19: -#line 478 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 20: +#line 488 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< NodeList< UpdateRule >::Ptr > () = Ast::make< NodeList< UpdateRule > >( yylhs.location ); } -#line 1527 "GrammarParser.cpp" // lalr1.cc:859 +#line 1553 "GrammarParser.cpp" // lalr1.cc:859 break; - case 20: -#line 486 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 21: +#line 496 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[1].value.as< Expression::Ptr > (); } -#line 1535 "GrammarParser.cpp" // lalr1.cc:859 +#line 1561 "GrammarParser.cpp" // lalr1.cc:859 break; - case 21: -#line 490 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 22: +#line 500 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = Ast::make< UndefAtom >( yylhs.location ); } -#line 1543 "GrammarParser.cpp" // lalr1.cc:859 +#line 1569 "GrammarParser.cpp" // lalr1.cc:859 break; - case 22: -#line 498 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 23: +#line 508 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto types = yystack_[2].value.as< Types::Ptr > (); types->add( yystack_[0].value.as< Type::Ptr > () ); yylhs.value.as< Types::Ptr > () = types; } -#line 1553 "GrammarParser.cpp" // lalr1.cc:859 +#line 1579 "GrammarParser.cpp" // lalr1.cc:859 break; - case 23: -#line 504 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 24: +#line 514 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto types = Ast::make< Types >( yylhs.location ); types->add( yystack_[0].value.as< Type::Ptr > () ); yylhs.value.as< Types::Ptr > () = types; } -#line 1563 "GrammarParser.cpp" // lalr1.cc:859 +#line 1589 "GrammarParser.cpp" // lalr1.cc:859 break; - case 24: -#line 514 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 25: +#line 524 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Types::Ptr > () = yystack_[0].value.as< Types::Ptr > (); } -#line 1571 "GrammarParser.cpp" // lalr1.cc:859 +#line 1597 "GrammarParser.cpp" // lalr1.cc:859 break; - case 25: -#line 518 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 26: +#line 528 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Types::Ptr > () = Ast::make< Types >( yylhs.location ); } -#line 1579 "GrammarParser.cpp" // lalr1.cc:859 +#line 1605 "GrammarParser.cpp" // lalr1.cc:859 break; - case 26: -#line 526 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 27: +#line 536 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { const auto singleAgentIdentifier = Ast::make< Identifier >( yylhs.location, "$" ); auto singleAgentArguments = libcasm_fe::Ast::make< Expressions >( yylhs.location ); @@ -1602,11 +1628,11 @@ namespace libcasm_fe { yylhs.value.as< FunctionDefinition::Ptr > () = programDefinition; } -#line 1606 "GrammarParser.cpp" // lalr1.cc:859 +#line 1632 "GrammarParser.cpp" // lalr1.cc:859 break; - case 27: -#line 549 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 28: +#line 559 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto programDefinition = createProgramFunction( yylhs.location ); @@ -1620,11 +1646,11 @@ namespace libcasm_fe { yylhs.value.as< FunctionDefinition::Ptr > () = programDefinition; } -#line 1624 "GrammarParser.cpp" // lalr1.cc:859 +#line 1650 "GrammarParser.cpp" // lalr1.cc:859 break; - case 28: -#line 567 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 29: +#line 577 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { // the unknown function identifier will be replaced in FunctionDefinition const auto arguments = Ast::make< Expressions >( yylhs.location ); @@ -1632,11 +1658,11 @@ namespace libcasm_fe { function->setTargetType( CallExpression::TargetType::FUNCTION ); yylhs.value.as< UpdateRule::Ptr > () = Ast::make< UpdateRule >( yylhs.location, function, yystack_[0].value.as< Expression::Ptr > () ); } -#line 1636 "GrammarParser.cpp" // lalr1.cc:859 +#line 1662 "GrammarParser.cpp" // lalr1.cc:859 break; - case 29: -#line 575 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 30: +#line 585 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto arguments = Ast::make< Expressions >( yylhs.location ); arguments->add( yystack_[2].value.as< Expression::Ptr > () ); @@ -1646,479 +1672,541 @@ namespace libcasm_fe { function->setTargetType( CallExpression::TargetType::FUNCTION ); yylhs.value.as< UpdateRule::Ptr > () = Ast::make< UpdateRule >( yylhs.location, function, yystack_[0].value.as< Expression::Ptr > () ); } -#line 1650 "GrammarParser.cpp" // lalr1.cc:859 +#line 1676 "GrammarParser.cpp" // lalr1.cc:859 break; - case 30: -#line 585 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 31: +#line 595 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { // the unknown function identifier will be replaced in FunctionDefinition const auto function = Ast::make< DirectCallExpression >( yylhs.location, nullptr, yystack_[2].value.as< Expressions::Ptr > () ); function->setTargetType( CallExpression::TargetType::FUNCTION ); yylhs.value.as< UpdateRule::Ptr > () = Ast::make< UpdateRule >( yylhs.location, function, yystack_[0].value.as< Expression::Ptr > () ); } -#line 1661 "GrammarParser.cpp" // lalr1.cc:859 +#line 1687 "GrammarParser.cpp" // lalr1.cc:859 break; - case 31: -#line 596 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 32: +#line 606 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto initializers = yystack_[2].value.as< NodeList< UpdateRule >::Ptr > (); initializers->add( yystack_[0].value.as< UpdateRule::Ptr > () ); yylhs.value.as< NodeList< UpdateRule >::Ptr > () = initializers; } -#line 1671 "GrammarParser.cpp" // lalr1.cc:859 +#line 1697 "GrammarParser.cpp" // lalr1.cc:859 break; - case 32: -#line 602 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 33: +#line 612 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto initializers = Ast::make< NodeList< UpdateRule > >( yylhs.location ); initializers->add( yystack_[0].value.as< UpdateRule::Ptr > () ); yylhs.value.as< NodeList< UpdateRule >::Ptr > () = initializers; } -#line 1681 "GrammarParser.cpp" // lalr1.cc:859 +#line 1707 "GrammarParser.cpp" // lalr1.cc:859 break; - case 33: -#line 612 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 34: +#line 622 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< NodeList< UpdateRule >::Ptr > () = yystack_[0].value.as< NodeList< UpdateRule >::Ptr > (); } -#line 1689 "GrammarParser.cpp" // lalr1.cc:859 +#line 1715 "GrammarParser.cpp" // lalr1.cc:859 break; - case 34: -#line 616 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 35: +#line 626 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< NodeList< UpdateRule >::Ptr > () = Ast::make< NodeList< UpdateRule > >( yylhs.location ); } -#line 1697 "GrammarParser.cpp" // lalr1.cc:859 +#line 1723 "GrammarParser.cpp" // lalr1.cc:859 break; - case 35: -#line 624 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 36: +#line 634 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< DerivedDefinition::Ptr > () = Ast::make< DerivedDefinition >( yylhs.location, yystack_[5].value.as< Identifier::Ptr > (), yystack_[4].value.as< NodeList< VariableDefinition >::Ptr > (), yystack_[2].value.as< Type::Ptr > (), yystack_[0].value.as< Expression::Ptr > () ); } -#line 1705 "GrammarParser.cpp" // lalr1.cc:859 +#line 1731 "GrammarParser.cpp" // lalr1.cc:859 break; - case 36: -#line 632 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 37: +#line 642 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< EnumerationDefinition::Ptr > () = Ast::make< EnumerationDefinition >( yylhs.location, yystack_[4].value.as< Identifier::Ptr > (), yystack_[1].value.as< Identifiers::Ptr > () ); } -#line 1713 "GrammarParser.cpp" // lalr1.cc:859 +#line 1739 "GrammarParser.cpp" // lalr1.cc:859 break; - case 37: -#line 640 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 38: +#line 650 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< StructureDefinition::Ptr > () = Ast::make< StructureDefinition >( yylhs.location, yystack_[4].value.as< Identifier::Ptr > (), yystack_[1].value.as< FunctionDefinitions::Ptr > () ); } -#line 1721 "GrammarParser.cpp" // lalr1.cc:859 +#line 1747 "GrammarParser.cpp" // lalr1.cc:859 break; - case 38: -#line 648 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 39: +#line 658 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< FeatureDefinition::Ptr > () = Ast::make< FeatureDefinition >( yylhs.location, yystack_[4].value.as< Identifier::Ptr > (), yystack_[1].value.as< Definitions::Ptr > () ); } -#line 1729 "GrammarParser.cpp" // lalr1.cc:859 +#line 1755 "GrammarParser.cpp" // lalr1.cc:859 break; - case 39: -#line 656 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 40: +#line 666 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< DeclarationDefinition::Ptr > (); } -#line 1737 "GrammarParser.cpp" // lalr1.cc:859 +#line 1763 "GrammarParser.cpp" // lalr1.cc:859 break; - case 40: -#line 660 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 41: +#line 670 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< DerivedDefinition::Ptr > (); } -#line 1745 "GrammarParser.cpp" // lalr1.cc:859 +#line 1771 "GrammarParser.cpp" // lalr1.cc:859 break; - case 41: -#line 664 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 42: +#line 674 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< RuleDefinition::Ptr > (); } -#line 1753 "GrammarParser.cpp" // lalr1.cc:859 +#line 1779 "GrammarParser.cpp" // lalr1.cc:859 break; - case 42: -#line 672 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 43: +#line 682 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { - auto definitions = yystack_[2].value.as< Definitions::Ptr > (); + auto definitions = yystack_[1].value.as< Definitions::Ptr > (); definitions->add( yystack_[0].value.as< Definition::Ptr > () ); yylhs.value.as< Definitions::Ptr > () = definitions; } -#line 1763 "GrammarParser.cpp" // lalr1.cc:859 +#line 1789 "GrammarParser.cpp" // lalr1.cc:859 break; - case 43: -#line 678 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 44: +#line 688 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto definitions = Ast::make< Definitions >( yylhs.location ); definitions->add( yystack_[0].value.as< Definition::Ptr > () ); yylhs.value.as< Definitions::Ptr > () = definitions; } -#line 1773 "GrammarParser.cpp" // lalr1.cc:859 +#line 1799 "GrammarParser.cpp" // lalr1.cc:859 break; - case 44: -#line 688 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 45: +#line 698 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + { + yylhs.value.as< ImplementationDefinition::Ptr > () = Ast::make< ImplementationDefinition >( yylhs.location, yystack_[6].value.as< IdentifierPath::Ptr > (), yystack_[4].value.as< Type::Ptr > (), yystack_[1].value.as< Definitions::Ptr > () ); + } +#line 1807 "GrammarParser.cpp" // lalr1.cc:859 + break; + + case 46: +#line 702 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + { + const auto name = Ast::make< Identifier >( yylhs.location, "" ); + const auto path = asIdentifierPath( name ); + yylhs.value.as< ImplementationDefinition::Ptr > () = Ast::make< ImplementationDefinition >( yylhs.location, path, yystack_[4].value.as< Type::Ptr > (), yystack_[1].value.as< Definitions::Ptr > () ); + } +#line 1817 "GrammarParser.cpp" // lalr1.cc:859 + break; + + case 47: +#line 712 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + { + yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< DerivedDefinition::Ptr > (); + } +#line 1825 "GrammarParser.cpp" // lalr1.cc:859 + break; + + case 48: +#line 716 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + { + yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< RuleDefinition::Ptr > (); + } +#line 1833 "GrammarParser.cpp" // lalr1.cc:859 + break; + + case 49: +#line 724 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + { + auto definitions = yystack_[1].value.as< Definitions::Ptr > (); + definitions->add( yystack_[0].value.as< Definition::Ptr > () ); + yylhs.value.as< Definitions::Ptr > () = definitions; + } +#line 1843 "GrammarParser.cpp" // lalr1.cc:859 + break; + + case 50: +#line 730 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + { + auto definitions = Ast::make< Definitions >( yylhs.location ); + definitions->add( yystack_[0].value.as< Definition::Ptr > () ); + yylhs.value.as< Definitions::Ptr > () = definitions; + } +#line 1853 "GrammarParser.cpp" // lalr1.cc:859 + break; + + case 51: +#line 740 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto declaration = Ast::make< DeclarationDefinition >( yylhs.location, yystack_[4].value.as< Identifier::Ptr > (), yystack_[2].value.as< Types::Ptr > (), yystack_[0].value.as< Type::Ptr > () ); declaration->setKind( DeclarationDefinition::Kind::DERIVED ); yylhs.value.as< DeclarationDefinition::Ptr > () = declaration; } -#line 1783 "GrammarParser.cpp" // lalr1.cc:859 +#line 1863 "GrammarParser.cpp" // lalr1.cc:859 break; - case 45: -#line 694 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 52: +#line 746 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto declaration = Ast::make< DeclarationDefinition >( yylhs.location, yystack_[4].value.as< Identifier::Ptr > (), yystack_[2].value.as< Types::Ptr > (), yystack_[0].value.as< Type::Ptr > () ); declaration->setKind( DeclarationDefinition::Kind::RULE ); yylhs.value.as< DeclarationDefinition::Ptr > () = declaration; } -#line 1793 "GrammarParser.cpp" // lalr1.cc:859 +#line 1873 "GrammarParser.cpp" // lalr1.cc:859 break; - case 46: -#line 704 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 53: +#line 756 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Identifier::Ptr > () = Ast::make< Identifier >( yylhs.location, yystack_[0].value.as< std::string > () ); } -#line 1801 "GrammarParser.cpp" // lalr1.cc:859 +#line 1881 "GrammarParser.cpp" // lalr1.cc:859 break; - case 47: -#line 708 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 54: +#line 760 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Identifier::Ptr > () = Ast::make< Identifier >( yylhs.location, "in" ); } -#line 1809 "GrammarParser.cpp" // lalr1.cc:859 +#line 1889 "GrammarParser.cpp" // lalr1.cc:859 break; - case 48: -#line 716 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 55: +#line 768 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto identifiers = yystack_[2].value.as< Identifiers::Ptr > (); identifiers->add( yystack_[0].value.as< Identifier::Ptr > () ); yylhs.value.as< Identifiers::Ptr > () = identifiers; } -#line 1819 "GrammarParser.cpp" // lalr1.cc:859 +#line 1899 "GrammarParser.cpp" // lalr1.cc:859 break; - case 49: -#line 722 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 56: +#line 774 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto identifiers = Ast::make< Identifiers >( yylhs.location ); identifiers->add( yystack_[0].value.as< Identifier::Ptr > () ); yylhs.value.as< Identifiers::Ptr > () = identifiers; } -#line 1829 "GrammarParser.cpp" // lalr1.cc:859 +#line 1909 "GrammarParser.cpp" // lalr1.cc:859 break; - case 50: -#line 732 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 57: +#line 784 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto identifiers = yystack_[2].value.as< Identifiers::Ptr > (); identifiers->add( yystack_[0].value.as< Identifier::Ptr > () ); yylhs.value.as< Identifiers::Ptr > () = identifiers; } -#line 1839 "GrammarParser.cpp" // lalr1.cc:859 +#line 1919 "GrammarParser.cpp" // lalr1.cc:859 break; - case 51: -#line 738 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 58: +#line 790 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto identifiers = Ast::make< Identifiers >( yylhs.location ); identifiers->add( yystack_[0].value.as< Identifier::Ptr > () ); yylhs.value.as< Identifiers::Ptr > () = identifiers; } -#line 1849 "GrammarParser.cpp" // lalr1.cc:859 +#line 1929 "GrammarParser.cpp" // lalr1.cc:859 break; - case 52: -#line 748 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 59: +#line 800 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< IdentifierPath::Ptr > () = Ast::make< IdentifierPath >( yylhs.location, yystack_[0].value.as< Identifiers::Ptr > (), IdentifierPath::Type::ABSOLUTE ); } -#line 1857 "GrammarParser.cpp" // lalr1.cc:859 +#line 1937 "GrammarParser.cpp" // lalr1.cc:859 break; - case 53: -#line 752 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 60: +#line 804 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< IdentifierPath::Ptr > () = Ast::make< IdentifierPath >( yylhs.location, yystack_[0].value.as< Identifiers::Ptr > (), IdentifierPath::Type::RELATIVE ); } -#line 1865 "GrammarParser.cpp" // lalr1.cc:859 +#line 1945 "GrammarParser.cpp" // lalr1.cc:859 break; - case 54: -#line 760 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 61: +#line 808 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + { + yylhs.value.as< IdentifierPath::Ptr > () = Ast::make< IdentifierPath >( yylhs.location, yystack_[0].value.as< Identifiers::Ptr > (), IdentifierPath::Type::THIS ); + } +#line 1953 "GrammarParser.cpp" // lalr1.cc:859 + break; + + case 62: +#line 816 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< VariableDefinition::Ptr > () = Ast::make< VariableDefinition >( yylhs.location, yystack_[2].value.as< Identifier::Ptr > (), yystack_[0].value.as< Type::Ptr > () ); } -#line 1873 "GrammarParser.cpp" // lalr1.cc:859 +#line 1961 "GrammarParser.cpp" // lalr1.cc:859 break; - case 55: -#line 764 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 63: +#line 820 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { const auto unresolvedType = Ast::make< UnresolvedType >( yylhs.location ); yylhs.value.as< VariableDefinition::Ptr > () = Ast::make< VariableDefinition >( yylhs.location, yystack_[0].value.as< Identifier::Ptr > (), unresolvedType ); } -#line 1882 "GrammarParser.cpp" // lalr1.cc:859 +#line 1970 "GrammarParser.cpp" // lalr1.cc:859 break; - case 56: -#line 773 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 64: +#line 829 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto variable = yystack_[0].value.as< VariableDefinition::Ptr > (); variable->setAttributes( yystack_[2].value.as< Attributes::Ptr > () ); yylhs.value.as< VariableDefinition::Ptr > () = variable; } -#line 1892 "GrammarParser.cpp" // lalr1.cc:859 +#line 1980 "GrammarParser.cpp" // lalr1.cc:859 break; - case 57: -#line 779 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 65: +#line 835 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< VariableDefinition::Ptr > () = yystack_[0].value.as< VariableDefinition::Ptr > (); } -#line 1900 "GrammarParser.cpp" // lalr1.cc:859 +#line 1988 "GrammarParser.cpp" // lalr1.cc:859 break; - case 58: -#line 787 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 66: +#line 843 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto parameters = yystack_[2].value.as< NodeList< VariableDefinition >::Ptr > (); parameters->add( yystack_[0].value.as< VariableDefinition::Ptr > () ); yylhs.value.as< NodeList< VariableDefinition >::Ptr > () = parameters; } -#line 1910 "GrammarParser.cpp" // lalr1.cc:859 +#line 1998 "GrammarParser.cpp" // lalr1.cc:859 break; - case 59: -#line 793 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 67: +#line 849 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto parameters = Ast::make< NodeList< VariableDefinition > >( yylhs.location ); parameters->add( yystack_[0].value.as< VariableDefinition::Ptr > () ); yylhs.value.as< NodeList< VariableDefinition >::Ptr > () = parameters; } -#line 1920 "GrammarParser.cpp" // lalr1.cc:859 +#line 2008 "GrammarParser.cpp" // lalr1.cc:859 break; - case 60: -#line 803 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 68: +#line 859 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< NodeList< VariableDefinition >::Ptr > () = yystack_[1].value.as< NodeList< VariableDefinition >::Ptr > (); } -#line 1928 "GrammarParser.cpp" // lalr1.cc:859 +#line 2016 "GrammarParser.cpp" // lalr1.cc:859 break; - case 61: -#line 807 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 69: +#line 863 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< NodeList< VariableDefinition >::Ptr > () = nullptr; } -#line 1936 "GrammarParser.cpp" // lalr1.cc:859 +#line 2024 "GrammarParser.cpp" // lalr1.cc:859 break; - case 62: -#line 811 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 70: +#line 867 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< NodeList< VariableDefinition >::Ptr > () = Ast::make< NodeList< VariableDefinition > >( yylhs.location ); } -#line 1944 "GrammarParser.cpp" // lalr1.cc:859 +#line 2032 "GrammarParser.cpp" // lalr1.cc:859 break; - case 63: -#line 819 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 71: +#line 875 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Type::Ptr > () = yystack_[0].value.as< BasicType::Ptr > (); } -#line 1952 "GrammarParser.cpp" // lalr1.cc:859 +#line 2040 "GrammarParser.cpp" // lalr1.cc:859 break; - case 64: -#line 823 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 72: +#line 879 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Type::Ptr > () = yystack_[0].value.as< ComposedType::Ptr > (); } -#line 1960 "GrammarParser.cpp" // lalr1.cc:859 +#line 2048 "GrammarParser.cpp" // lalr1.cc:859 break; - case 65: -#line 827 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 73: +#line 883 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Type::Ptr > () = yystack_[0].value.as< RelationType::Ptr > (); } -#line 1968 "GrammarParser.cpp" // lalr1.cc:859 +#line 2056 "GrammarParser.cpp" // lalr1.cc:859 break; - case 66: -#line 831 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 74: +#line 887 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Type::Ptr > () = yystack_[0].value.as< FixedSizedType::Ptr > (); } -#line 1976 "GrammarParser.cpp" // lalr1.cc:859 +#line 2064 "GrammarParser.cpp" // lalr1.cc:859 break; - case 67: -#line 839 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 75: +#line 895 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< BasicType::Ptr > () = Ast::make< BasicType >( yylhs.location, yystack_[0].value.as< IdentifierPath::Ptr > () ); } -#line 1984 "GrammarParser.cpp" // lalr1.cc:859 +#line 2072 "GrammarParser.cpp" // lalr1.cc:859 break; - case 68: -#line 847 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 76: +#line 903 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< ComposedType::Ptr > () = Ast::make< ComposedType >( yylhs.location, yystack_[3].value.as< IdentifierPath::Ptr > (), yystack_[1].value.as< Types::Ptr > () ); } -#line 1992 "GrammarParser.cpp" // lalr1.cc:859 +#line 2080 "GrammarParser.cpp" // lalr1.cc:859 break; - case 69: -#line 855 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 77: +#line 911 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< RelationType::Ptr > () = Ast::make< RelationType >( yylhs.location, yystack_[5].value.as< IdentifierPath::Ptr > (), yystack_[3].value.as< Types::Ptr > (), yystack_[1].value.as< Type::Ptr > () ); } -#line 2000 "GrammarParser.cpp" // lalr1.cc:859 +#line 2088 "GrammarParser.cpp" // lalr1.cc:859 break; - case 70: -#line 863 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 78: +#line 919 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< FixedSizedType::Ptr > () = Ast::make< FixedSizedType >( yylhs.location, yystack_[2].value.as< IdentifierPath::Ptr > (), yystack_[0].value.as< Expression::Ptr > () ); } -#line 2008 "GrammarParser.cpp" // lalr1.cc:859 +#line 2096 "GrammarParser.cpp" // lalr1.cc:859 break; - case 71: -#line 871 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 79: +#line 927 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto types = yystack_[2].value.as< Types::Ptr > (); types->add( yystack_[0].value.as< Type::Ptr > () ); yylhs.value.as< Types::Ptr > () = types; } -#line 2018 "GrammarParser.cpp" // lalr1.cc:859 +#line 2106 "GrammarParser.cpp" // lalr1.cc:859 break; - case 72: -#line 877 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 80: +#line 933 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto types = Ast::make< Types >( yylhs.location ); types->add( yystack_[0].value.as< Type::Ptr > () ); yylhs.value.as< Types::Ptr > () = types; } -#line 2028 "GrammarParser.cpp" // lalr1.cc:859 +#line 2116 "GrammarParser.cpp" // lalr1.cc:859 break; - case 73: -#line 887 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 81: +#line 943 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ReferenceAtom::Ptr > (); } -#line 2036 "GrammarParser.cpp" // lalr1.cc:859 +#line 2124 "GrammarParser.cpp" // lalr1.cc:859 break; - case 74: -#line 891 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 82: +#line 947 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ValueAtom::Ptr > (); } -#line 2044 "GrammarParser.cpp" // lalr1.cc:859 +#line 2132 "GrammarParser.cpp" // lalr1.cc:859 break; - case 75: -#line 895 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 83: +#line 951 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ValueAtom::Ptr > (); } -#line 2052 "GrammarParser.cpp" // lalr1.cc:859 +#line 2140 "GrammarParser.cpp" // lalr1.cc:859 break; - case 76: -#line 899 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 84: +#line 955 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ValueAtom::Ptr > (); } -#line 2060 "GrammarParser.cpp" // lalr1.cc:859 +#line 2148 "GrammarParser.cpp" // lalr1.cc:859 break; - case 77: -#line 903 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 85: +#line 959 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ValueAtom::Ptr > (); } -#line 2068 "GrammarParser.cpp" // lalr1.cc:859 +#line 2156 "GrammarParser.cpp" // lalr1.cc:859 break; - case 78: -#line 907 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 86: +#line 963 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ValueAtom::Ptr > (); } -#line 2076 "GrammarParser.cpp" // lalr1.cc:859 +#line 2164 "GrammarParser.cpp" // lalr1.cc:859 break; - case 79: -#line 911 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 87: +#line 967 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< UndefAtom::Ptr > (); } -#line 2084 "GrammarParser.cpp" // lalr1.cc:859 +#line 2172 "GrammarParser.cpp" // lalr1.cc:859 break; - case 80: -#line 915 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 88: +#line 971 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ValueAtom::Ptr > (); } -#line 2092 "GrammarParser.cpp" // lalr1.cc:859 +#line 2180 "GrammarParser.cpp" // lalr1.cc:859 break; - case 81: -#line 923 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 89: +#line 979 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< UndefAtom::Ptr > () = Ast::make< UndefAtom >( yylhs.location ); } -#line 2100 "GrammarParser.cpp" // lalr1.cc:859 +#line 2188 "GrammarParser.cpp" // lalr1.cc:859 break; - case 82: -#line 931 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 90: +#line 987 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { const auto value = libstdhl::get< libcasm_ir::BooleanConstant >( true ); yylhs.value.as< ValueAtom::Ptr > () = Ast::make< ValueAtom >( yylhs.location, value ); } -#line 2109 "GrammarParser.cpp" // lalr1.cc:859 +#line 2197 "GrammarParser.cpp" // lalr1.cc:859 break; - case 83: -#line 936 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 91: +#line 992 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { const auto value = libstdhl::get< libcasm_ir::BooleanConstant >( false ); yylhs.value.as< ValueAtom::Ptr > () = Ast::make< ValueAtom >( yylhs.location, value ); } -#line 2118 "GrammarParser.cpp" // lalr1.cc:859 +#line 2206 "GrammarParser.cpp" // lalr1.cc:859 break; - case 84: -#line 945 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 92: +#line 1001 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { try { @@ -2130,11 +2218,11 @@ namespace libcasm_fe { throw syntax_error( yylhs.location, e.what() ); } } -#line 2134 "GrammarParser.cpp" // lalr1.cc:859 +#line 2222 "GrammarParser.cpp" // lalr1.cc:859 break; - case 85: -#line 961 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 93: +#line 1017 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { try { @@ -2146,11 +2234,11 @@ namespace libcasm_fe { throw syntax_error( yylhs.location, e.what() ); } } -#line 2150 "GrammarParser.cpp" // lalr1.cc:859 +#line 2238 "GrammarParser.cpp" // lalr1.cc:859 break; - case 86: -#line 973 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 94: +#line 1029 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { try { @@ -2162,11 +2250,11 @@ namespace libcasm_fe { throw syntax_error( yylhs.location, e.what() ); } } -#line 2166 "GrammarParser.cpp" // lalr1.cc:859 +#line 2254 "GrammarParser.cpp" // lalr1.cc:859 break; - case 87: -#line 989 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 95: +#line 1045 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { try { @@ -2178,11 +2266,11 @@ namespace libcasm_fe { throw syntax_error( yylhs.location, e.what() ); } } -#line 2182 "GrammarParser.cpp" // lalr1.cc:859 +#line 2270 "GrammarParser.cpp" // lalr1.cc:859 break; - case 88: -#line 1005 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 96: +#line 1061 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { try { @@ -2194,11 +2282,11 @@ namespace libcasm_fe { throw syntax_error( yylhs.location, e.what() ); } } -#line 2198 "GrammarParser.cpp" // lalr1.cc:859 +#line 2286 "GrammarParser.cpp" // lalr1.cc:859 break; - case 89: -#line 1021 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 97: +#line 1077 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { try { @@ -2210,850 +2298,850 @@ namespace libcasm_fe { throw syntax_error( yylhs.location, e.what() ); } } -#line 2214 "GrammarParser.cpp" // lalr1.cc:859 +#line 2302 "GrammarParser.cpp" // lalr1.cc:859 break; - case 90: -#line 1037 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 98: +#line 1093 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< ReferenceAtom::Ptr > () = Ast::make< ReferenceAtom >( yylhs.location, yystack_[0].value.as< IdentifierPath::Ptr > () ); } -#line 2222 "GrammarParser.cpp" // lalr1.cc:859 +#line 2310 "GrammarParser.cpp" // lalr1.cc:859 break; - case 91: -#line 1045 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 99: +#line 1101 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< DirectCallExpression::Ptr > (); } -#line 2230 "GrammarParser.cpp" // lalr1.cc:859 +#line 2318 "GrammarParser.cpp" // lalr1.cc:859 break; - case 92: -#line 1049 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 100: +#line 1105 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< IndirectCallExpression::Ptr > (); } -#line 2238 "GrammarParser.cpp" // lalr1.cc:859 +#line 2326 "GrammarParser.cpp" // lalr1.cc:859 break; - case 93: -#line 1053 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 101: +#line 1109 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< LetExpression::Ptr > (); } -#line 2246 "GrammarParser.cpp" // lalr1.cc:859 +#line 2334 "GrammarParser.cpp" // lalr1.cc:859 break; - case 94: -#line 1057 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 102: +#line 1113 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ConditionalExpression::Ptr > (); } -#line 2254 "GrammarParser.cpp" // lalr1.cc:859 +#line 2342 "GrammarParser.cpp" // lalr1.cc:859 break; - case 95: -#line 1061 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 103: +#line 1117 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ChooseExpression::Ptr > (); } -#line 2262 "GrammarParser.cpp" // lalr1.cc:859 +#line 2350 "GrammarParser.cpp" // lalr1.cc:859 break; - case 96: -#line 1065 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 104: +#line 1121 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< UniversalQuantifierExpression::Ptr > (); } -#line 2270 "GrammarParser.cpp" // lalr1.cc:859 +#line 2358 "GrammarParser.cpp" // lalr1.cc:859 break; - case 97: -#line 1069 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 105: +#line 1125 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ExistentialQuantifierExpression::Ptr > (); } -#line 2278 "GrammarParser.cpp" // lalr1.cc:859 +#line 2366 "GrammarParser.cpp" // lalr1.cc:859 break; - case 98: -#line 1073 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 106: +#line 1129 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< Expression::Ptr > (); } -#line 2286 "GrammarParser.cpp" // lalr1.cc:859 +#line 2374 "GrammarParser.cpp" // lalr1.cc:859 break; - case 99: -#line 1077 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 107: +#line 1133 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ListExpression::Ptr > (); } -#line 2294 "GrammarParser.cpp" // lalr1.cc:859 +#line 2382 "GrammarParser.cpp" // lalr1.cc:859 break; - case 100: -#line 1081 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 108: +#line 1137 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< RangeExpression::Ptr > (); } -#line 2302 "GrammarParser.cpp" // lalr1.cc:859 +#line 2390 "GrammarParser.cpp" // lalr1.cc:859 break; - case 101: -#line 1085 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 109: +#line 1141 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< Expression::Ptr > (); } -#line 2310 "GrammarParser.cpp" // lalr1.cc:859 +#line 2398 "GrammarParser.cpp" // lalr1.cc:859 break; - case 102: -#line 1093 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 110: +#line 1149 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[1].value.as< Expression::Ptr > (); } -#line 2318 "GrammarParser.cpp" // lalr1.cc:859 +#line 2406 "GrammarParser.cpp" // lalr1.cc:859 break; - case 103: -#line 1097 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 111: +#line 1153 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = nullptr; } -#line 2326 "GrammarParser.cpp" // lalr1.cc:859 +#line 2414 "GrammarParser.cpp" // lalr1.cc:859 break; - case 104: -#line 1101 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 112: +#line 1157 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< Expression::Ptr > (); } -#line 2334 "GrammarParser.cpp" // lalr1.cc:859 +#line 2422 "GrammarParser.cpp" // lalr1.cc:859 break; - case 105: -#line 1105 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 113: +#line 1161 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = Ast::make< UnaryExpression >( yylhs.location, yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::INV_INSTRUCTION ); } -#line 2342 "GrammarParser.cpp" // lalr1.cc:859 +#line 2430 "GrammarParser.cpp" // lalr1.cc:859 break; - case 106: -#line 1109 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 114: +#line 1165 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::ADD_INSTRUCTION ); } -#line 2350 "GrammarParser.cpp" // lalr1.cc:859 +#line 2438 "GrammarParser.cpp" // lalr1.cc:859 break; - case 107: -#line 1113 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 115: +#line 1169 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::SUB_INSTRUCTION ); } -#line 2358 "GrammarParser.cpp" // lalr1.cc:859 +#line 2446 "GrammarParser.cpp" // lalr1.cc:859 break; - case 108: -#line 1117 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 116: +#line 1173 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::MUL_INSTRUCTION ); } -#line 2366 "GrammarParser.cpp" // lalr1.cc:859 +#line 2454 "GrammarParser.cpp" // lalr1.cc:859 break; - case 109: -#line 1121 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 117: +#line 1177 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::DIV_INSTRUCTION ); } -#line 2374 "GrammarParser.cpp" // lalr1.cc:859 +#line 2462 "GrammarParser.cpp" // lalr1.cc:859 break; - case 110: -#line 1125 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 118: +#line 1181 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::MOD_INSTRUCTION ); } -#line 2382 "GrammarParser.cpp" // lalr1.cc:859 +#line 2470 "GrammarParser.cpp" // lalr1.cc:859 break; - case 111: -#line 1129 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 119: +#line 1185 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::POW_INSTRUCTION ); } -#line 2390 "GrammarParser.cpp" // lalr1.cc:859 +#line 2478 "GrammarParser.cpp" // lalr1.cc:859 break; - case 112: -#line 1133 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 120: +#line 1189 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::NEQ_INSTRUCTION ); } -#line 2398 "GrammarParser.cpp" // lalr1.cc:859 +#line 2486 "GrammarParser.cpp" // lalr1.cc:859 break; - case 113: -#line 1137 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 121: +#line 1193 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::EQU_INSTRUCTION ); } -#line 2406 "GrammarParser.cpp" // lalr1.cc:859 +#line 2494 "GrammarParser.cpp" // lalr1.cc:859 break; - case 114: -#line 1141 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 122: +#line 1197 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::LTH_INSTRUCTION ); } -#line 2414 "GrammarParser.cpp" // lalr1.cc:859 +#line 2502 "GrammarParser.cpp" // lalr1.cc:859 break; - case 115: -#line 1145 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 123: +#line 1201 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::GTH_INSTRUCTION ); } -#line 2422 "GrammarParser.cpp" // lalr1.cc:859 +#line 2510 "GrammarParser.cpp" // lalr1.cc:859 break; - case 116: -#line 1149 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 124: +#line 1205 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::LEQ_INSTRUCTION ); } -#line 2430 "GrammarParser.cpp" // lalr1.cc:859 +#line 2518 "GrammarParser.cpp" // lalr1.cc:859 break; - case 117: -#line 1153 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 125: +#line 1209 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::GEQ_INSTRUCTION ); } -#line 2438 "GrammarParser.cpp" // lalr1.cc:859 +#line 2526 "GrammarParser.cpp" // lalr1.cc:859 break; - case 118: -#line 1157 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 126: +#line 1213 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::OR_INSTRUCTION ); } -#line 2446 "GrammarParser.cpp" // lalr1.cc:859 +#line 2534 "GrammarParser.cpp" // lalr1.cc:859 break; - case 119: -#line 1161 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 127: +#line 1217 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::XOR_INSTRUCTION ); } -#line 2454 "GrammarParser.cpp" // lalr1.cc:859 +#line 2542 "GrammarParser.cpp" // lalr1.cc:859 break; - case 120: -#line 1165 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 128: +#line 1221 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::AND_INSTRUCTION ); } -#line 2462 "GrammarParser.cpp" // lalr1.cc:859 +#line 2550 "GrammarParser.cpp" // lalr1.cc:859 break; - case 121: -#line 1169 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 129: +#line 1225 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::IMP_INSTRUCTION ); } -#line 2470 "GrammarParser.cpp" // lalr1.cc:859 +#line 2558 "GrammarParser.cpp" // lalr1.cc:859 break; - case 122: -#line 1173 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 130: +#line 1229 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::IMP_INSTRUCTION ); } -#line 2478 "GrammarParser.cpp" // lalr1.cc:859 +#line 2566 "GrammarParser.cpp" // lalr1.cc:859 break; - case 123: -#line 1177 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 131: +#line 1233 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = Ast::make< UnaryExpression >( yylhs.location, yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::NOT_INSTRUCTION ); } -#line 2486 "GrammarParser.cpp" // lalr1.cc:859 +#line 2574 "GrammarParser.cpp" // lalr1.cc:859 break; - case 124: -#line 1185 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 132: +#line 1241 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< RangeExpression::Ptr > () = Ast::make< RangeExpression >( yylhs.location, yystack_[3].value.as< Expression::Ptr > (), yystack_[1].value.as< Expression::Ptr > () ); } -#line 2494 "GrammarParser.cpp" // lalr1.cc:859 +#line 2582 "GrammarParser.cpp" // lalr1.cc:859 break; - case 125: -#line 1193 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 133: +#line 1249 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { const auto expressions = Ast::make< Expressions >( yylhs.location ); yylhs.value.as< ListExpression::Ptr > () = Ast::make< ListExpression >( yylhs.location, expressions ); } -#line 2503 "GrammarParser.cpp" // lalr1.cc:859 +#line 2591 "GrammarParser.cpp" // lalr1.cc:859 break; - case 126: -#line 1198 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 134: +#line 1254 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< ListExpression::Ptr > () = Ast::make< ListExpression >( yylhs.location, yystack_[1].value.as< Expressions::Ptr > () ); } -#line 2511 "GrammarParser.cpp" // lalr1.cc:859 +#line 2599 "GrammarParser.cpp" // lalr1.cc:859 break; - case 127: -#line 1202 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 135: +#line 1258 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< ListExpression::Ptr > () = nullptr; } -#line 2519 "GrammarParser.cpp" // lalr1.cc:859 +#line 2607 "GrammarParser.cpp" // lalr1.cc:859 break; - case 128: -#line 1210 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 136: +#line 1266 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto expressions = yystack_[2].value.as< Expressions::Ptr > (); expressions->add( yystack_[0].value.as< Expression::Ptr > () ); yylhs.value.as< Expressions::Ptr > () = expressions; } -#line 2529 "GrammarParser.cpp" // lalr1.cc:859 +#line 2617 "GrammarParser.cpp" // lalr1.cc:859 break; - case 129: -#line 1216 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 137: +#line 1272 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { const auto expressions = Ast::make< Expressions >( yylhs.location ); expressions->add( yystack_[0].value.as< Expression::Ptr > () ); yylhs.value.as< Expressions::Ptr > () = expressions; } -#line 2539 "GrammarParser.cpp" // lalr1.cc:859 +#line 2627 "GrammarParser.cpp" // lalr1.cc:859 break; - case 130: -#line 1226 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 138: +#line 1282 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expressions::Ptr > () = yystack_[1].value.as< Expressions::Ptr > (); } -#line 2547 "GrammarParser.cpp" // lalr1.cc:859 +#line 2635 "GrammarParser.cpp" // lalr1.cc:859 break; - case 131: -#line 1230 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 139: +#line 1286 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expressions::Ptr > () = nullptr; } -#line 2555 "GrammarParser.cpp" // lalr1.cc:859 +#line 2643 "GrammarParser.cpp" // lalr1.cc:859 break; - case 132: -#line 1234 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 140: +#line 1290 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { const auto expressions = Ast::make< Expressions >( yylhs.location ); yylhs.value.as< Expressions::Ptr > () = expressions; } -#line 2564 "GrammarParser.cpp" // lalr1.cc:859 +#line 2652 "GrammarParser.cpp" // lalr1.cc:859 break; - case 133: -#line 1243 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 141: +#line 1299 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { const auto expressions = yystack_[3].value.as< Expressions::Ptr > (); expressions->add( yystack_[1].value.as< Expression::Ptr > () ); yylhs.value.as< Expressions::Ptr > () = expressions; } -#line 2574 "GrammarParser.cpp" // lalr1.cc:859 +#line 2662 "GrammarParser.cpp" // lalr1.cc:859 break; - case 134: -#line 1253 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 142: +#line 1309 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { const auto arguments = Ast::make< Expressions >( yylhs.location ); yylhs.value.as< DirectCallExpression::Ptr > () = Ast::make< DirectCallExpression >( yylhs.location, yystack_[0].value.as< IdentifierPath::Ptr > (), arguments ); } -#line 2583 "GrammarParser.cpp" // lalr1.cc:859 +#line 2671 "GrammarParser.cpp" // lalr1.cc:859 break; - case 135: -#line 1258 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 143: +#line 1314 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< DirectCallExpression::Ptr > () = Ast::make< DirectCallExpression >( yylhs.location, yystack_[1].value.as< IdentifierPath::Ptr > (), yystack_[0].value.as< Expressions::Ptr > () ); } -#line 2591 "GrammarParser.cpp" // lalr1.cc:859 +#line 2679 "GrammarParser.cpp" // lalr1.cc:859 break; - case 136: -#line 1266 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 144: +#line 1322 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< IndirectCallExpression::Ptr > () = Ast::make< IndirectCallExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expressions::Ptr > () ); } -#line 2599 "GrammarParser.cpp" // lalr1.cc:859 +#line 2687 "GrammarParser.cpp" // lalr1.cc:859 break; - case 137: -#line 1274 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 145: +#line 1330 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< LetExpression::Ptr > () = Ast::make< LetExpression >( yylhs.location, yystack_[4].value.as< VariableDefinition::Ptr > (), yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > () ); } -#line 2607 "GrammarParser.cpp" // lalr1.cc:859 +#line 2695 "GrammarParser.cpp" // lalr1.cc:859 break; - case 138: -#line 1282 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 146: +#line 1338 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< ConditionalExpression::Ptr > () = Ast::make< ConditionalExpression >( yylhs.location, yystack_[4].value.as< Expression::Ptr > (), yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > () ); } -#line 2615 "GrammarParser.cpp" // lalr1.cc:859 +#line 2703 "GrammarParser.cpp" // lalr1.cc:859 break; - case 139: -#line 1290 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 147: +#line 1346 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< ChooseExpression::Ptr > () = Ast::make< ChooseExpression >( yylhs.location, yystack_[4].value.as< VariableDefinition::Ptr > (), yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > () ); } -#line 2623 "GrammarParser.cpp" // lalr1.cc:859 +#line 2711 "GrammarParser.cpp" // lalr1.cc:859 break; - case 140: -#line 1298 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 148: +#line 1354 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< UniversalQuantifierExpression::Ptr > () = Ast::make< UniversalQuantifierExpression >( yylhs.location, yystack_[4].value.as< VariableDefinition::Ptr > (), yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > () ); } -#line 2631 "GrammarParser.cpp" // lalr1.cc:859 +#line 2719 "GrammarParser.cpp" // lalr1.cc:859 break; - case 141: -#line 1306 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 149: +#line 1362 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< ExistentialQuantifierExpression::Ptr > () = Ast::make< ExistentialQuantifierExpression >( yylhs.location, yystack_[4].value.as< VariableDefinition::Ptr > (), yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > () ); } -#line 2639 "GrammarParser.cpp" // lalr1.cc:859 +#line 2727 "GrammarParser.cpp" // lalr1.cc:859 break; - case 142: -#line 1314 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 150: +#line 1370 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< RuleDefinition::Ptr > () = Ast::make< RuleDefinition >( yylhs.location, yystack_[3].value.as< Identifier::Ptr > (), yystack_[2].value.as< NodeList< VariableDefinition >::Ptr > (), createVoidType( yylhs.location ), wrapInBlockRule( yystack_[0].value.as< Rule::Ptr > () ) ); } -#line 2648 "GrammarParser.cpp" // lalr1.cc:859 +#line 2736 "GrammarParser.cpp" // lalr1.cc:859 break; - case 143: -#line 1319 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 151: +#line 1375 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< RuleDefinition::Ptr > () = Ast::make< RuleDefinition >( yylhs.location, yystack_[5].value.as< Identifier::Ptr > (), yystack_[4].value.as< NodeList< VariableDefinition >::Ptr > (), yystack_[2].value.as< Type::Ptr > (), wrapInBlockRule( yystack_[0].value.as< Rule::Ptr > () ) ); } -#line 2657 "GrammarParser.cpp" // lalr1.cc:859 +#line 2745 "GrammarParser.cpp" // lalr1.cc:859 break; - case 144: -#line 1328 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 152: +#line 1384 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< SkipRule::Ptr > (); } -#line 2665 "GrammarParser.cpp" // lalr1.cc:859 +#line 2753 "GrammarParser.cpp" // lalr1.cc:859 break; - case 145: -#line 1332 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 153: +#line 1388 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< ConditionalRule::Ptr > (); } -#line 2673 "GrammarParser.cpp" // lalr1.cc:859 +#line 2761 "GrammarParser.cpp" // lalr1.cc:859 break; - case 146: -#line 1336 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 154: +#line 1392 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< CaseRule::Ptr > (); } -#line 2681 "GrammarParser.cpp" // lalr1.cc:859 +#line 2769 "GrammarParser.cpp" // lalr1.cc:859 break; - case 147: -#line 1340 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 155: +#line 1396 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< LetRule::Ptr > (); } -#line 2689 "GrammarParser.cpp" // lalr1.cc:859 +#line 2777 "GrammarParser.cpp" // lalr1.cc:859 break; - case 148: -#line 1344 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 156: +#line 1400 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< ForallRule::Ptr > (); } -#line 2697 "GrammarParser.cpp" // lalr1.cc:859 +#line 2785 "GrammarParser.cpp" // lalr1.cc:859 break; - case 149: -#line 1348 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 157: +#line 1404 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< ChooseRule::Ptr > (); } -#line 2705 "GrammarParser.cpp" // lalr1.cc:859 +#line 2793 "GrammarParser.cpp" // lalr1.cc:859 break; - case 150: -#line 1352 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 158: +#line 1408 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< IterateRule::Ptr > (); } -#line 2713 "GrammarParser.cpp" // lalr1.cc:859 +#line 2801 "GrammarParser.cpp" // lalr1.cc:859 break; - case 151: -#line 1356 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 159: +#line 1412 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< BlockRule::Ptr > (); } -#line 2721 "GrammarParser.cpp" // lalr1.cc:859 +#line 2809 "GrammarParser.cpp" // lalr1.cc:859 break; - case 152: -#line 1360 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 160: +#line 1416 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< SequenceRule::Ptr > (); } -#line 2729 "GrammarParser.cpp" // lalr1.cc:859 +#line 2817 "GrammarParser.cpp" // lalr1.cc:859 break; - case 153: -#line 1364 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 161: +#line 1420 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< UpdateRule::Ptr > (); } -#line 2737 "GrammarParser.cpp" // lalr1.cc:859 +#line 2825 "GrammarParser.cpp" // lalr1.cc:859 break; - case 154: -#line 1368 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 162: +#line 1424 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< CallRule::Ptr > (); } -#line 2745 "GrammarParser.cpp" // lalr1.cc:859 +#line 2833 "GrammarParser.cpp" // lalr1.cc:859 break; - case 155: -#line 1376 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 163: +#line 1432 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto rules = yystack_[1].value.as< Rules::Ptr > (); rules->add( yystack_[0].value.as< Rule::Ptr > () ); yylhs.value.as< Rules::Ptr > () = rules; } -#line 2755 "GrammarParser.cpp" // lalr1.cc:859 +#line 2843 "GrammarParser.cpp" // lalr1.cc:859 break; - case 156: -#line 1382 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 164: +#line 1438 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto rules = Ast::make< Rules >( yylhs.location ); rules->add( yystack_[0].value.as< Rule::Ptr > () ); yylhs.value.as< Rules::Ptr > () = rules; } -#line 2765 "GrammarParser.cpp" // lalr1.cc:859 +#line 2853 "GrammarParser.cpp" // lalr1.cc:859 break; - case 157: -#line 1392 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 165: +#line 1448 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< SkipRule::Ptr > () = Ast::make< SkipRule >( yylhs.location ); } -#line 2773 "GrammarParser.cpp" // lalr1.cc:859 +#line 2861 "GrammarParser.cpp" // lalr1.cc:859 break; - case 158: -#line 1400 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 166: +#line 1456 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< ConditionalRule::Ptr > () = Ast::make< ConditionalRule >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Rule::Ptr > () ); } -#line 2781 "GrammarParser.cpp" // lalr1.cc:859 +#line 2869 "GrammarParser.cpp" // lalr1.cc:859 break; - case 159: -#line 1404 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 167: +#line 1460 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< ConditionalRule::Ptr > () = Ast::make< ConditionalRule >( yylhs.location, yystack_[4].value.as< Expression::Ptr > (), yystack_[2].value.as< Rule::Ptr > (), yystack_[0].value.as< Rule::Ptr > () ); } -#line 2789 "GrammarParser.cpp" // lalr1.cc:859 +#line 2877 "GrammarParser.cpp" // lalr1.cc:859 break; - case 160: -#line 1412 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 168: +#line 1468 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< CaseRule::Ptr > () = Ast::make< CaseRule >( yylhs.location, yystack_[4].value.as< Expression::Ptr > (), yystack_[1].value.as< Cases::Ptr > () ); } -#line 2797 "GrammarParser.cpp" // lalr1.cc:859 +#line 2885 "GrammarParser.cpp" // lalr1.cc:859 break; - case 161: -#line 1416 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 169: +#line 1472 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< CaseRule::Ptr > () = nullptr; } -#line 2805 "GrammarParser.cpp" // lalr1.cc:859 +#line 2893 "GrammarParser.cpp" // lalr1.cc:859 break; - case 162: -#line 1424 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 170: +#line 1480 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Case::Ptr > () = Ast::make< DefaultCase >( yylhs.location, yystack_[0].value.as< Rule::Ptr > () ); } -#line 2813 "GrammarParser.cpp" // lalr1.cc:859 +#line 2901 "GrammarParser.cpp" // lalr1.cc:859 break; - case 163: -#line 1428 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 171: +#line 1484 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Case::Ptr > () = Ast::make< DefaultCase >( yylhs.location, yystack_[0].value.as< Rule::Ptr > () ); } -#line 2821 "GrammarParser.cpp" // lalr1.cc:859 +#line 2909 "GrammarParser.cpp" // lalr1.cc:859 break; - case 164: -#line 1432 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 172: +#line 1488 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Case::Ptr > () = Ast::make< ExpressionCase >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Rule::Ptr > () ); } -#line 2829 "GrammarParser.cpp" // lalr1.cc:859 +#line 2917 "GrammarParser.cpp" // lalr1.cc:859 break; - case 165: -#line 1440 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 173: +#line 1496 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto cases = yystack_[0].value.as< Cases::Ptr > (); cases->add( yystack_[1].value.as< Case::Ptr > () ); yylhs.value.as< Cases::Ptr > () = cases; } -#line 2839 "GrammarParser.cpp" // lalr1.cc:859 +#line 2927 "GrammarParser.cpp" // lalr1.cc:859 break; - case 166: -#line 1446 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 174: +#line 1502 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto cases = Ast::make< Cases >( yylhs.location ); cases->add( yystack_[0].value.as< Case::Ptr > () ); yylhs.value.as< Cases::Ptr > () = cases; } -#line 2849 "GrammarParser.cpp" // lalr1.cc:859 +#line 2937 "GrammarParser.cpp" // lalr1.cc:859 break; - case 167: -#line 1456 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 175: +#line 1512 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< LetRule::Ptr > () = Ast::make< LetRule >( yylhs.location, yystack_[4].value.as< VariableDefinition::Ptr > (), yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Rule::Ptr > () ); } -#line 2857 "GrammarParser.cpp" // lalr1.cc:859 +#line 2945 "GrammarParser.cpp" // lalr1.cc:859 break; - case 168: -#line 1464 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 176: +#line 1520 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< ForallRule::Ptr > () = Ast::make< ForallRule >( yylhs.location, yystack_[4].value.as< VariableDefinition::Ptr > (), yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Rule::Ptr > () ); } -#line 2865 "GrammarParser.cpp" // lalr1.cc:859 +#line 2953 "GrammarParser.cpp" // lalr1.cc:859 break; - case 169: -#line 1472 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 177: +#line 1528 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< ChooseRule::Ptr > () = Ast::make< ChooseRule >( yylhs.location, yystack_[4].value.as< VariableDefinition::Ptr > (), yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Rule::Ptr > () ); } -#line 2873 "GrammarParser.cpp" // lalr1.cc:859 +#line 2961 "GrammarParser.cpp" // lalr1.cc:859 break; - case 170: -#line 1480 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 178: +#line 1536 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< IterateRule::Ptr > () = Ast::make< IterateRule >( yylhs.location, yystack_[0].value.as< Rule::Ptr > () ); } -#line 2881 "GrammarParser.cpp" // lalr1.cc:859 +#line 2969 "GrammarParser.cpp" // lalr1.cc:859 break; - case 171: -#line 1488 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 179: +#line 1544 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< BlockRule::Ptr > () = Ast::make< BlockRule >( yylhs.location, yystack_[1].value.as< Rules::Ptr > () ); } -#line 2889 "GrammarParser.cpp" // lalr1.cc:859 +#line 2977 "GrammarParser.cpp" // lalr1.cc:859 break; - case 172: -#line 1492 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 180: +#line 1548 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< BlockRule::Ptr > () = Ast::make< BlockRule >( yylhs.location, yystack_[1].value.as< Rules::Ptr > () ); } -#line 2897 "GrammarParser.cpp" // lalr1.cc:859 +#line 2985 "GrammarParser.cpp" // lalr1.cc:859 break; - case 173: -#line 1496 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 181: +#line 1552 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< BlockRule::Ptr > () = nullptr; yyerrok; } -#line 2906 "GrammarParser.cpp" // lalr1.cc:859 +#line 2994 "GrammarParser.cpp" // lalr1.cc:859 break; - case 174: -#line 1501 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 182: +#line 1557 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< BlockRule::Ptr > () = nullptr; yyerrok; } -#line 2915 "GrammarParser.cpp" // lalr1.cc:859 +#line 3003 "GrammarParser.cpp" // lalr1.cc:859 break; - case 175: -#line 1510 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 183: +#line 1566 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< SequenceRule::Ptr > () = Ast::make< SequenceRule >( yylhs.location, yystack_[1].value.as< Rules::Ptr > () ); } -#line 2923 "GrammarParser.cpp" // lalr1.cc:859 +#line 3011 "GrammarParser.cpp" // lalr1.cc:859 break; - case 176: -#line 1514 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 184: +#line 1570 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< SequenceRule::Ptr > () = Ast::make< SequenceRule >( yylhs.location, yystack_[1].value.as< Rules::Ptr > () ); } -#line 2931 "GrammarParser.cpp" // lalr1.cc:859 +#line 3019 "GrammarParser.cpp" // lalr1.cc:859 break; - case 177: -#line 1518 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 185: +#line 1574 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< SequenceRule::Ptr > () = nullptr; yyerrok; } -#line 2940 "GrammarParser.cpp" // lalr1.cc:859 +#line 3028 "GrammarParser.cpp" // lalr1.cc:859 break; - case 178: -#line 1523 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 186: +#line 1579 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< SequenceRule::Ptr > () = nullptr; yyerrok; } -#line 2949 "GrammarParser.cpp" // lalr1.cc:859 +#line 3037 "GrammarParser.cpp" // lalr1.cc:859 break; - case 179: -#line 1532 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 187: +#line 1588 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { const auto function = yystack_[2].value.as< DirectCallExpression::Ptr > (); function->setTargetType( CallExpression::TargetType::FUNCTION ); yylhs.value.as< UpdateRule::Ptr > () = Ast::make< UpdateRule >( yylhs.location, function, yystack_[0].value.as< Expression::Ptr > () ); } -#line 2959 "GrammarParser.cpp" // lalr1.cc:859 +#line 3047 "GrammarParser.cpp" // lalr1.cc:859 break; - case 180: -#line 1542 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 188: +#line 1598 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { const std::set< CallExpression::TargetType > allowedCallTargetTypes{ CallExpression::TargetType::RULE }; yylhs.value.as< CallRule::Ptr > () = Ast::make< CallRule >( yylhs.location, yystack_[0].value.as< DirectCallExpression::Ptr > (), allowedCallTargetTypes ); } -#line 2969 "GrammarParser.cpp" // lalr1.cc:859 +#line 3057 "GrammarParser.cpp" // lalr1.cc:859 break; - case 181: -#line 1548 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 189: +#line 1604 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { const std::set< CallExpression::TargetType > allowedCallTargetTypes{ CallExpression::TargetType::DERIVED, CallExpression::TargetType::BUILTIN }; yylhs.value.as< CallRule::Ptr > () = Ast::make< CallRule >( yylhs.location, yystack_[0].value.as< DirectCallExpression::Ptr > (), allowedCallTargetTypes ); } -#line 2980 "GrammarParser.cpp" // lalr1.cc:859 +#line 3068 "GrammarParser.cpp" // lalr1.cc:859 break; - case 182: -#line 1555 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 190: +#line 1611 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { const std::set< CallExpression::TargetType > allowedCallTargetTypes{ CallExpression::TargetType::RULE }; yylhs.value.as< CallRule::Ptr > () = Ast::make< CallRule >( yylhs.location, yystack_[0].value.as< IndirectCallExpression::Ptr > (), allowedCallTargetTypes ); } -#line 2990 "GrammarParser.cpp" // lalr1.cc:859 +#line 3078 "GrammarParser.cpp" // lalr1.cc:859 break; - case 183: -#line 1561 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 191: +#line 1617 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { const std::set< CallExpression::TargetType > allowedCallTargetTypes{ CallExpression::TargetType::DERIVED, CallExpression::TargetType::BUILTIN }; yylhs.value.as< CallRule::Ptr > () = Ast::make< CallRule >( yylhs.location, yystack_[0].value.as< IndirectCallExpression::Ptr > (), allowedCallTargetTypes ); } -#line 3001 "GrammarParser.cpp" // lalr1.cc:859 +#line 3089 "GrammarParser.cpp" // lalr1.cc:859 break; - case 184: -#line 1572 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 192: +#line 1628 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Attribute::Ptr > () = yystack_[0].value.as< BasicAttribute::Ptr > (); } -#line 3009 "GrammarParser.cpp" // lalr1.cc:859 +#line 3097 "GrammarParser.cpp" // lalr1.cc:859 break; - case 185: -#line 1576 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 193: +#line 1632 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Attribute::Ptr > () = yystack_[0].value.as< ExpressionAttribute::Ptr > (); } -#line 3017 "GrammarParser.cpp" // lalr1.cc:859 +#line 3105 "GrammarParser.cpp" // lalr1.cc:859 break; - case 186: -#line 1584 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 194: +#line 1640 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto attributes = yystack_[2].value.as< Attributes::Ptr > (); attributes->add( yystack_[0].value.as< Attribute::Ptr > () ); yylhs.value.as< Attributes::Ptr > () = attributes; } -#line 3027 "GrammarParser.cpp" // lalr1.cc:859 +#line 3115 "GrammarParser.cpp" // lalr1.cc:859 break; - case 187: -#line 1590 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 195: +#line 1646 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto attributes = Ast::make< Attributes >( yylhs.location ); attributes->add( yystack_[0].value.as< Attribute::Ptr > () ); yylhs.value.as< Attributes::Ptr > () = attributes; } -#line 3037 "GrammarParser.cpp" // lalr1.cc:859 +#line 3125 "GrammarParser.cpp" // lalr1.cc:859 break; - case 188: -#line 1600 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 196: +#line 1656 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< BasicAttribute::Ptr > () = Ast::make< BasicAttribute >( yylhs.location, yystack_[0].value.as< Identifier::Ptr > () ); } -#line 3045 "GrammarParser.cpp" // lalr1.cc:859 +#line 3133 "GrammarParser.cpp" // lalr1.cc:859 break; - case 189: -#line 1608 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 197: +#line 1664 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< ExpressionAttribute::Ptr > () = Ast::make< ExpressionAttribute >( yylhs.location, yystack_[1].value.as< Identifier::Ptr > (), yystack_[0].value.as< Expression::Ptr > () ); } -#line 3053 "GrammarParser.cpp" // lalr1.cc:859 +#line 3141 "GrammarParser.cpp" // lalr1.cc:859 break; -#line 3057 "GrammarParser.cpp" // lalr1.cc:859 +#line 3145 "GrammarParser.cpp" // lalr1.cc:859 default: break; } @@ -3308,606 +3396,634 @@ namespace libcasm_fe { } - const short int Parser::yypact_ninf_ = -219; + const short int Parser::yypact_ninf_ = -269; - const signed char Parser::yytable_ninf_ = -73; + const signed char Parser::yytable_ninf_ = -81; const short int Parser::yypact_[] = { - 28, 184, 15, -219, -6, 9, 9, 9, 9, 9, - 9, 9, -219, -219, 658, -219, -219, -219, -219, -219, - -219, -219, -219, -219, 977, 9, -219, -219, -7, -219, - 16, -3, 16, 25, 35, 42, 1038, -219, 10, -219, - -219, -219, 7, 7, 7, 1038, 7, -219, -219, -219, - 1038, 1038, 1038, 453, 514, 4, -219, -219, -219, -219, - -219, -219, -219, 69, 13, 93, -219, -219, -219, -219, - -219, -219, -219, -219, -219, 1415, -219, -219, -219, 94, - -219, -219, -219, -219, -219, -219, -219, -219, 9, 6, - 95, 108, -22, 4, 113, 114, 453, 1679, 445, 9, - 9, 126, -219, 120, 162, 174, 1214, 175, -219, -219, - -219, 152, 1038, 1448, 145, 157, -219, 1481, 11, -219, - 977, -219, 575, -219, 1038, 1038, 1038, 1038, 1038, 1038, - 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, - 1038, 1038, 1038, -219, 154, -219, -2, 4, 9, 884, - 4, 153, 147, 19, -219, -219, -219, -219, -219, 116, - 41, 1448, -219, -219, 12, 4, 1038, 1038, 1038, 1038, - 1038, -219, 1514, -219, 1038, -219, 1038, -219, 1038, -219, - 163, -219, 1679, 1, 1816, 1745, 1797, 1712, 52, 52, - 1835, 144, 144, 155, 155, 155, -219, 1679, 1712, 1835, - 144, 144, 1679, -219, -219, 7, 170, -219, 71, 612, - 659, -219, 7, 7, 7, 884, 5, 1038, 1038, 159, - 696, 733, 151, -219, -219, -219, -219, -219, -219, -219, - -219, -219, -219, -219, -219, -219, 176, 4, 4, 4, - 1038, -219, 87, 9, 9, -219, -219, 106, -219, -219, - 9, -219, 111, 1349, 1103, 1283, 1382, 93, 1547, 1580, - 1679, -219, -219, -219, 1038, -219, 9, 207, -219, 770, - 206, 319, 181, 208, 209, -219, -219, -219, 1249, 1316, - 179, 807, 165, 847, 1038, 884, -219, 216, 173, -42, - 75, 1778, -219, 116, 30, 77, -219, 41, -219, 1038, - 1038, 1038, 1038, 1038, -219, -219, -219, 1679, -219, -219, - -219, -219, -219, -219, 1038, 1038, 1038, 884, 189, -219, - -219, -219, -219, 1679, -219, 197, 238, 4, 4, -219, - -219, 4, 4, -219, 1679, -219, 1679, 1679, -219, 1065, - 1141, 1179, 224, 392, 1038, 203, -219, 199, -219, 192, - 193, 884, 884, 884, 884, 210, 211, 222, 1613, 916, - 225, 1646, 977, -219, 4, 4, -219, -219, -219, -219, - -219, 884, 884, 884, -219, -219, -219, 226, -219, -219, - -219, -219, -219, -219 + 19, 321, 37, -269, -3, -11, -11, -11, -11, -11, + -11, 1, -11, -269, -269, 193, -269, -269, -269, -269, + -269, -269, -269, -269, -269, -27, -269, 934, -11, -269, + -269, -9, -269, 23, 17, 23, 29, 62, 69, 10, + 103, -269, -269, -269, -269, 1001, -269, -31, -269, -269, + -269, -11, -12, -12, -12, 1001, -12, -269, -269, -269, + 1001, 1001, 1001, 492, 559, 1, -269, -269, -269, -269, + -269, -269, -269, 48, 31, 105, -269, -269, -269, -269, + -269, -269, -269, -269, -269, 1529, -269, -269, -269, 9, + -269, -269, -269, -269, -269, -269, -269, -269, -11, 8, + 84, 102, -16, 1, 107, 108, 1, 1, 1001, 110, + 492, 1793, 724, -11, -269, -11, 114, -269, 109, 135, + 147, 1328, 148, -269, -269, -269, 127, 1001, 1562, 120, + 137, -269, 1595, 2, -269, 934, -269, 626, -269, 1001, + 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, + 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, -269, 146, + -269, 16, 1, -11, 1180, 1, 124, 129, 34, -269, + 58, 45, 155, 140, 54, 89, 1859, 86, 1562, -269, + -269, 44, 1, 1001, 1001, 1001, 1001, 1001, -269, 1628, + -269, 1001, -269, 1001, -269, 1001, -269, 159, -269, 1793, + 28, 463, 1892, 1920, 1826, 119, 119, 370, 167, 167, + 153, 153, 153, -269, 1793, 1826, 370, 167, 167, 1793, + -269, -269, -12, 170, -269, 55, 693, 733, -269, -12, + -12, -12, 1180, 6, 1001, 1001, 158, 795, 835, 150, + -269, -269, -269, -269, -269, -269, -269, -269, -269, -269, + -269, -269, -269, 173, 1, 1, -269, 61, -11, -11, + -269, -269, 22, -269, -269, 172, 1, 1, -269, -269, + -269, 27, -269, -11, -269, 730, 1463, 1217, 1397, 1496, + 105, 1661, 1694, 1793, -269, -269, -269, 1001, -269, -11, + 205, -269, 1038, 207, 1078, 186, 212, 213, -269, -269, + -269, 1363, 1430, 183, 1100, 163, 1140, 1001, 1180, -269, + 228, -269, 58, 52, 56, -269, -269, 86, 180, -269, + -269, -269, -269, 1001, 1001, 1001, 1001, 1001, -269, -269, + -269, 1793, -269, -269, -269, -269, -269, -269, 1001, 1001, + 1001, 1180, 188, -269, -269, -269, -269, 1793, -269, 189, + 233, -269, 1, 1, 41, -269, 1793, -269, 1793, 1793, + -269, 1177, 1255, 1293, 217, 425, 1001, 197, -269, 185, + 192, -269, 1180, 1180, 1180, 1180, 202, 206, 210, 1727, + 867, 208, 1760, 934, 1, 1, -269, -269, -269, -269, + -269, 1180, 1180, 1180, -269, -269, -269, 216, -269, -269, + -269, -269, -269, -269 }; const unsigned char Parser::yydefact_[] = { - 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, - 0, 0, 11, 13, 0, 3, 15, 4, 6, 7, - 8, 5, 1, 47, 34, 0, 46, 51, 52, 26, - 62, 0, 62, 0, 0, 0, 188, 187, 0, 184, - 185, 12, 0, 0, 0, 0, 0, 81, 83, 82, - 0, 0, 0, 0, 0, 0, 85, 86, 87, 89, - 88, 84, 32, 33, 0, 134, 101, 79, 80, 78, - 74, 75, 76, 77, 73, 28, 98, 100, 99, 0, - 91, 92, 93, 94, 95, 96, 97, 53, 0, 0, - 0, 0, 0, 25, 0, 0, 0, 189, 0, 0, - 0, 55, 57, 0, 0, 0, 0, 0, 123, 104, - 105, 0, 0, 129, 0, 0, 125, 129, 0, 90, - 0, 27, 0, 135, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 12, 14, 0, 3, 16, 4, 6, + 7, 8, 9, 5, 1, 0, 54, 35, 0, 53, + 58, 59, 27, 70, 0, 70, 0, 0, 0, 75, + 0, 71, 72, 73, 74, 196, 195, 0, 192, 193, + 13, 0, 0, 0, 0, 0, 0, 89, 91, 90, + 0, 0, 0, 0, 0, 0, 93, 94, 95, 97, + 96, 92, 33, 34, 0, 142, 109, 87, 88, 86, + 82, 83, 84, 85, 81, 29, 106, 108, 107, 0, + 99, 100, 101, 102, 103, 104, 105, 60, 0, 0, + 0, 0, 0, 26, 0, 0, 0, 26, 0, 0, + 0, 197, 0, 0, 61, 0, 63, 65, 0, 0, + 0, 0, 0, 131, 112, 113, 0, 0, 137, 0, + 0, 133, 137, 0, 98, 0, 28, 0, 143, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 50, 0, 59, 0, 0, 0, 0, - 0, 24, 0, 67, 23, 63, 64, 65, 66, 0, - 0, 0, 10, 186, 0, 0, 0, 0, 0, 0, - 0, 103, 0, 102, 0, 127, 0, 126, 0, 31, - 0, 132, 129, 0, 120, 118, 119, 122, 106, 107, - 113, 114, 115, 108, 109, 110, 111, 29, 121, 112, - 116, 117, 30, 61, 60, 0, 0, 49, 0, 0, - 0, 157, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 181, 183, 142, 144, 145, 146, 147, 148, - 149, 150, 151, 152, 153, 154, 0, 0, 0, 25, - 0, 17, 0, 0, 0, 40, 43, 0, 39, 41, - 0, 54, 0, 0, 0, 0, 0, 0, 128, 0, - 128, 131, 130, 58, 0, 36, 0, 0, 156, 0, - 0, 0, 0, 0, 0, 170, 180, 182, 0, 0, - 0, 0, 0, 0, 0, 0, 22, 21, 0, 23, - 0, 70, 37, 0, 62, 62, 38, 0, 56, 0, - 0, 0, 0, 0, 136, 133, 124, 35, 48, 178, - 176, 155, 174, 172, 0, 0, 0, 0, 0, 173, - 171, 177, 175, 179, 143, 0, 19, 0, 0, 68, - 16, 25, 25, 42, 137, 140, 139, 138, 141, 0, - 0, 0, 158, 0, 0, 0, 14, 0, 71, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 166, - 0, 0, 34, 69, 0, 0, 167, 168, 169, 159, - 161, 0, 0, 0, 165, 160, 20, 0, 44, 45, - 162, 163, 164, 18 + 0, 0, 0, 0, 0, 0, 0, 0, 57, 0, + 67, 0, 0, 0, 0, 0, 25, 0, 75, 24, + 0, 0, 0, 0, 24, 0, 78, 0, 0, 11, + 194, 0, 0, 0, 0, 0, 0, 0, 111, 0, + 110, 0, 135, 0, 134, 0, 32, 0, 140, 137, + 0, 128, 126, 127, 130, 114, 115, 121, 122, 123, + 116, 117, 118, 119, 30, 129, 120, 124, 125, 31, + 69, 68, 0, 0, 56, 0, 0, 0, 165, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 189, + 191, 150, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, 162, 0, 0, 0, 18, 0, 0, 0, + 41, 44, 0, 40, 42, 0, 0, 0, 76, 47, + 50, 0, 48, 0, 62, 0, 0, 0, 0, 0, + 0, 136, 0, 136, 139, 138, 66, 0, 37, 0, + 0, 164, 0, 0, 0, 0, 0, 0, 178, 188, + 190, 0, 0, 0, 0, 0, 0, 0, 0, 23, + 22, 38, 0, 70, 70, 39, 43, 0, 0, 79, + 46, 49, 64, 0, 0, 0, 0, 0, 144, 141, + 132, 36, 55, 186, 184, 163, 182, 180, 0, 0, + 0, 0, 0, 181, 179, 185, 183, 187, 151, 0, + 20, 17, 26, 26, 0, 77, 145, 148, 147, 146, + 149, 0, 0, 0, 166, 0, 0, 0, 15, 0, + 0, 45, 0, 0, 0, 0, 0, 0, 0, 0, + 174, 0, 0, 35, 0, 0, 175, 176, 177, 167, + 169, 0, 0, 0, 173, 168, 21, 0, 51, 52, + 170, 171, 172, 19 }; const short int Parser::yypgoto_[] = { - -219, -219, 160, 245, -219, -154, -219, -219, -219, -219, - -218, -219, 141, -219, -84, -152, -219, -219, -219, -18, - -219, -219, 27, -219, 258, -4, 37, -40, -219, -31, - -120, -219, -219, -219, -219, -219, -219, -219, -219, -219, - -219, -219, -219, -219, -219, -34, -219, -219, -219, -45, - 32, -219, 3, 33, -219, -219, -219, -219, -219, -150, - 48, -181, -219, -219, -219, -219, -74, -219, -219, -219, - -219, -219, -219, -219, -219, 191, 194, -219, -219 + -269, -269, 154, 255, -269, -165, -269, -269, -269, -269, + -99, -269, 136, -269, -109, 3, -269, -269, -269, 13, + -269, -269, -268, -41, -269, 133, -269, -15, -4, 4, + -39, -269, -33, -10, -269, -269, -269, -269, -269, -269, + -269, -269, -269, -269, -269, -269, -269, -269, -20, -269, + -269, -269, -58, 0, -269, 46, 104, -269, -269, -269, + -269, -269, 32, -83, -182, -269, -269, -269, -269, -98, + -269, -269, -269, -269, -269, -269, -269, -269, 175, 171, + -269, -269 }; const short int Parser::yydefgoto_[] = { - -1, 2, 12, 13, 14, 15, 242, 346, 326, 151, - 152, 16, 62, 63, 64, 17, 18, 19, 20, 246, - 247, 248, 27, 208, 28, 65, 102, 103, 146, 90, - 154, 155, 156, 157, 158, 290, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 114, - 123, 79, 80, 81, 82, 83, 84, 85, 86, 21, - 268, 269, 225, 226, 227, 359, 360, 228, 229, 230, - 231, 232, 233, 234, 235, 37, 38, 39, 40 + -1, 2, 13, 14, 15, 16, 257, 368, 350, 166, + 167, 17, 72, 73, 74, 269, 19, 20, 21, 261, + 262, 22, 270, 271, 263, 30, 225, 31, 75, 117, + 118, 161, 100, 169, 41, 42, 43, 44, 175, 76, + 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, + 87, 88, 129, 138, 89, 90, 91, 92, 93, 94, + 95, 96, 272, 291, 292, 242, 243, 244, 380, 381, + 245, 246, 247, 248, 249, 250, 251, 252, 46, 47, + 48, 49 }; const short int Parser::yytable_[] = { - 29, 92, 97, 104, 105, 241, 107, 144, 245, 118, - 249, 106, -72, 23, -72, 22, 108, 109, 110, 113, - 117, 288, 149, 23, 23, 23, 23, 206, 23, 271, - 236, 1, 30, 31, 32, 33, 34, 35, 36, 281, - 283, 91, 150, 24, 204, 251, 243, 262, 244, 145, - 219, 119, 205, 100, 100, 178, 88, 25, 98, 177, - 250, 89, 161, 121, 99, 178, 99, 25, 25, 101, - 101, 101, 26, 101, 239, 89, 93, 183, 172, 94, - 240, 331, 26, 26, 26, 26, 95, 26, 182, 153, - 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, - 194, 195, 196, 197, 198, 199, 200, 201, 202, 133, - 134, 135, 136, 349, 350, 143, 101, 286, 287, 289, - 4, 265, 89, 120, 8, 266, 36, 36, 332, 328, - 299, 329, 252, 253, 254, 255, 256, 292, 122, 330, - 258, 293, 259, 153, 260, 245, 153, 249, 124, 125, - 126, 127, 222, 128, 129, 130, 296, 148, 142, 147, - 297, 153, 159, 160, 166, 263, 131, 132, 133, 134, - 135, 136, 272, 273, 274, 207, 138, 165, 139, 140, - 141, 167, 223, 278, 279, 3, 128, 129, 4, 5, - 6, 7, 8, 168, 170, 9, 10, 224, 171, 174, - 203, 133, 134, 135, 136, 175, 291, 347, 348, 261, - 237, 238, 222, 222, 264, 136, 112, 284, 222, 276, - 285, 309, 312, 222, 222, 314, 325, 315, 316, 319, - 307, 11, 101, 153, 153, 153, 321, 327, 343, 101, - 101, 101, 223, 223, 378, 379, 344, 345, 223, 277, - 323, 354, 362, 223, 223, 363, 364, 365, 162, 41, - 370, 179, 371, 275, 92, 334, 335, 336, 337, 338, - 294, 295, 222, 372, 222, 375, 383, 101, 377, 333, - 339, 340, 341, 87, 222, 374, 222, 298, 222, 304, - 163, 0, 0, 308, 164, 0, 0, 0, 0, 0, - 0, 0, 223, 0, 223, 0, 0, 0, 0, 358, - 361, 0, 0, 0, 223, 0, 223, 311, 223, 311, - 222, 0, 0, 153, 153, 358, 0, 153, 153, 311, - 0, 311, 209, 324, 210, 313, 211, 212, 23, 213, - 214, 215, 0, 216, 217, 0, 0, 218, 0, 0, - 223, 0, 0, 0, 222, 222, 222, 222, 0, 0, - 153, 153, 0, 0, 219, 342, 0, 0, 220, 0, - 0, 0, 0, 0, 222, 222, 222, 0, 0, 0, - 0, 0, 25, 0, 223, 223, 223, 223, 0, 221, - 0, 0, 0, 355, 0, 0, 0, 26, 0, 366, - 367, 368, 369, 0, 223, 223, 223, 0, 0, 0, - 42, 23, 43, 44, 0, 0, 0, 45, 0, 380, - 381, 382, 356, 0, 46, 0, 47, 48, 49, 0, - 0, 0, 0, 50, 51, 52, 0, 96, 0, 54, - 0, 0, 0, 0, 357, 55, 3, 0, 0, 4, - 5, 6, 7, 8, 111, 25, 9, 10, 0, 0, - 0, 0, 0, 0, 56, 57, 58, 59, 60, 61, - 26, 42, 23, 43, 44, 0, 0, 0, 45, 0, - 0, 0, 0, 0, 0, 46, 0, 47, 48, 49, - 0, 0, 0, 0, 50, 51, 52, 0, 96, 0, - 54, 0, 0, 0, 0, 0, 55, 0, 0, 0, - 112, 0, 0, 0, 0, 115, 25, 0, 0, 0, - 0, 0, 0, 0, 0, 56, 57, 58, 59, 60, - 61, 26, 42, 23, 43, 44, 0, 0, 0, 45, - 0, 0, 0, 0, 0, 0, 46, 0, 47, 48, - 49, 0, 0, 0, 0, 50, 51, 52, 0, 96, - 0, 54, 116, 0, 0, 0, 0, 55, 0, 0, - 0, 0, 0, 0, 0, 0, 180, 25, 0, 0, - 0, 0, 0, 0, 0, 0, 56, 57, 58, 59, - 60, 61, 26, 42, 23, 43, 44, 0, 0, 0, - 45, 0, 0, 0, 0, 0, 0, 46, 0, 47, - 48, 49, 0, 267, 0, 0, 50, 51, 52, 0, - 96, 181, 54, 0, 0, 209, 0, 210, 55, 211, - 212, 23, 213, 214, 215, 0, 216, 217, 25, 0, - 218, 0, 0, 0, 0, 0, 0, 56, 57, 58, - 59, 60, 61, 26, 0, 0, 0, 219, -2, 3, - 270, 220, 4, 5, 6, 7, 8, 0, 0, 9, - 10, 0, 209, 0, 210, 25, 211, 212, 23, 213, - 214, 215, 221, 216, 217, 0, 0, 218, 0, 0, - 26, 0, 0, 0, 0, 0, 0, 280, 0, 0, - 0, 0, 0, 0, 219, 11, 0, 0, 220, 209, - 0, 210, 0, 211, 212, 23, 213, 214, 215, 0, - 216, 217, 25, 0, 218, 0, 0, 0, 0, 221, - 0, 0, 0, 0, 282, 0, 0, 26, 0, 0, - 0, 219, 0, 0, 0, 220, 209, 0, 210, 0, - 211, 212, 23, 213, 214, 215, 0, 216, 217, 25, - 0, 218, 0, 0, 0, 0, 221, 0, 0, 0, - 0, 0, 0, 0, 26, 0, 0, 0, 219, 0, - 0, 0, 220, 209, 310, 210, 0, 211, 212, 23, - 213, 214, 215, 0, 216, 217, 25, 0, 218, 0, - 0, 0, 0, 221, 0, 0, 0, 0, 0, 0, - 0, 26, 0, 0, 0, 219, 0, 0, 0, 220, - 209, 0, 210, 0, 211, 212, 23, 213, 214, 215, - 0, 216, 217, 25, 0, 218, 0, 0, 0, 0, - 221, 0, 0, 0, 0, 0, 0, 0, 26, 0, - 0, 0, 219, 0, 0, 0, 220, 320, 0, 0, - 209, 0, 210, 0, 211, 212, 23, 213, 214, 215, - 25, 216, 217, 0, 0, 218, 0, 221, 0, 0, - 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, - 0, 0, 219, 0, 0, 0, 220, 209, 0, 210, - 0, 211, 212, 23, 213, 214, 215, 0, 216, 217, - 25, 0, 218, 0, 0, 0, 0, 221, 322, 0, - 0, 0, 0, 0, 0, 26, 0, 0, 0, 219, - 0, 0, 0, 220, 42, 23, 43, 44, 0, 0, - 0, 45, 0, 0, 0, 0, 356, 25, 46, 0, - 47, 48, 49, 0, 221, 0, 0, 50, 51, 52, - 0, 96, 26, 54, 0, 0, 0, 0, 357, 55, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 25, - 0, 0, 0, 0, 0, 0, 0, 0, 56, 57, - 58, 59, 60, 61, 26, 42, 23, 43, 44, 0, - 0, 0, 45, 0, 0, 0, 0, 0, 0, 46, - 0, 47, 48, 49, 0, 0, 0, 0, 50, 51, - 52, 0, 53, 0, 54, 0, 0, 0, 0, 0, - 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 25, 0, 0, 0, 0, 0, 0, 0, 0, 56, - 57, 58, 59, 60, 61, 26, 42, 23, 43, 44, - 0, 0, 0, 45, 0, 0, 0, 0, 0, 0, - 46, 0, 47, 48, 49, 0, 0, 0, 0, 50, - 51, 52, 0, 96, 351, 54, 0, 0, 0, 0, - 0, 55, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 25, 124, 125, 126, 127, 0, 128, 129, 130, - 56, 57, 58, 59, 60, 61, 26, 0, 0, 0, - 131, 132, 133, 134, 135, 136, 301, 0, 0, 0, - 138, 0, 139, 140, 141, 0, 0, 0, 0, 0, - 124, 125, 126, 127, 0, 128, 129, 130, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 131, 132, - 133, 134, 135, 136, 352, 0, 0, 0, 138, 0, - 139, 140, 141, 0, 0, 0, 0, 0, 124, 125, - 126, 127, 0, 128, 129, 130, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 131, 132, 133, 134, - 135, 136, 353, 0, 0, 0, 138, 0, 139, 140, - 141, 0, 0, 0, 0, 0, 124, 125, 126, 127, - 0, 128, 129, 130, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 131, 132, 133, 134, 135, 136, - 169, 0, 0, 0, 138, 0, 139, 140, 141, 0, - 0, 124, 125, 126, 127, 0, 128, 129, 130, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 131, - 132, 133, 134, 135, 136, 317, 0, 0, 0, 138, - 0, 139, 140, 141, 0, 0, 124, 125, 126, 127, - 0, 128, 129, 130, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 131, 132, 133, 134, 135, 136, - 302, 0, 0, 0, 138, 0, 139, 140, 141, 0, - 124, 125, 126, 127, 0, 128, 129, 130, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 131, 132, - 133, 134, 135, 136, 0, 318, 0, 0, 138, 0, - 139, 140, 141, 124, 125, 126, 127, 0, 128, 129, - 130, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 131, 132, 133, 134, 135, 136, 0, 0, 0, - 300, 138, 0, 139, 140, 141, 124, 125, 126, 127, - 0, 128, 129, 130, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 131, 132, 133, 134, 135, 136, - 0, 0, 0, 0, 138, 303, 139, 140, 141, 124, - 125, 126, 127, 0, 128, 129, 130, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 131, 132, 133, - 134, 135, 136, 0, 0, 0, 0, 138, 0, 139, - 140, 141, 124, 125, 126, 127, 0, 128, 129, 130, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 131, 132, 133, 134, 135, 136, 0, 0, 0, 137, - 138, 0, 139, 140, 141, 124, 125, 126, 127, 0, - 128, 129, 130, 0, 173, 0, 0, 0, 0, 0, - 0, 0, 0, 131, 132, 133, 134, 135, 136, 0, - 0, 0, 0, 138, 0, 139, 140, 141, 124, 125, - 126, 127, 0, 128, 129, 130, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 131, 132, 133, 134, - 135, 136, 0, 176, 0, 0, 138, 0, 139, 140, - 141, 124, 125, 126, 127, 0, 128, 129, 130, 0, - 257, 0, 0, 0, 0, 0, 0, 0, 0, 131, - 132, 133, 134, 135, 136, 0, 0, 0, 0, 138, - 0, 139, 140, 141, 124, 125, 126, 127, 0, 128, - 129, 130, 0, 305, 0, 0, 0, 0, 0, 0, - 0, 0, 131, 132, 133, 134, 135, 136, 0, 0, - 0, 0, 138, 0, 139, 140, 141, 124, 125, 126, - 127, 0, 128, 129, 130, 0, 0, 0, 306, 0, - 0, 0, 0, 0, 0, 131, 132, 133, 134, 135, - 136, 0, 0, 0, 0, 138, 0, 139, 140, 141, - 124, 125, 126, 127, 0, 128, 129, 130, 0, 0, - 0, 0, 0, 0, 373, 0, 0, 0, 131, 132, - 133, 134, 135, 136, 0, 0, 0, 0, 138, 0, - 139, 140, 141, 124, 125, 126, 127, 0, 128, 129, - 130, 0, 0, 0, 0, 0, 376, 0, 0, 0, - 0, 131, 132, 133, 134, 135, 136, 0, 0, 0, - 0, 138, 0, 139, 140, 141, 124, 125, 126, 127, - 0, 128, 129, 130, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 131, 132, 133, 134, 135, 136, - 0, 0, 0, 0, 138, 0, 139, 140, 141, 124, - 125, 126, 0, 0, 128, 129, 130, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 131, 132, 133, - 134, 135, 136, 0, 0, 0, 0, 0, 0, 139, - 140, 141, 124, 0, 126, 0, 0, 128, 129, 130, + 32, 40, 102, 321, 18, 256, 133, 39, 173, 159, + 26, 26, 25, 97, 119, 120, 25, 122, 18, 26, + 112, 25, 1, 26, 106, 111, 113, 258, 26, 259, + 26, 164, 5, 23, 7, 121, 114, 24, 115, 51, + 123, 124, 125, 128, 132, 294, 5, 23, 7, 27, + 258, 165, 259, 194, 236, 304, 306, 98, 115, 195, + 160, 134, 4, 28, 101, 221, 8, 28, 107, 29, + 29, 99, 28, 222, 108, 315, 157, 285, 29, 200, + 320, 241, 29, 103, 136, 195, 321, 29, 176, 29, + 178, 5, 107, 7, 371, 273, 172, 174, 108, 168, + 99, 113, 168, 168, 99, 135, 352, 189, 288, 104, + 353, -80, 289, -80, 311, 18, 105, 199, 312, 201, + 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 219, 33, 34, + 35, 36, 37, 38, 23, 45, 267, 351, 268, 298, + 109, 162, 223, 137, 163, 253, 183, 184, 168, 170, + 171, 168, 177, 275, 276, 277, 278, 279, 182, 185, + 187, 281, 274, 282, 260, 283, 188, 191, 168, 148, + 149, 150, 151, 286, 254, 116, 116, 116, 192, 116, + 295, 296, 297, -2, 3, 220, 255, 4, 5, 6, + 7, 8, 265, 264, 9, 10, 11, 266, 284, 335, + 239, 335, 143, 144, 301, 302, 151, 287, 127, 307, + 308, 335, 333, 335, 317, 348, 336, 148, 149, 150, + 151, 158, 116, 338, 339, 340, 343, 345, 349, 355, + 365, 366, 367, 12, 309, 310, 45, 375, 45, 383, + 168, 168, 384, 369, 370, 390, 318, 319, 364, 385, + 391, 395, 168, 168, 392, 260, 179, 331, 240, 403, + 50, 196, 239, 239, 397, 316, 354, 322, 239, 299, + 328, 102, 394, 239, 239, 0, 181, 347, 180, 386, + 387, 388, 389, 0, 264, 0, 224, 0, 0, 0, + 0, 0, 0, 356, 357, 358, 359, 360, 400, 401, + 402, 0, 0, 0, 0, 0, 0, 0, 361, 362, + 363, 0, 3, 0, 0, 4, 5, 6, 7, 8, + 240, 240, 9, 10, 11, 0, 240, 300, 239, 0, + 239, 240, 240, 0, 0, 379, 382, 0, 168, 168, + 239, 0, 239, 0, 239, 116, 0, 0, 0, 0, + 379, 0, 116, 116, 116, 0, 0, 0, 0, 0, + 0, 12, 0, 0, 398, 399, 0, 0, 0, 0, + 168, 168, 0, 0, 0, 0, 0, 239, 0, 0, + 0, 313, 314, 0, 0, 0, 240, 0, 240, 0, + 0, 0, 0, 0, 0, 0, 116, 0, 240, 0, + 240, 0, 240, 0, 0, 143, 144, 0, 239, 239, + 239, 239, 332, 0, 0, 0, 376, 0, 146, 147, + 148, 149, 150, 151, 0, 0, 0, 239, 239, 239, + 25, 155, 156, 0, 0, 240, 52, 26, 53, 54, + 0, 0, 0, 55, 0, 0, 0, 0, 377, 0, + 56, 0, 57, 58, 59, 0, 0, 0, 0, 60, + 61, 62, 0, 110, 0, 64, 240, 240, 240, 240, + 378, 65, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 28, 0, 126, 0, 240, 240, 240, 0, 0, + 66, 67, 68, 69, 70, 71, 29, 25, 143, 144, + 145, 0, 0, 52, 26, 53, 54, 0, 0, 0, + 55, 146, 147, 148, 149, 150, 151, 56, 0, 57, + 58, 59, 0, 154, 155, 156, 60, 61, 62, 0, + 110, 0, 64, 0, 0, 0, 0, 0, 65, 0, + 0, 0, 127, 0, 0, 0, 0, 0, 28, 0, + 130, 0, 0, 0, 0, 0, 0, 66, 67, 68, + 69, 70, 71, 29, 25, 0, 0, 0, 0, 0, + 52, 26, 53, 54, 0, 0, 0, 55, 0, 0, + 0, 0, 0, 0, 56, 0, 57, 58, 59, 0, + 0, 0, 0, 60, 61, 62, 0, 110, 0, 64, + 131, 0, 0, 0, 0, 65, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 28, 0, 197, 0, 0, + 0, 0, 0, 0, 66, 67, 68, 69, 70, 71, + 29, 25, 0, 0, 0, 0, 0, 52, 26, 53, + 54, 0, 0, 0, 55, 0, 0, 0, 0, 0, + 0, 56, 0, 57, 58, 59, 0, 0, 0, 0, + 60, 61, 62, 0, 110, 198, 64, 0, 0, 0, + 0, 0, 65, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 28, 0, 290, 0, 0, 0, 0, 0, + 0, 66, 67, 68, 69, 70, 71, 29, 25, 226, + 0, 227, 0, 228, 229, 26, 230, 231, 232, 0, + 233, 234, 0, 0, 235, 3, 0, 0, 4, 5, + 6, 7, 8, 0, 293, 9, 10, 11, 0, 0, + 0, 236, 0, 0, 0, 237, 0, 0, 25, 226, + 0, 227, 323, 228, 229, 26, 230, 231, 232, 28, + 233, 234, 0, 0, 235, 0, 238, 0, 0, 0, + 139, 140, 141, 142, 29, 143, 144, 145, 0, 0, + 0, 236, 0, 0, 0, 237, 0, 0, 146, 147, + 148, 149, 150, 151, 0, 0, 303, 0, 153, 28, + 154, 155, 156, 0, 0, 0, 238, 0, 0, 0, + 25, 226, 0, 227, 29, 228, 229, 26, 230, 231, + 232, 0, 233, 234, 0, 0, 235, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 305, 0, 0, 0, + 0, 0, 0, 236, 0, 0, 0, 237, 0, 0, + 25, 226, 0, 227, 0, 228, 229, 26, 230, 231, + 232, 28, 233, 234, 0, 0, 235, 0, 238, 0, + 0, 0, 0, 0, 0, 0, 29, 0, 0, 0, + 0, 0, 25, 236, 0, 0, 0, 237, 52, 26, + 53, 54, 0, 0, 0, 55, 0, 0, 0, 0, + 377, 28, 56, 0, 57, 58, 59, 0, 238, 0, + 0, 60, 61, 62, 0, 110, 29, 64, 0, 0, + 0, 0, 378, 65, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 28, 0, 0, 0, 0, 0, 0, + 0, 0, 66, 67, 68, 69, 70, 71, 29, 25, + 0, 0, 0, 0, 0, 52, 26, 53, 54, 0, + 0, 0, 55, 0, 0, 0, 0, 0, 0, 56, + 0, 57, 58, 59, 0, 0, 0, 0, 60, 61, + 62, 0, 63, 0, 64, 0, 0, 0, 0, 0, + 65, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 28, 0, 0, 0, 0, 0, 0, 0, 0, 66, + 67, 68, 69, 70, 71, 29, 25, 0, 0, 0, + 0, 0, 52, 26, 53, 54, 0, 0, 0, 55, + 0, 0, 0, 0, 0, 0, 56, 0, 57, 58, + 59, 0, 0, 0, 0, 60, 61, 62, 0, 110, + 0, 64, 0, 25, 226, 334, 227, 65, 228, 229, + 26, 230, 231, 232, 0, 233, 234, 28, 0, 235, + 0, 0, 0, 0, 0, 0, 66, 67, 68, 69, + 70, 71, 29, 0, 0, 0, 236, 0, 0, 0, + 237, 0, 0, 25, 226, 0, 227, 337, 228, 229, + 26, 230, 231, 232, 28, 233, 234, 0, 0, 235, + 0, 238, 0, 0, 0, 25, 226, 0, 227, 29, + 228, 229, 26, 230, 231, 232, 236, 233, 234, 0, + 237, 235, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 28, 0, 0, 0, 236, 0, + 0, 238, 237, 344, 0, 25, 226, 0, 227, 29, + 228, 229, 26, 230, 231, 232, 28, 233, 234, 0, + 0, 235, 0, 238, 0, 0, 0, 0, 0, 0, + 0, 29, 0, 0, 0, 0, 0, 0, 236, 0, + 0, 0, 237, 0, 0, 25, 226, 0, 227, 372, + 228, 229, 26, 230, 231, 232, 28, 233, 234, 0, + 0, 235, 0, 238, 346, 0, 0, 139, 140, 141, + 142, 29, 143, 144, 145, 0, 0, 0, 236, 0, + 0, 0, 237, 0, 0, 146, 147, 148, 149, 150, + 151, 0, 0, 325, 0, 153, 28, 154, 155, 156, + 0, 0, 0, 238, 0, 0, 0, 139, 140, 141, + 142, 29, 143, 144, 145, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 146, 147, 148, 149, 150, + 151, 373, 0, 0, 0, 153, 0, 154, 155, 156, + 0, 0, 0, 0, 0, 139, 140, 141, 142, 0, + 143, 144, 145, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 146, 147, 148, 149, 150, 151, 374, + 0, 0, 0, 153, 0, 154, 155, 156, 0, 0, + 0, 0, 0, 139, 140, 141, 142, 0, 143, 144, + 145, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 146, 147, 148, 149, 150, 151, 186, 0, 0, + 0, 153, 0, 154, 155, 156, 0, 0, 139, 140, + 141, 142, 0, 143, 144, 145, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 146, 147, 148, 149, + 150, 151, 341, 0, 0, 0, 153, 0, 154, 155, + 156, 0, 0, 139, 140, 141, 142, 0, 143, 144, + 145, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 146, 147, 148, 149, 150, 151, 326, 0, 0, + 0, 153, 0, 154, 155, 156, 0, 139, 140, 141, + 142, 0, 143, 144, 145, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 146, 147, 148, 149, 150, + 151, 0, 342, 0, 0, 153, 0, 154, 155, 156, + 139, 140, 141, 142, 0, 143, 144, 145, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 146, 147, + 148, 149, 150, 151, 0, 0, 0, 324, 153, 0, + 154, 155, 156, 139, 140, 141, 142, 0, 143, 144, + 145, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 146, 147, 148, 149, 150, 151, 0, 0, 0, + 0, 153, 327, 154, 155, 156, 139, 140, 141, 142, + 0, 143, 144, 145, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 146, 147, 148, 149, 150, 151, + 0, 0, 0, 0, 153, 0, 154, 155, 156, 139, + 140, 141, 142, 0, 143, 144, 145, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 146, 147, 148, + 149, 150, 151, 0, 0, 0, 152, 153, 0, 154, + 155, 156, 139, 140, 141, 142, 0, 143, 144, 145, + 0, 190, 0, 0, 0, 0, 0, 0, 0, 0, + 146, 147, 148, 149, 150, 151, 0, 0, 0, 0, + 153, 0, 154, 155, 156, 139, 140, 141, 142, 0, + 143, 144, 145, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 146, 147, 148, 149, 150, 151, 0, + 193, 0, 0, 153, 0, 154, 155, 156, 139, 140, + 141, 142, 0, 143, 144, 145, 0, 280, 0, 0, + 0, 0, 0, 0, 0, 0, 146, 147, 148, 149, + 150, 151, 0, 0, 0, 0, 153, 0, 154, 155, + 156, 139, 140, 141, 142, 0, 143, 144, 145, 0, + 329, 0, 0, 0, 0, 0, 0, 0, 0, 146, + 147, 148, 149, 150, 151, 0, 0, 0, 0, 153, + 0, 154, 155, 156, 139, 140, 141, 142, 0, 143, + 144, 145, 0, 0, 0, 330, 0, 0, 0, 0, + 0, 0, 146, 147, 148, 149, 150, 151, 0, 0, + 0, 0, 153, 0, 154, 155, 156, 139, 140, 141, + 142, 0, 143, 144, 145, 0, 0, 0, 0, 0, + 0, 393, 0, 0, 0, 146, 147, 148, 149, 150, + 151, 0, 0, 0, 0, 153, 0, 154, 155, 156, + 139, 140, 141, 142, 0, 143, 144, 145, 0, 0, + 0, 0, 0, 396, 0, 0, 0, 0, 146, 147, + 148, 149, 150, 151, 0, 0, 0, 0, 153, 0, + 154, 155, 156, 139, 140, 141, 142, 0, 143, 144, + 145, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 146, 147, 148, 149, 150, 151, 0, 0, 0, + 0, 153, 0, 154, 155, 156, 139, 140, 141, 0, + 0, 143, 144, 145, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 146, 147, 148, 149, 150, 151, + 0, 0, 0, 0, 0, 0, 154, 155, 156, 139, + 140, 141, 142, 0, 143, 144, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 146, 0, 0, + 149, 150, 151, 0, 0, 0, 0, 153, 0, 154, + 155, 156, 139, 0, 141, 0, 0, 143, 144, 145, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 131, 132, 133, 134, 135, 136, 0, 0, 0, 0, - 0, 0, 139, 140, 141, 124, 125, 126, 127, 0, - 128, 129, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 131, 124, 0, 134, 135, 136, 128, - 129, 130, 0, 138, 0, 139, 140, 141, 0, 0, - 0, 0, 131, 132, 133, 134, 135, 136, 128, 129, - 130, 0, 0, 0, 139, 140, 141, 0, 0, 0, - 0, 131, 132, 133, 134, 135, 136, 128, 129, 0, - 0, 0, 0, 139, 140, 141, 0, 0, 0, 0, - 131, 132, 133, 134, 135, 136, 0, 0, 0, 0, - 0, 0, 0, 140, 141 + 146, 147, 148, 149, 150, 151, 0, 0, 0, 0, + 139, 0, 154, 155, 156, 143, 144, 145, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 146, 147, + 148, 149, 150, 151, 0, 0, 0, 0, 0, 0, + 154, 155, 156 }; const short int Parser::yycheck_[] = { - 4, 32, 36, 43, 44, 159, 46, 1, 160, 54, - 160, 45, 54, 19, 56, 0, 50, 51, 52, 53, - 54, 239, 44, 19, 19, 19, 19, 147, 19, 210, - 150, 3, 5, 6, 7, 8, 9, 10, 11, 220, - 221, 44, 64, 49, 46, 165, 5, 46, 7, 89, - 45, 55, 54, 47, 47, 54, 63, 63, 48, 48, - 48, 45, 96, 50, 54, 54, 54, 63, 63, 42, - 43, 44, 78, 46, 55, 45, 51, 122, 112, 44, - 61, 51, 78, 78, 78, 78, 44, 78, 122, 93, - 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, - 134, 135, 136, 137, 138, 139, 140, 141, 142, 57, - 58, 59, 60, 331, 332, 88, 89, 237, 238, 239, - 4, 50, 45, 54, 8, 54, 99, 100, 51, 54, - 19, 56, 166, 167, 168, 169, 170, 50, 45, 293, - 174, 54, 176, 147, 178, 297, 150, 297, 37, 38, - 39, 40, 149, 42, 43, 44, 50, 49, 64, 64, - 54, 165, 49, 49, 44, 205, 55, 56, 57, 58, - 59, 60, 212, 213, 214, 148, 65, 51, 67, 68, - 69, 19, 149, 217, 218, 1, 42, 43, 4, 5, - 6, 7, 8, 19, 19, 11, 12, 149, 46, 54, - 46, 57, 58, 59, 60, 48, 240, 327, 328, 46, - 57, 64, 209, 210, 44, 60, 57, 66, 215, 216, - 44, 14, 16, 220, 221, 44, 10, 19, 19, 50, - 264, 47, 205, 237, 238, 239, 71, 64, 49, 212, - 213, 214, 209, 210, 364, 365, 49, 9, 215, 216, - 284, 27, 49, 220, 221, 56, 64, 64, 98, 14, - 50, 120, 51, 215, 295, 299, 300, 301, 302, 303, - 243, 244, 269, 51, 271, 50, 50, 250, 362, 297, - 314, 315, 316, 25, 281, 359, 283, 250, 285, 257, - 99, -1, -1, 266, 100, -1, -1, -1, -1, -1, - -1, -1, 269, -1, 271, -1, -1, -1, -1, 343, - 344, -1, -1, -1, 281, -1, 283, 269, 285, 271, - 317, -1, -1, 327, 328, 359, -1, 331, 332, 281, - -1, 283, 13, 285, 15, 16, 17, 18, 19, 20, - 21, 22, -1, 24, 25, -1, -1, 28, -1, -1, - 317, -1, -1, -1, 351, 352, 353, 354, -1, -1, - 364, 365, -1, -1, 45, 317, -1, -1, 49, -1, - -1, -1, -1, -1, 371, 372, 373, -1, -1, -1, - -1, -1, 63, -1, 351, 352, 353, 354, -1, 70, - -1, -1, -1, 1, -1, -1, -1, 78, -1, 351, - 352, 353, 354, -1, 371, 372, 373, -1, -1, -1, - 18, 19, 20, 21, -1, -1, -1, 25, -1, 371, - 372, 373, 30, -1, 32, -1, 34, 35, 36, -1, - -1, -1, -1, 41, 42, 43, -1, 45, -1, 47, - -1, -1, -1, -1, 52, 53, 1, -1, -1, 4, - 5, 6, 7, 8, 1, 63, 11, 12, -1, -1, - -1, -1, -1, -1, 72, 73, 74, 75, 76, 77, - 78, 18, 19, 20, 21, -1, -1, -1, 25, -1, - -1, -1, -1, -1, -1, 32, -1, 34, 35, 36, - -1, -1, -1, -1, 41, 42, 43, -1, 45, -1, - 47, -1, -1, -1, -1, -1, 53, -1, -1, -1, - 57, -1, -1, -1, -1, 1, 63, -1, -1, -1, - -1, -1, -1, -1, -1, 72, 73, 74, 75, 76, - 77, 78, 18, 19, 20, 21, -1, -1, -1, 25, - -1, -1, -1, -1, -1, -1, 32, -1, 34, 35, - 36, -1, -1, -1, -1, 41, 42, 43, -1, 45, - -1, 47, 48, -1, -1, -1, -1, 53, -1, -1, - -1, -1, -1, -1, -1, -1, 1, 63, -1, -1, - -1, -1, -1, -1, -1, -1, 72, 73, 74, 75, - 76, 77, 78, 18, 19, 20, 21, -1, -1, -1, - 25, -1, -1, -1, -1, -1, -1, 32, -1, 34, - 35, 36, -1, 1, -1, -1, 41, 42, 43, -1, - 45, 46, 47, -1, -1, 13, -1, 15, 53, 17, - 18, 19, 20, 21, 22, -1, 24, 25, 63, -1, - 28, -1, -1, -1, -1, -1, -1, 72, 73, 74, - 75, 76, 77, 78, -1, -1, -1, 45, 0, 1, - 1, 49, 4, 5, 6, 7, 8, -1, -1, 11, - 12, -1, 13, -1, 15, 63, 17, 18, 19, 20, - 21, 22, 70, 24, 25, -1, -1, 28, -1, -1, - 78, -1, -1, -1, -1, -1, -1, 1, -1, -1, - -1, -1, -1, -1, 45, 47, -1, -1, 49, 13, - -1, 15, -1, 17, 18, 19, 20, 21, 22, -1, - 24, 25, 63, -1, 28, -1, -1, -1, -1, 70, - -1, -1, -1, -1, 1, -1, -1, 78, -1, -1, - -1, 45, -1, -1, -1, 49, 13, -1, 15, -1, - 17, 18, 19, 20, 21, 22, -1, 24, 25, 63, - -1, 28, -1, -1, -1, -1, 70, -1, -1, -1, - -1, -1, -1, -1, 78, -1, -1, -1, 45, -1, - -1, -1, 49, 13, 14, 15, -1, 17, 18, 19, - 20, 21, 22, -1, 24, 25, 63, -1, 28, -1, - -1, -1, -1, 70, -1, -1, -1, -1, -1, -1, - -1, 78, -1, -1, -1, 45, -1, -1, -1, 49, - 13, -1, 15, -1, 17, 18, 19, 20, 21, 22, - -1, 24, 25, 63, -1, 28, -1, -1, -1, -1, - 70, -1, -1, -1, -1, -1, -1, -1, 78, -1, - -1, -1, 45, -1, -1, -1, 49, 50, -1, -1, - 13, -1, 15, -1, 17, 18, 19, 20, 21, 22, - 63, 24, 25, -1, -1, 28, -1, 70, -1, -1, - -1, -1, -1, -1, -1, 78, -1, -1, -1, -1, - -1, -1, 45, -1, -1, -1, 49, 13, -1, 15, - -1, 17, 18, 19, 20, 21, 22, -1, 24, 25, - 63, -1, 28, -1, -1, -1, -1, 70, 71, -1, - -1, -1, -1, -1, -1, 78, -1, -1, -1, 45, - -1, -1, -1, 49, 18, 19, 20, 21, -1, -1, - -1, 25, -1, -1, -1, -1, 30, 63, 32, -1, - 34, 35, 36, -1, 70, -1, -1, 41, 42, 43, - -1, 45, 78, 47, -1, -1, -1, -1, 52, 53, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 63, - -1, -1, -1, -1, -1, -1, -1, -1, 72, 73, - 74, 75, 76, 77, 78, 18, 19, 20, 21, -1, - -1, -1, 25, -1, -1, -1, -1, -1, -1, 32, - -1, 34, 35, 36, -1, -1, -1, -1, 41, 42, - 43, -1, 45, -1, 47, -1, -1, -1, -1, -1, - 53, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 63, -1, -1, -1, -1, -1, -1, -1, -1, 72, - 73, 74, 75, 76, 77, 78, 18, 19, 20, 21, - -1, -1, -1, 25, -1, -1, -1, -1, -1, -1, - 32, -1, 34, 35, 36, -1, -1, -1, -1, 41, - 42, 43, -1, 45, 19, 47, -1, -1, -1, -1, - -1, 53, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 63, 37, 38, 39, 40, -1, 42, 43, 44, - 72, 73, 74, 75, 76, 77, 78, -1, -1, -1, - 55, 56, 57, 58, 59, 60, 23, -1, -1, -1, - 65, -1, 67, 68, 69, -1, -1, -1, -1, -1, - 37, 38, 39, 40, -1, 42, 43, 44, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 55, 56, - 57, 58, 59, 60, 23, -1, -1, -1, 65, -1, - 67, 68, 69, -1, -1, -1, -1, -1, 37, 38, - 39, 40, -1, 42, 43, 44, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 55, 56, 57, 58, - 59, 60, 23, -1, -1, -1, 65, -1, 67, 68, - 69, -1, -1, -1, -1, -1, 37, 38, 39, 40, - -1, 42, 43, 44, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 55, 56, 57, 58, 59, 60, - 26, -1, -1, -1, 65, -1, 67, 68, 69, -1, - -1, 37, 38, 39, 40, -1, 42, 43, 44, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 55, - 56, 57, 58, 59, 60, 26, -1, -1, -1, 65, - -1, 67, 68, 69, -1, -1, 37, 38, 39, 40, - -1, 42, 43, 44, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 55, 56, 57, 58, 59, 60, - 27, -1, -1, -1, 65, -1, 67, 68, 69, -1, - 37, 38, 39, 40, -1, 42, 43, 44, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 55, 56, - 57, 58, 59, 60, -1, 29, -1, -1, 65, -1, - 67, 68, 69, 37, 38, 39, 40, -1, 42, 43, - 44, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 55, 56, 57, 58, 59, 60, -1, -1, -1, - 31, 65, -1, 67, 68, 69, 37, 38, 39, 40, - -1, 42, 43, 44, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 55, 56, 57, 58, 59, 60, - -1, -1, -1, -1, 65, 33, 67, 68, 69, 37, - 38, 39, 40, -1, 42, 43, 44, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 55, 56, 57, - 58, 59, 60, -1, -1, -1, -1, 65, -1, 67, - 68, 69, 37, 38, 39, 40, -1, 42, 43, 44, + 4, 11, 35, 271, 1, 170, 64, 11, 107, 1, + 22, 22, 15, 28, 53, 54, 15, 56, 15, 22, + 51, 15, 3, 22, 14, 45, 57, 5, 22, 7, + 22, 47, 5, 1, 7, 55, 51, 0, 50, 66, + 60, 61, 62, 63, 64, 227, 5, 15, 7, 52, + 5, 67, 7, 51, 48, 237, 238, 66, 50, 57, + 99, 65, 4, 66, 47, 49, 8, 66, 58, 81, + 81, 48, 66, 57, 64, 53, 67, 49, 81, 137, + 53, 164, 81, 54, 53, 57, 354, 81, 108, 81, + 110, 5, 58, 7, 53, 51, 106, 107, 64, 103, + 48, 57, 106, 107, 48, 57, 54, 127, 53, 47, + 54, 57, 57, 59, 53, 112, 47, 137, 57, 139, + 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 5, 6, + 7, 8, 9, 10, 112, 12, 57, 312, 59, 232, + 47, 67, 162, 48, 52, 165, 47, 22, 162, 52, + 52, 165, 52, 183, 184, 185, 186, 187, 54, 22, + 22, 191, 182, 193, 171, 195, 49, 57, 182, 60, + 61, 62, 63, 222, 60, 52, 53, 54, 51, 56, + 229, 230, 231, 0, 1, 49, 67, 4, 5, 6, + 7, 8, 47, 171, 11, 12, 13, 67, 49, 292, + 164, 294, 45, 46, 234, 235, 63, 47, 60, 69, + 47, 304, 17, 306, 52, 308, 19, 60, 61, 62, + 63, 98, 99, 47, 22, 22, 53, 74, 10, 59, + 52, 52, 9, 50, 254, 255, 113, 30, 115, 52, + 254, 255, 67, 352, 353, 53, 266, 267, 341, 67, + 54, 53, 266, 267, 54, 262, 112, 287, 164, 53, + 15, 135, 226, 227, 383, 262, 317, 273, 232, 233, + 280, 314, 380, 237, 238, -1, 115, 307, 113, 372, + 373, 374, 375, -1, 262, -1, 163, -1, -1, -1, + -1, -1, -1, 323, 324, 325, 326, 327, 391, 392, + 393, -1, -1, -1, -1, -1, -1, -1, 338, 339, + 340, -1, 1, -1, -1, 4, 5, 6, 7, 8, + 226, 227, 11, 12, 13, -1, 232, 233, 292, -1, + 294, 237, 238, -1, -1, 365, 366, -1, 352, 353, + 304, -1, 306, -1, 308, 222, -1, -1, -1, -1, + 380, -1, 229, 230, 231, -1, -1, -1, -1, -1, + -1, 50, -1, -1, 384, 385, -1, -1, -1, -1, + 384, 385, -1, -1, -1, -1, -1, 341, -1, -1, + -1, 258, 259, -1, -1, -1, 292, -1, 294, -1, + -1, -1, -1, -1, -1, -1, 273, -1, 304, -1, + 306, -1, 308, -1, -1, 45, 46, -1, 372, 373, + 374, 375, 289, -1, -1, -1, 1, -1, 58, 59, + 60, 61, 62, 63, -1, -1, -1, 391, 392, 393, + 15, 71, 72, -1, -1, 341, 21, 22, 23, 24, + -1, -1, -1, 28, -1, -1, -1, -1, 33, -1, + 35, -1, 37, 38, 39, -1, -1, -1, -1, 44, + 45, 46, -1, 48, -1, 50, 372, 373, 374, 375, + 55, 56, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 66, -1, 1, -1, 391, 392, 393, -1, -1, + 75, 76, 77, 78, 79, 80, 81, 15, 45, 46, + 47, -1, -1, 21, 22, 23, 24, -1, -1, -1, + 28, 58, 59, 60, 61, 62, 63, 35, -1, 37, + 38, 39, -1, 70, 71, 72, 44, 45, 46, -1, + 48, -1, 50, -1, -1, -1, -1, -1, 56, -1, + -1, -1, 60, -1, -1, -1, -1, -1, 66, -1, + 1, -1, -1, -1, -1, -1, -1, 75, 76, 77, + 78, 79, 80, 81, 15, -1, -1, -1, -1, -1, + 21, 22, 23, 24, -1, -1, -1, 28, -1, -1, + -1, -1, -1, -1, 35, -1, 37, 38, 39, -1, + -1, -1, -1, 44, 45, 46, -1, 48, -1, 50, + 51, -1, -1, -1, -1, 56, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 66, -1, 1, -1, -1, + -1, -1, -1, -1, 75, 76, 77, 78, 79, 80, + 81, 15, -1, -1, -1, -1, -1, 21, 22, 23, + 24, -1, -1, -1, 28, -1, -1, -1, -1, -1, + -1, 35, -1, 37, 38, 39, -1, -1, -1, -1, + 44, 45, 46, -1, 48, 49, 50, -1, -1, -1, + -1, -1, 56, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 66, -1, 1, -1, -1, -1, -1, -1, + -1, 75, 76, 77, 78, 79, 80, 81, 15, 16, + -1, 18, -1, 20, 21, 22, 23, 24, 25, -1, + 27, 28, -1, -1, 31, 1, -1, -1, 4, 5, + 6, 7, 8, -1, 1, 11, 12, 13, -1, -1, + -1, 48, -1, -1, -1, 52, -1, -1, 15, 16, + -1, 18, 22, 20, 21, 22, 23, 24, 25, 66, + 27, 28, -1, -1, 31, -1, 73, -1, -1, -1, + 40, 41, 42, 43, 81, 45, 46, 47, -1, -1, + -1, 48, -1, -1, -1, 52, -1, -1, 58, 59, + 60, 61, 62, 63, -1, -1, 1, -1, 68, 66, + 70, 71, 72, -1, -1, -1, 73, -1, -1, -1, + 15, 16, -1, 18, 81, 20, 21, 22, 23, 24, + 25, -1, 27, 28, -1, -1, 31, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, + -1, -1, -1, 48, -1, -1, -1, 52, -1, -1, + 15, 16, -1, 18, -1, 20, 21, 22, 23, 24, + 25, 66, 27, 28, -1, -1, 31, -1, 73, -1, + -1, -1, -1, -1, -1, -1, 81, -1, -1, -1, + -1, -1, 15, 48, -1, -1, -1, 52, 21, 22, + 23, 24, -1, -1, -1, 28, -1, -1, -1, -1, + 33, 66, 35, -1, 37, 38, 39, -1, 73, -1, + -1, 44, 45, 46, -1, 48, 81, 50, -1, -1, + -1, -1, 55, 56, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 66, -1, -1, -1, -1, -1, -1, + -1, -1, 75, 76, 77, 78, 79, 80, 81, 15, + -1, -1, -1, -1, -1, 21, 22, 23, 24, -1, + -1, -1, 28, -1, -1, -1, -1, -1, -1, 35, + -1, 37, 38, 39, -1, -1, -1, -1, 44, 45, + 46, -1, 48, -1, 50, -1, -1, -1, -1, -1, + 56, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 66, -1, -1, -1, -1, -1, -1, -1, -1, 75, + 76, 77, 78, 79, 80, 81, 15, -1, -1, -1, + -1, -1, 21, 22, 23, 24, -1, -1, -1, 28, + -1, -1, -1, -1, -1, -1, 35, -1, 37, 38, + 39, -1, -1, -1, -1, 44, 45, 46, -1, 48, + -1, 50, -1, 15, 16, 17, 18, 56, 20, 21, + 22, 23, 24, 25, -1, 27, 28, 66, -1, 31, + -1, -1, -1, -1, -1, -1, 75, 76, 77, 78, + 79, 80, 81, -1, -1, -1, 48, -1, -1, -1, + 52, -1, -1, 15, 16, -1, 18, 19, 20, 21, + 22, 23, 24, 25, 66, 27, 28, -1, -1, 31, + -1, 73, -1, -1, -1, 15, 16, -1, 18, 81, + 20, 21, 22, 23, 24, 25, 48, 27, 28, -1, + 52, 31, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 66, -1, -1, -1, 48, -1, + -1, 73, 52, 53, -1, 15, 16, -1, 18, 81, + 20, 21, 22, 23, 24, 25, 66, 27, 28, -1, + -1, 31, -1, 73, -1, -1, -1, -1, -1, -1, + -1, 81, -1, -1, -1, -1, -1, -1, 48, -1, + -1, -1, 52, -1, -1, 15, 16, -1, 18, 22, + 20, 21, 22, 23, 24, 25, 66, 27, 28, -1, + -1, 31, -1, 73, 74, -1, -1, 40, 41, 42, + 43, 81, 45, 46, 47, -1, -1, -1, 48, -1, + -1, -1, 52, -1, -1, 58, 59, 60, 61, 62, + 63, -1, -1, 26, -1, 68, 66, 70, 71, 72, + -1, -1, -1, 73, -1, -1, -1, 40, 41, 42, + 43, 81, 45, 46, 47, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 58, 59, 60, 61, 62, + 63, 26, -1, -1, -1, 68, -1, 70, 71, 72, + -1, -1, -1, -1, -1, 40, 41, 42, 43, -1, + 45, 46, 47, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 58, 59, 60, 61, 62, 63, 26, + -1, -1, -1, 68, -1, 70, 71, 72, -1, -1, + -1, -1, -1, 40, 41, 42, 43, -1, 45, 46, + 47, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 58, 59, 60, 61, 62, 63, 29, -1, -1, + -1, 68, -1, 70, 71, 72, -1, -1, 40, 41, + 42, 43, -1, 45, 46, 47, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 58, 59, 60, 61, + 62, 63, 29, -1, -1, -1, 68, -1, 70, 71, + 72, -1, -1, 40, 41, 42, 43, -1, 45, 46, + 47, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 58, 59, 60, 61, 62, 63, 30, -1, -1, + -1, 68, -1, 70, 71, 72, -1, 40, 41, 42, + 43, -1, 45, 46, 47, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 58, 59, 60, 61, 62, + 63, -1, 32, -1, -1, 68, -1, 70, 71, 72, + 40, 41, 42, 43, -1, 45, 46, 47, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 58, 59, + 60, 61, 62, 63, -1, -1, -1, 34, 68, -1, + 70, 71, 72, 40, 41, 42, 43, -1, 45, 46, + 47, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 58, 59, 60, 61, 62, 63, -1, -1, -1, + -1, 68, 36, 70, 71, 72, 40, 41, 42, 43, + -1, 45, 46, 47, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 58, 59, 60, 61, 62, 63, + -1, -1, -1, -1, 68, -1, 70, 71, 72, 40, + 41, 42, 43, -1, 45, 46, 47, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 58, 59, 60, + 61, 62, 63, -1, -1, -1, 67, 68, -1, 70, + 71, 72, 40, 41, 42, 43, -1, 45, 46, 47, + -1, 49, -1, -1, -1, -1, -1, -1, -1, -1, + 58, 59, 60, 61, 62, 63, -1, -1, -1, -1, + 68, -1, 70, 71, 72, 40, 41, 42, 43, -1, + 45, 46, 47, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 58, 59, 60, 61, 62, 63, -1, + 65, -1, -1, 68, -1, 70, 71, 72, 40, 41, + 42, 43, -1, 45, 46, 47, -1, 49, -1, -1, + -1, -1, -1, -1, -1, -1, 58, 59, 60, 61, + 62, 63, -1, -1, -1, -1, 68, -1, 70, 71, + 72, 40, 41, 42, 43, -1, 45, 46, 47, -1, + 49, -1, -1, -1, -1, -1, -1, -1, -1, 58, + 59, 60, 61, 62, 63, -1, -1, -1, -1, 68, + -1, 70, 71, 72, 40, 41, 42, 43, -1, 45, + 46, 47, -1, -1, -1, 51, -1, -1, -1, -1, + -1, -1, 58, 59, 60, 61, 62, 63, -1, -1, + -1, -1, 68, -1, 70, 71, 72, 40, 41, 42, + 43, -1, 45, 46, 47, -1, -1, -1, -1, -1, + -1, 54, -1, -1, -1, 58, 59, 60, 61, 62, + 63, -1, -1, -1, -1, 68, -1, 70, 71, 72, + 40, 41, 42, 43, -1, 45, 46, 47, -1, -1, + -1, -1, -1, 53, -1, -1, -1, -1, 58, 59, + 60, 61, 62, 63, -1, -1, -1, -1, 68, -1, + 70, 71, 72, 40, 41, 42, 43, -1, 45, 46, + 47, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 58, 59, 60, 61, 62, 63, -1, -1, -1, + -1, 68, -1, 70, 71, 72, 40, 41, 42, -1, + -1, 45, 46, 47, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 58, 59, 60, 61, 62, 63, + -1, -1, -1, -1, -1, -1, 70, 71, 72, 40, + 41, 42, 43, -1, 45, 46, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 58, -1, -1, + 61, 62, 63, -1, -1, -1, -1, 68, -1, 70, + 71, 72, 40, -1, 42, -1, -1, 45, 46, 47, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 55, 56, 57, 58, 59, 60, -1, -1, -1, 64, - 65, -1, 67, 68, 69, 37, 38, 39, 40, -1, - 42, 43, 44, -1, 46, -1, -1, -1, -1, -1, - -1, -1, -1, 55, 56, 57, 58, 59, 60, -1, - -1, -1, -1, 65, -1, 67, 68, 69, 37, 38, - 39, 40, -1, 42, 43, 44, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 55, 56, 57, 58, - 59, 60, -1, 62, -1, -1, 65, -1, 67, 68, - 69, 37, 38, 39, 40, -1, 42, 43, 44, -1, - 46, -1, -1, -1, -1, -1, -1, -1, -1, 55, - 56, 57, 58, 59, 60, -1, -1, -1, -1, 65, - -1, 67, 68, 69, 37, 38, 39, 40, -1, 42, - 43, 44, -1, 46, -1, -1, -1, -1, -1, -1, - -1, -1, 55, 56, 57, 58, 59, 60, -1, -1, - -1, -1, 65, -1, 67, 68, 69, 37, 38, 39, - 40, -1, 42, 43, 44, -1, -1, -1, 48, -1, - -1, -1, -1, -1, -1, 55, 56, 57, 58, 59, - 60, -1, -1, -1, -1, 65, -1, 67, 68, 69, - 37, 38, 39, 40, -1, 42, 43, 44, -1, -1, - -1, -1, -1, -1, 51, -1, -1, -1, 55, 56, - 57, 58, 59, 60, -1, -1, -1, -1, 65, -1, - 67, 68, 69, 37, 38, 39, 40, -1, 42, 43, - 44, -1, -1, -1, -1, -1, 50, -1, -1, -1, - -1, 55, 56, 57, 58, 59, 60, -1, -1, -1, - -1, 65, -1, 67, 68, 69, 37, 38, 39, 40, - -1, 42, 43, 44, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 55, 56, 57, 58, 59, 60, - -1, -1, -1, -1, 65, -1, 67, 68, 69, 37, - 38, 39, -1, -1, 42, 43, 44, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 55, 56, 57, - 58, 59, 60, -1, -1, -1, -1, -1, -1, 67, - 68, 69, 37, -1, 39, -1, -1, 42, 43, 44, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 55, 56, 57, 58, 59, 60, -1, -1, -1, -1, - -1, -1, 67, 68, 69, 37, 38, 39, 40, -1, - 42, 43, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 55, 37, -1, 58, 59, 60, 42, - 43, 44, -1, 65, -1, 67, 68, 69, -1, -1, - -1, -1, 55, 56, 57, 58, 59, 60, 42, 43, - 44, -1, -1, -1, 67, 68, 69, -1, -1, -1, - -1, 55, 56, 57, 58, 59, 60, 42, 43, -1, - -1, -1, -1, 67, 68, 69, -1, -1, -1, -1, - 55, 56, 57, 58, 59, 60, -1, -1, -1, -1, - -1, -1, -1, 68, 69 + 58, 59, 60, 61, 62, 63, -1, -1, -1, -1, + 40, -1, 70, 71, 72, 45, 46, 47, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 58, 59, + 60, 61, 62, 63, -1, -1, -1, -1, -1, -1, + 70, 71, 72 }; const unsigned char Parser::yystos_[] = { - 0, 3, 84, 1, 4, 5, 6, 7, 8, 11, - 12, 47, 85, 86, 87, 88, 94, 98, 99, 100, - 101, 142, 0, 19, 49, 63, 78, 105, 107, 108, - 105, 105, 105, 105, 105, 105, 105, 158, 159, 160, - 161, 86, 18, 20, 21, 25, 32, 34, 35, 36, - 41, 42, 43, 45, 47, 53, 72, 73, 74, 75, - 76, 77, 95, 96, 97, 108, 119, 120, 121, 122, - 123, 124, 125, 126, 127, 128, 129, 130, 131, 134, - 135, 136, 137, 138, 139, 140, 141, 107, 63, 45, - 112, 44, 112, 51, 44, 44, 45, 128, 48, 54, - 47, 105, 109, 110, 110, 110, 128, 110, 128, 128, - 128, 1, 57, 128, 132, 1, 48, 128, 132, 108, - 54, 50, 45, 133, 37, 38, 39, 40, 42, 43, - 44, 55, 56, 57, 58, 59, 60, 64, 65, 67, - 68, 69, 64, 105, 1, 110, 111, 64, 49, 44, - 64, 92, 93, 108, 113, 114, 115, 116, 117, 49, - 49, 128, 85, 158, 159, 51, 44, 19, 19, 26, - 19, 46, 128, 46, 54, 48, 62, 48, 54, 95, - 1, 46, 128, 132, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 46, 46, 54, 113, 105, 106, 13, - 15, 17, 18, 20, 21, 22, 24, 25, 28, 45, - 49, 70, 135, 136, 143, 145, 146, 147, 150, 151, - 152, 153, 154, 155, 156, 157, 113, 57, 64, 55, - 61, 88, 89, 5, 7, 98, 102, 103, 104, 142, - 48, 113, 128, 128, 128, 128, 128, 46, 128, 128, - 128, 46, 46, 110, 44, 50, 54, 1, 143, 144, - 1, 144, 110, 110, 110, 143, 135, 136, 128, 128, - 1, 144, 1, 144, 66, 44, 113, 113, 93, 113, - 118, 128, 50, 54, 105, 105, 50, 54, 109, 19, - 31, 23, 27, 33, 133, 46, 48, 128, 105, 14, - 14, 143, 16, 16, 44, 19, 19, 26, 29, 50, - 50, 71, 71, 128, 143, 10, 91, 64, 54, 56, - 88, 51, 51, 102, 128, 128, 128, 128, 128, 128, - 128, 128, 143, 49, 49, 9, 90, 113, 113, 93, - 93, 19, 23, 23, 27, 1, 30, 52, 128, 148, - 149, 128, 49, 56, 64, 64, 143, 143, 143, 143, - 50, 51, 51, 51, 149, 50, 50, 97, 113, 113, - 143, 143, 143, 50 + 0, 3, 87, 1, 4, 5, 6, 7, 8, 11, + 12, 13, 50, 88, 89, 90, 91, 97, 101, 102, + 103, 104, 107, 148, 0, 15, 22, 52, 66, 81, + 111, 113, 114, 111, 111, 111, 111, 111, 111, 114, + 119, 120, 121, 122, 123, 111, 164, 165, 166, 167, + 89, 66, 21, 23, 24, 28, 35, 37, 38, 39, + 44, 45, 46, 48, 50, 56, 75, 76, 77, 78, + 79, 80, 98, 99, 100, 114, 125, 126, 127, 128, + 129, 130, 131, 132, 133, 134, 135, 136, 137, 140, + 141, 142, 143, 144, 145, 146, 147, 113, 66, 48, + 118, 47, 118, 54, 47, 47, 14, 58, 64, 47, + 48, 134, 51, 57, 113, 50, 111, 115, 116, 116, + 116, 134, 116, 134, 134, 134, 1, 60, 134, 138, + 1, 51, 134, 138, 114, 57, 53, 48, 139, 40, + 41, 42, 43, 45, 46, 47, 58, 59, 60, 61, + 62, 63, 67, 68, 70, 71, 72, 67, 111, 1, + 116, 117, 67, 52, 47, 67, 95, 96, 114, 119, + 52, 52, 119, 96, 119, 124, 134, 52, 134, 88, + 164, 165, 54, 47, 22, 22, 29, 22, 49, 134, + 49, 57, 51, 65, 51, 57, 98, 1, 49, 134, + 138, 134, 134, 134, 134, 134, 134, 134, 134, 134, + 134, 134, 134, 134, 134, 134, 134, 134, 134, 134, + 49, 49, 57, 119, 111, 112, 16, 18, 20, 21, + 23, 24, 25, 27, 28, 31, 48, 52, 73, 141, + 142, 149, 151, 152, 153, 156, 157, 158, 159, 160, + 161, 162, 163, 119, 60, 67, 91, 92, 5, 7, + 101, 105, 106, 110, 148, 47, 67, 57, 59, 101, + 108, 109, 148, 51, 119, 134, 134, 134, 134, 134, + 49, 134, 134, 134, 49, 49, 116, 47, 53, 57, + 1, 149, 150, 1, 150, 116, 116, 116, 149, 141, + 142, 134, 134, 1, 150, 1, 150, 69, 47, 119, + 119, 53, 57, 111, 111, 53, 105, 52, 119, 119, + 53, 108, 115, 22, 34, 26, 30, 36, 139, 49, + 51, 134, 111, 17, 17, 149, 19, 19, 47, 22, + 22, 29, 32, 53, 53, 74, 74, 134, 149, 10, + 94, 91, 54, 54, 109, 59, 134, 134, 134, 134, + 134, 134, 134, 134, 149, 52, 52, 9, 93, 96, + 96, 53, 22, 26, 26, 30, 1, 33, 55, 134, + 154, 155, 134, 52, 67, 67, 149, 149, 149, 149, + 53, 54, 54, 54, 155, 53, 53, 100, 119, 119, + 149, 149, 149, 53 }; const unsigned char Parser::yyr1_[] = { - 0, 83, 84, 85, 85, 85, 85, 85, 85, 85, - 86, 86, 87, 87, 88, 88, 89, 89, 90, 90, - 91, 91, 92, 92, 93, 93, 94, 94, 95, 95, - 95, 96, 96, 97, 97, 98, 99, 100, 101, 102, - 102, 102, 103, 103, 104, 104, 105, 105, 106, 106, - 107, 107, 108, 108, 109, 109, 110, 110, 111, 111, - 112, 112, 112, 113, 113, 113, 113, 114, 115, 116, - 117, 118, 118, 119, 119, 119, 119, 119, 119, 119, - 119, 120, 121, 121, 122, 123, 123, 124, 125, 126, - 127, 128, 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 129, 129, 129, 129, 129, 129, 129, 129, - 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, - 129, 129, 129, 129, 130, 131, 131, 131, 132, 132, - 133, 133, 133, 134, 135, 135, 136, 137, 138, 139, - 140, 141, 142, 142, 143, 143, 143, 143, 143, 143, - 143, 143, 143, 143, 143, 144, 144, 145, 146, 146, - 147, 147, 148, 148, 148, 149, 149, 150, 151, 152, - 153, 154, 154, 154, 154, 155, 155, 155, 155, 156, - 157, 157, 157, 157, 158, 158, 159, 159, 160, 161 + 0, 86, 87, 88, 88, 88, 88, 88, 88, 88, + 88, 89, 89, 90, 90, 91, 91, 92, 92, 93, + 93, 94, 94, 95, 95, 96, 96, 97, 97, 98, + 98, 98, 99, 99, 100, 100, 101, 102, 103, 104, + 105, 105, 105, 106, 106, 107, 107, 108, 108, 109, + 109, 110, 110, 111, 111, 112, 112, 113, 113, 114, + 114, 114, 115, 115, 116, 116, 117, 117, 118, 118, + 118, 119, 119, 119, 119, 120, 121, 122, 123, 124, + 124, 125, 125, 125, 125, 125, 125, 125, 125, 126, + 127, 127, 128, 129, 129, 130, 131, 132, 133, 134, + 134, 134, 134, 134, 134, 134, 134, 134, 134, 134, + 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, + 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, + 135, 135, 136, 137, 137, 137, 138, 138, 139, 139, + 139, 140, 141, 141, 142, 143, 144, 145, 146, 147, + 148, 148, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 150, 150, 151, 152, 152, 153, 153, + 154, 154, 154, 155, 155, 156, 157, 158, 159, 160, + 160, 160, 160, 161, 161, 161, 161, 162, 163, 163, + 163, 163, 164, 164, 165, 165, 166, 167 }; const unsigned char Parser::yyr2_[] = { 0, 2, 2, 1, 1, 1, 1, 1, 1, 1, - 4, 1, 2, 1, 8, 1, 3, 1, 4, 0, - 4, 0, 3, 1, 1, 0, 2, 4, 1, 3, - 3, 3, 1, 1, 0, 7, 6, 6, 6, 1, - 1, 1, 3, 1, 6, 6, 1, 1, 3, 1, - 3, 1, 1, 2, 3, 1, 4, 1, 3, 1, - 3, 3, 0, 1, 1, 1, 1, 1, 4, 6, - 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 4, 1, 2, 1, 8, 1, 3, 1, 4, + 0, 4, 0, 3, 1, 1, 0, 2, 4, 1, + 3, 3, 3, 1, 1, 0, 7, 6, 6, 6, + 1, 1, 1, 2, 1, 8, 6, 1, 1, 2, + 1, 6, 6, 1, 1, 3, 1, 3, 1, 1, + 2, 3, 3, 1, 4, 1, 3, 1, 3, 3, + 0, 1, 1, 1, 1, 1, 4, 6, 3, 3, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 3, 3, 2, 2, 3, 3, 3, 3, + 3, 3, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 2, 5, 2, 3, 3, 3, 1, - 3, 3, 2, 5, 1, 2, 5, 6, 6, 6, - 6, 6, 5, 7, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 2, 1, 1, 4, 6, - 6, 6, 3, 3, 3, 2, 1, 6, 6, 6, - 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 2, 1, 2, 1, 1, 1, 3, 1, 1, 2 + 3, 2, 5, 2, 3, 3, 3, 1, 3, 3, + 2, 5, 1, 2, 5, 6, 6, 6, 6, 6, + 5, 7, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 2, 1, 1, 4, 6, 6, 6, + 3, 3, 3, 2, 1, 6, 6, 6, 2, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 2, 1, + 2, 1, 1, 1, 3, 1, 1, 2 }; @@ -3919,18 +4035,19 @@ namespace libcasm_fe { { "\"end of file\"", "error", "$undefined", "\"CASM\"", "\"init\"", "\"derived\"", "\"enum\"", "\"rule\"", "\"function\"", "\"initially\"", - "\"defined\"", "\"structure\"", "\"feature\"", "\"seq\"", "\"endseq\"", - "\"par\"", "\"endpar\"", "\"skip\"", "\"let\"", "\"in\"", "\"forall\"", - "\"choose\"", "\"iterate\"", "\"do\"", "\"call\"", "\"if\"", "\"then\"", - "\"else\"", "\"case\"", "\"of\"", "\"default\"", "\"holds\"", - "\"exists\"", "\"with\"", "\"undef\"", "\"false\"", "\"true\"", - "\"and\"", "\"or\"", "\"xor\"", "\"implies\"", "\"not\"", "\"+\"", - "\"-\"", "\"=\"", "\"(\"", "\")\"", "\"[\"", "\"]\"", "\"{\"", "\"}\"", - "\":\"", "\"_\"", "\"@\"", "\",\"", "\"<\"", "\">\"", "\"*\"", "\"/\"", - "\"%\"", "\"^\"", "\"'\"", "\"..\"", "\".\"", "\"->\"", "\"=>\"", - "\":=\"", "\"!=\"", "\"<=\"", "\">=\"", "\"{|\"", "\"|}\"", "\"binary\"", - "\"hexadecimal\"", "\"integer\"", "\"rational\"", "\"floating\"", - "\"string\"", "\"identifier\"", "ABSOLUTE_PATH", "UPLUS", "UMINUS", + "\"defined\"", "\"structure\"", "\"feature\"", "\"implements\"", + "\"for\"", "\"this\"", "\"seq\"", "\"endseq\"", "\"par\"", "\"endpar\"", + "\"skip\"", "\"let\"", "\"in\"", "\"forall\"", "\"choose\"", + "\"iterate\"", "\"do\"", "\"call\"", "\"if\"", "\"then\"", "\"else\"", + "\"case\"", "\"of\"", "\"default\"", "\"holds\"", "\"exists\"", + "\"with\"", "\"undef\"", "\"false\"", "\"true\"", "\"and\"", "\"or\"", + "\"xor\"", "\"implies\"", "\"not\"", "\"+\"", "\"-\"", "\"=\"", "\"(\"", + "\")\"", "\"[\"", "\"]\"", "\"{\"", "\"}\"", "\":\"", "\"_\"", "\"@\"", + "\",\"", "\"<\"", "\">\"", "\"*\"", "\"/\"", "\"%\"", "\"^\"", "\"'\"", + "\"..\"", "\".\"", "\"->\"", "\"=>\"", "\":=\"", "\"!=\"", "\"<=\"", + "\">=\"", "\"{|\"", "\"|}\"", "\"binary\"", "\"hexadecimal\"", + "\"integer\"", "\"rational\"", "\"floating\"", "\"string\"", + "\"identifier\"", "ABSOLUTE_PATH", "UPLUS", "UMINUS", "CALL_WITHOUT_ARGS", "$accept", "Specification", "Definition", "AttributedDefinition", "Definitions", "FunctionDefinition", "FunctionDefinitions", "MaybeInitially", "MaybeDefined", @@ -3939,15 +4056,16 @@ namespace libcasm_fe { "MaybeInitializers", "DerivedDefinition", "EnumerationDefinition", "StructureDefinition", "FeatureDefinition", "FeatureDeclarationOrDefinition", "FeatureDeclarationsAndDefinitions", - "DeclarationDefinition", "Identifier", "Identifiers", - "DotSeparatedIdentifiers", "IdentifierPath", "Variable", - "AttributedVariable", "Parameters", "MaybeParameters", "Type", - "BasicType", "ComposedType", "RelationType", "FixedSizedType", "Types", - "Atom", "Undefined", "Boolean", "String", "BitNumber", "IntegerNumber", - "FloatingNumber", "RationalNumber", "Reference", "Term", "Expression", - "Range", "List", "Terms", "Arguments", "TwoOrMoreArguments", - "DirectCallExpression", "IndirectCallExpression", "LetExpression", - "ConditionalExpression", "ChooseExpression", + "ImplementationDefinition", "ImplementationDefinitionDefinition", + "ImplementationDefinitionDefinitions", "DeclarationDefinition", + "Identifier", "Identifiers", "DotSeparatedIdentifiers", "IdentifierPath", + "Variable", "AttributedVariable", "Parameters", "MaybeParameters", + "Type", "BasicType", "ComposedType", "RelationType", "FixedSizedType", + "Types", "Atom", "Undefined", "Boolean", "String", "BitNumber", + "IntegerNumber", "FloatingNumber", "RationalNumber", "Reference", "Term", + "Expression", "Range", "List", "Terms", "Arguments", + "TwoOrMoreArguments", "DirectCallExpression", "IndirectCallExpression", + "LetExpression", "ConditionalExpression", "ChooseExpression", "UniversalQuantifierExpression", "ExistentialQuantifierExpression", "RuleDefinition", "Rule", "Rules", "SkipRule", "ConditionalRule", "CaseRule", "CaseLabel", "CaseLabels", "LetRule", "ForallRule", @@ -3960,25 +4078,26 @@ namespace libcasm_fe { const unsigned short int Parser::yyrline_[] = { - 0, 359, 359, 371, 375, 379, 383, 387, 391, 395, - 403, 409, 417, 423, 433, 449, 457, 463, 473, 477, - 485, 489, 497, 503, 513, 517, 525, 548, 566, 574, - 584, 595, 601, 611, 615, 623, 631, 639, 647, 655, - 659, 663, 671, 677, 687, 693, 703, 707, 715, 721, - 731, 737, 747, 751, 759, 763, 772, 778, 786, 792, - 802, 806, 810, 818, 822, 826, 830, 838, 846, 854, - 862, 870, 876, 886, 890, 894, 898, 902, 906, 910, - 914, 922, 930, 935, 944, 960, 972, 988, 1004, 1020, - 1036, 1044, 1048, 1052, 1056, 1060, 1064, 1068, 1072, 1076, - 1080, 1084, 1092, 1096, 1100, 1104, 1108, 1112, 1116, 1120, - 1124, 1128, 1132, 1136, 1140, 1144, 1148, 1152, 1156, 1160, - 1164, 1168, 1172, 1176, 1184, 1192, 1197, 1201, 1209, 1215, - 1225, 1229, 1233, 1242, 1252, 1257, 1265, 1273, 1281, 1289, - 1297, 1305, 1313, 1318, 1327, 1331, 1335, 1339, 1343, 1347, - 1351, 1355, 1359, 1363, 1367, 1375, 1381, 1391, 1399, 1403, - 1411, 1415, 1423, 1427, 1431, 1439, 1445, 1455, 1463, 1471, - 1479, 1487, 1491, 1495, 1500, 1509, 1513, 1517, 1522, 1531, - 1541, 1547, 1554, 1560, 1571, 1575, 1583, 1589, 1599, 1607 + 0, 365, 365, 377, 381, 385, 389, 393, 397, 401, + 405, 413, 419, 427, 433, 443, 459, 467, 473, 483, + 487, 495, 499, 507, 513, 523, 527, 535, 558, 576, + 584, 594, 605, 611, 621, 625, 633, 641, 649, 657, + 665, 669, 673, 681, 687, 697, 701, 711, 715, 723, + 729, 739, 745, 755, 759, 767, 773, 783, 789, 799, + 803, 807, 815, 819, 828, 834, 842, 848, 858, 862, + 866, 874, 878, 882, 886, 894, 902, 910, 918, 926, + 932, 942, 946, 950, 954, 958, 962, 966, 970, 978, + 986, 991, 1000, 1016, 1028, 1044, 1060, 1076, 1092, 1100, + 1104, 1108, 1112, 1116, 1120, 1124, 1128, 1132, 1136, 1140, + 1148, 1152, 1156, 1160, 1164, 1168, 1172, 1176, 1180, 1184, + 1188, 1192, 1196, 1200, 1204, 1208, 1212, 1216, 1220, 1224, + 1228, 1232, 1240, 1248, 1253, 1257, 1265, 1271, 1281, 1285, + 1289, 1298, 1308, 1313, 1321, 1329, 1337, 1345, 1353, 1361, + 1369, 1374, 1383, 1387, 1391, 1395, 1399, 1403, 1407, 1411, + 1415, 1419, 1423, 1431, 1437, 1447, 1455, 1459, 1467, 1471, + 1479, 1483, 1487, 1495, 1501, 1511, 1519, 1527, 1535, 1543, + 1547, 1551, 1556, 1565, 1569, 1573, 1578, 1587, 1597, 1603, + 1610, 1616, 1627, 1631, 1639, 1645, 1655, 1663 }; // Print the state stack on the debug stream. @@ -4013,8 +4132,8 @@ namespace libcasm_fe { #line 31 "../../obj/src/GrammarParser.yy" // lalr1.cc:1167 } // libcasm_fe -#line 4017 "GrammarParser.cpp" // lalr1.cc:1167 -#line 1613 "../../obj/src/GrammarParser.yy" // lalr1.cc:1168 +#line 4136 "GrammarParser.cpp" // lalr1.cc:1167 +#line 1669 "../../obj/src/GrammarParser.yy" // lalr1.cc:1168 void Parser::error( const SourceLocation& location, const std::string& message ) diff --git a/src/various/GrammarParser.output b/src/various/GrammarParser.output index 73b69d2e6..c33147637 100644 --- a/src/various/GrammarParser.output +++ b/src/various/GrammarParser.output @@ -10,517 +10,538 @@ Grammar 5 | EnumerationDefinition 6 | StructureDefinition 7 | FeatureDefinition - 8 | error + 8 | ImplementationDefinition + 9 | error - 9 AttributedDefinition: "[" Attributes "]" Definition - 10 | Definition + 10 AttributedDefinition: "[" Attributes "]" Definition + 11 | Definition - 11 Definitions: Definitions AttributedDefinition - 12 | AttributedDefinition + 12 Definitions: Definitions AttributedDefinition + 13 | AttributedDefinition - 13 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially - 14 | ProgramFunctionDefinition + 14 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially + 15 | ProgramFunctionDefinition - 15 FunctionDefinitions: FunctionDefinitions "," FunctionDefinition - 16 | FunctionDefinition + 16 FunctionDefinitions: FunctionDefinitions "," FunctionDefinition + 17 | FunctionDefinition - 17 MaybeInitially: "initially" "{" MaybeInitializers "}" - 18 | %empty + 18 MaybeInitially: "initially" "{" MaybeInitializers "}" + 19 | %empty - 19 MaybeDefined: "defined" "{" Term "}" - 20 | %empty + 20 MaybeDefined: "defined" "{" Term "}" + 21 | %empty - 21 FunctionParameters: FunctionParameters "*" Type - 22 | Type + 22 FunctionParameters: FunctionParameters "*" Type + 23 | Type - 23 MaybeFunctionParameters: FunctionParameters - 24 | %empty + 24 MaybeFunctionParameters: FunctionParameters + 25 | %empty - 25 ProgramFunctionDefinition: "init" IdentifierPath - 26 | "init" "{" MaybeInitializers "}" + 26 ProgramFunctionDefinition: "init" IdentifierPath + 27 | "init" "{" MaybeInitializers "}" - 27 Initializer: Term - 28 | Term "->" Term - 29 | TwoOrMoreArguments "->" Term + 28 Initializer: Term + 29 | Term "->" Term + 30 | TwoOrMoreArguments "->" Term - 30 Initializers: Initializers "," Initializer - 31 | Initializer + 31 Initializers: Initializers "," Initializer + 32 | Initializer - 32 MaybeInitializers: Initializers - 33 | %empty + 33 MaybeInitializers: Initializers + 34 | %empty - 34 DerivedDefinition: "derived" Identifier MaybeParameters "->" Type "=" Term + 35 DerivedDefinition: "derived" Identifier MaybeParameters "->" Type "=" Term - 35 EnumerationDefinition: "enum" Identifier "=" "{" Identifiers "}" + 36 EnumerationDefinition: "enum" Identifier "=" "{" Identifiers "}" - 36 StructureDefinition: "structure" Identifier "=" "{" FunctionDefinitions "}" + 37 StructureDefinition: "structure" Identifier "=" "{" FunctionDefinitions "}" - 37 FeatureDefinition: "feature" Identifier "=" "{" FeatureDeclarationsAndDefinitions "}" + 38 FeatureDefinition: "feature" Identifier "=" "{" FeatureDeclarationsAndDefinitions "}" - 38 FeatureDeclarationOrDefinition: DeclarationDefinition - 39 | DerivedDefinition - 40 | RuleDefinition + 39 FeatureDeclarationOrDefinition: DeclarationDefinition + 40 | DerivedDefinition + 41 | RuleDefinition - 41 FeatureDeclarationsAndDefinitions: FeatureDeclarationsAndDefinitions "," FeatureDeclarationOrDefinition - 42 | FeatureDeclarationOrDefinition + 42 FeatureDeclarationsAndDefinitions: FeatureDeclarationsAndDefinitions FeatureDeclarationOrDefinition + 43 | FeatureDeclarationOrDefinition - 43 DeclarationDefinition: "derived" Identifier ":" MaybeFunctionParameters "->" Type - 44 | "rule" Identifier ":" MaybeFunctionParameters "->" Type + 44 ImplementationDefinition: "implements" IdentifierPath "for" Type "=" "{" ImplementationDefinitionDefinitions "}" + 45 | "implements" Type "=" "{" ImplementationDefinitionDefinitions "}" - 45 Identifier: "identifier" - 46 | "in" + 46 ImplementationDefinitionDefinition: DerivedDefinition + 47 | RuleDefinition - 47 Identifiers: Identifiers "," Identifier - 48 | Identifier + 48 ImplementationDefinitionDefinitions: ImplementationDefinitionDefinitions ImplementationDefinitionDefinition + 49 | ImplementationDefinitionDefinition - 49 DotSeparatedIdentifiers: DotSeparatedIdentifiers "." Identifier - 50 | Identifier + 50 DeclarationDefinition: "derived" Identifier ":" MaybeFunctionParameters "->" Type + 51 | "rule" Identifier ":" MaybeFunctionParameters "->" Type - 51 IdentifierPath: DotSeparatedIdentifiers - 52 | "." DotSeparatedIdentifiers + 52 Identifier: "identifier" + 53 | "in" - 53 Variable: Identifier ":" Type - 54 | Identifier + 54 Identifiers: Identifiers "," Identifier + 55 | Identifier - 55 AttributedVariable: "[" Attributes "]" Variable - 56 | Variable + 56 DotSeparatedIdentifiers: DotSeparatedIdentifiers "." Identifier + 57 | Identifier - 57 Parameters: Parameters "," AttributedVariable - 58 | AttributedVariable + 58 IdentifierPath: DotSeparatedIdentifiers + 59 | "." DotSeparatedIdentifiers + 60 | "this" "." DotSeparatedIdentifiers - 59 MaybeParameters: "(" Parameters ")" - 60 | "(" error ")" - 61 | %empty + 61 Variable: Identifier ":" Type + 62 | Identifier - 62 Type: BasicType - 63 | ComposedType - 64 | RelationType - 65 | FixedSizedType + 63 AttributedVariable: "[" Attributes "]" Variable + 64 | Variable - 66 BasicType: IdentifierPath + 65 Parameters: Parameters "," AttributedVariable + 66 | AttributedVariable - 67 ComposedType: IdentifierPath "<" Types ">" + 67 MaybeParameters: "(" Parameters ")" + 68 | "(" error ")" + 69 | %empty - 68 RelationType: IdentifierPath "<" MaybeFunctionParameters "->" Type ">" + 70 Type: BasicType + 71 | ComposedType + 72 | RelationType + 73 | FixedSizedType - 69 FixedSizedType: IdentifierPath "'" Term + 74 BasicType: IdentifierPath - 70 Types: Types "," Type - 71 | Type + 75 ComposedType: IdentifierPath "<" Types ">" - 72 Atom: Reference - 73 | BitNumber - 74 | IntegerNumber - 75 | FloatingNumber - 76 | RationalNumber - 77 | String - 78 | Undefined - 79 | Boolean + 76 RelationType: IdentifierPath "<" MaybeFunctionParameters "->" Type ">" - 80 Undefined: "undef" + 77 FixedSizedType: IdentifierPath "'" Term - 81 Boolean: "true" - 82 | "false" + 78 Types: Types "," Type + 79 | Type - 83 String: "string" + 80 Atom: Reference + 81 | BitNumber + 82 | IntegerNumber + 83 | FloatingNumber + 84 | RationalNumber + 85 | String + 86 | Undefined + 87 | Boolean - 84 BitNumber: "binary" - 85 | "hexadecimal" + 88 Undefined: "undef" - 86 IntegerNumber: "integer" + 89 Boolean: "true" + 90 | "false" - 87 FloatingNumber: "floating" + 91 String: "string" - 88 RationalNumber: "rational" + 92 BitNumber: "binary" + 93 | "hexadecimal" - 89 Reference: "@" IdentifierPath + 94 IntegerNumber: "integer" - 90 Term: DirectCallExpression - 91 | IndirectCallExpression - 92 | LetExpression - 93 | ConditionalExpression - 94 | ChooseExpression - 95 | UniversalQuantifierExpression - 96 | ExistentialQuantifierExpression - 97 | Expression - 98 | List - 99 | Range - 100 | Atom + 95 FloatingNumber: "floating" - 101 Expression: "(" Term ")" - 102 | "(" error ")" - 103 | "+" Term - 104 | "-" Term - 105 | Term "+" Term - 106 | Term "-" Term - 107 | Term "*" Term - 108 | Term "/" Term - 109 | Term "%" Term - 110 | Term "^" Term - 111 | Term "!=" Term - 112 | Term "=" Term - 113 | Term "<" Term - 114 | Term ">" Term - 115 | Term "<=" Term - 116 | Term ">=" Term - 117 | Term "or" Term - 118 | Term "xor" Term - 119 | Term "and" Term - 120 | Term "=>" Term - 121 | Term "implies" Term - 122 | "not" Term + 96 RationalNumber: "rational" - 123 Range: "[" Term ".." Term "]" + 97 Reference: "@" IdentifierPath - 124 List: "[" "]" - 125 | "[" Terms "]" - 126 | "[" error "]" + 98 Term: DirectCallExpression + 99 | IndirectCallExpression + 100 | LetExpression + 101 | ConditionalExpression + 102 | ChooseExpression + 103 | UniversalQuantifierExpression + 104 | ExistentialQuantifierExpression + 105 | Expression + 106 | List + 107 | Range + 108 | Atom - 127 Terms: Terms "," Term - 128 | Term + 109 Expression: "(" Term ")" + 110 | "(" error ")" + 111 | "+" Term + 112 | "-" Term + 113 | Term "+" Term + 114 | Term "-" Term + 115 | Term "*" Term + 116 | Term "/" Term + 117 | Term "%" Term + 118 | Term "^" Term + 119 | Term "!=" Term + 120 | Term "=" Term + 121 | Term "<" Term + 122 | Term ">" Term + 123 | Term "<=" Term + 124 | Term ">=" Term + 125 | Term "or" Term + 126 | Term "xor" Term + 127 | Term "and" Term + 128 | Term "=>" Term + 129 | Term "implies" Term + 130 | "not" Term - 129 Arguments: "(" Terms ")" - 130 | "(" error ")" - 131 | "(" ")" + 131 Range: "[" Term ".." Term "]" - 132 TwoOrMoreArguments: "(" Terms "," Term ")" + 132 List: "[" "]" + 133 | "[" Terms "]" + 134 | "[" error "]" - 133 DirectCallExpression: IdentifierPath - 134 | IdentifierPath Arguments + 135 Terms: Terms "," Term + 136 | Term - 135 IndirectCallExpression: "(" "*" Term ")" Arguments + 137 Arguments: "(" Terms ")" + 138 | "(" error ")" + 139 | "(" ")" - 136 LetExpression: "let" AttributedVariable "=" Term "in" Term + 140 TwoOrMoreArguments: "(" Terms "," Term ")" - 137 ConditionalExpression: "if" Term "then" Term "else" Term + 141 DirectCallExpression: IdentifierPath + 142 | IdentifierPath Arguments - 138 ChooseExpression: "choose" AttributedVariable "in" Term "do" Term + 143 IndirectCallExpression: "(" "*" Term ")" Arguments - 139 UniversalQuantifierExpression: "forall" AttributedVariable "in" Term "holds" Term + 144 LetExpression: "let" AttributedVariable "=" Term "in" Term - 140 ExistentialQuantifierExpression: "exists" AttributedVariable "in" Term "with" Term + 145 ConditionalExpression: "if" Term "then" Term "else" Term - 141 RuleDefinition: "rule" Identifier MaybeParameters "=" Rule - 142 | "rule" Identifier MaybeParameters "->" Type "=" Rule + 146 ChooseExpression: "choose" AttributedVariable "in" Term "do" Term - 143 Rule: SkipRule - 144 | ConditionalRule - 145 | CaseRule - 146 | LetRule - 147 | ForallRule - 148 | ChooseRule - 149 | IterateRule - 150 | BlockRule - 151 | SequenceRule - 152 | UpdateRule - 153 | CallRule + 147 UniversalQuantifierExpression: "forall" AttributedVariable "in" Term "holds" Term - 154 Rules: Rules Rule - 155 | Rule + 148 ExistentialQuantifierExpression: "exists" AttributedVariable "in" Term "with" Term - 156 SkipRule: "skip" + 149 RuleDefinition: "rule" Identifier MaybeParameters "=" Rule + 150 | "rule" Identifier MaybeParameters "->" Type "=" Rule - 157 ConditionalRule: "if" Term "then" Rule - 158 | "if" Term "then" Rule "else" Rule + 151 Rule: SkipRule + 152 | ConditionalRule + 153 | CaseRule + 154 | LetRule + 155 | ForallRule + 156 | ChooseRule + 157 | IterateRule + 158 | BlockRule + 159 | SequenceRule + 160 | UpdateRule + 161 | CallRule - 159 CaseRule: "case" Term "of" "{" CaseLabels "}" - 160 | "case" Term "of" "{" error "}" + 162 Rules: Rules Rule + 163 | Rule - 161 CaseLabel: "default" ":" Rule - 162 | "_" ":" Rule - 163 | Term ":" Rule + 164 SkipRule: "skip" - 164 CaseLabels: CaseLabel CaseLabels - 165 | CaseLabel + 165 ConditionalRule: "if" Term "then" Rule + 166 | "if" Term "then" Rule "else" Rule - 166 LetRule: "let" AttributedVariable "=" Term "in" Rule + 167 CaseRule: "case" Term "of" "{" CaseLabels "}" + 168 | "case" Term "of" "{" error "}" - 167 ForallRule: "forall" AttributedVariable "in" Term "do" Rule + 169 CaseLabel: "default" ":" Rule + 170 | "_" ":" Rule + 171 | Term ":" Rule - 168 ChooseRule: "choose" AttributedVariable "in" Term "do" Rule + 172 CaseLabels: CaseLabel CaseLabels + 173 | CaseLabel - 169 IterateRule: "iterate" Rule + 174 LetRule: "let" AttributedVariable "=" Term "in" Rule - 170 BlockRule: "{" Rules "}" - 171 | "par" Rules "endpar" - 172 | "{" error "}" - 173 | "par" error "endpar" + 175 ForallRule: "forall" AttributedVariable "in" Term "do" Rule - 174 SequenceRule: "{|" Rules "|}" - 175 | "seq" Rules "endseq" - 176 | "{|" error "|}" - 177 | "seq" error "endseq" + 176 ChooseRule: "choose" AttributedVariable "in" Term "do" Rule - 178 UpdateRule: DirectCallExpression ":=" Term + 177 IterateRule: "iterate" Rule - 179 CallRule: "call" DirectCallExpression - 180 | DirectCallExpression - 181 | "call" IndirectCallExpression - 182 | IndirectCallExpression + 178 BlockRule: "{" Rules "}" + 179 | "par" Rules "endpar" + 180 | "{" error "}" + 181 | "par" error "endpar" - 183 Attribute: BasicAttribute - 184 | ExpressionAttribute + 182 SequenceRule: "{|" Rules "|}" + 183 | "seq" Rules "endseq" + 184 | "{|" error "|}" + 185 | "seq" error "endseq" - 185 Attributes: Attributes "," Attribute - 186 | Attribute + 186 UpdateRule: DirectCallExpression ":=" Term - 187 BasicAttribute: Identifier + 187 CallRule: "call" DirectCallExpression + 188 | DirectCallExpression + 189 | "call" IndirectCallExpression + 190 | IndirectCallExpression - 188 ExpressionAttribute: Identifier Term + 191 Attribute: BasicAttribute + 192 | ExpressionAttribute + + 193 Attributes: Attributes "," Attribute + 194 | Attribute + + 195 BasicAttribute: Identifier + + 196 ExpressionAttribute: Identifier Term Terminals, with rules where they appear "end of file" (0) 0 -error (256) 8 60 102 126 130 160 172 173 176 177 +error (256) 9 68 110 134 138 168 180 181 184 185 "CASM" (258) 1 -"init" (259) 25 26 -"derived" (260) 34 43 -"enum" (261) 35 -"rule" (262) 44 141 142 -"function" (263) 13 -"initially" (264) 17 -"defined" (265) 19 -"structure" (266) 36 -"feature" (267) 37 -"seq" (268) 175 177 -"endseq" (269) 175 177 -"par" (270) 171 173 -"endpar" (271) 171 173 -"skip" (272) 156 -"let" (273) 136 166 -"in" (274) 46 136 138 139 140 166 167 168 -"forall" (275) 139 167 -"choose" (276) 138 168 -"iterate" (277) 169 -"do" (278) 138 167 168 -"call" (279) 179 181 -"if" (280) 137 157 158 -"then" (281) 137 157 158 -"else" (282) 137 158 -"case" (283) 159 160 -"of" (284) 159 160 -"default" (285) 161 -"holds" (286) 139 -"exists" (287) 140 -"with" (288) 140 -"undef" (289) 80 -"false" (290) 82 -"true" (291) 81 -"and" (292) 119 -"or" (293) 117 -"xor" (294) 118 -"implies" (295) 121 -"not" (296) 122 -"+" (297) 103 105 -"-" (298) 104 106 -"=" (299) 34 35 36 37 112 136 141 142 166 -"(" (300) 59 60 101 102 129 130 131 132 135 -")" (301) 59 60 101 102 129 130 131 132 135 -"[" (302) 9 55 123 124 125 126 -"]" (303) 9 55 123 124 125 126 -"{" (304) 17 19 26 35 36 37 159 160 170 172 -"}" (305) 17 19 26 35 36 37 159 160 170 172 -":" (306) 13 43 44 53 161 162 163 -"_" (307) 162 -"@" (308) 89 -"," (309) 15 30 41 47 57 70 127 132 185 -"<" (310) 67 68 113 -">" (311) 67 68 114 -"*" (312) 21 107 135 -"/" (313) 108 -"%" (314) 109 -"^" (315) 110 -"'" (316) 69 -".." (317) 123 -"." (318) 49 52 -"->" (319) 13 28 29 34 43 44 68 142 -"=>" (320) 120 -":=" (321) 178 -"!=" (322) 111 -"<=" (323) 115 -">=" (324) 116 -"{|" (325) 174 176 -"|}" (326) 174 176 -"binary" (327) 84 -"hexadecimal" (328) 85 -"integer" (329) 86 -"rational" (330) 88 -"floating" (331) 87 -"string" (332) 83 -"identifier" (333) 45 -ABSOLUTE_PATH (334) -UPLUS (335) -UMINUS (336) -CALL_WITHOUT_ARGS (337) +"init" (259) 26 27 +"derived" (260) 35 50 +"enum" (261) 36 +"rule" (262) 51 149 150 +"function" (263) 14 +"initially" (264) 18 +"defined" (265) 20 +"structure" (266) 37 +"feature" (267) 38 +"implements" (268) 44 45 +"for" (269) 44 +"this" (270) 60 +"seq" (271) 183 185 +"endseq" (272) 183 185 +"par" (273) 179 181 +"endpar" (274) 179 181 +"skip" (275) 164 +"let" (276) 144 174 +"in" (277) 53 144 146 147 148 174 175 176 +"forall" (278) 147 175 +"choose" (279) 146 176 +"iterate" (280) 177 +"do" (281) 146 175 176 +"call" (282) 187 189 +"if" (283) 145 165 166 +"then" (284) 145 165 166 +"else" (285) 145 166 +"case" (286) 167 168 +"of" (287) 167 168 +"default" (288) 169 +"holds" (289) 147 +"exists" (290) 148 +"with" (291) 148 +"undef" (292) 88 +"false" (293) 90 +"true" (294) 89 +"and" (295) 127 +"or" (296) 125 +"xor" (297) 126 +"implies" (298) 129 +"not" (299) 130 +"+" (300) 111 113 +"-" (301) 112 114 +"=" (302) 35 36 37 38 44 45 120 144 149 150 174 +"(" (303) 67 68 109 110 137 138 139 140 143 +")" (304) 67 68 109 110 137 138 139 140 143 +"[" (305) 10 63 131 132 133 134 +"]" (306) 10 63 131 132 133 134 +"{" (307) 18 20 27 36 37 38 44 45 167 168 178 180 +"}" (308) 18 20 27 36 37 38 44 45 167 168 178 180 +":" (309) 14 50 51 61 169 170 171 +"_" (310) 170 +"@" (311) 97 +"," (312) 16 31 54 65 78 135 140 193 +"<" (313) 75 76 121 +">" (314) 75 76 122 +"*" (315) 22 115 143 +"/" (316) 116 +"%" (317) 117 +"^" (318) 118 +"'" (319) 77 +".." (320) 131 +"." (321) 56 59 60 +"->" (322) 14 29 30 35 50 51 76 150 +"=>" (323) 128 +":=" (324) 186 +"!=" (325) 119 +"<=" (326) 123 +">=" (327) 124 +"{|" (328) 182 184 +"|}" (329) 182 184 +"binary" (330) 92 +"hexadecimal" (331) 93 +"integer" (332) 94 +"rational" (333) 96 +"floating" (334) 95 +"string" (335) 91 +"identifier" (336) 52 +ABSOLUTE_PATH (337) +UPLUS (338) +UMINUS (339) +CALL_WITHOUT_ARGS (340) Nonterminals, with rules where they appear -$accept (83) +$accept (86) on left: 0 -Specification (84) +Specification (87) on left: 1, on right: 0 -Definition (85) - on left: 2 3 4 5 6 7 8, on right: 9 10 -AttributedDefinition (86) - on left: 9 10, on right: 11 12 -Definitions (87) - on left: 11 12, on right: 1 11 -FunctionDefinition (88) - on left: 13 14, on right: 2 15 16 -FunctionDefinitions (89) - on left: 15 16, on right: 15 36 -MaybeInitially (90) - on left: 17 18, on right: 13 -MaybeDefined (91) - on left: 19 20, on right: 13 -FunctionParameters (92) - on left: 21 22, on right: 21 23 -MaybeFunctionParameters (93) - on left: 23 24, on right: 13 43 44 68 -ProgramFunctionDefinition (94) - on left: 25 26, on right: 14 -Initializer (95) - on left: 27 28 29, on right: 30 31 -Initializers (96) - on left: 30 31, on right: 30 32 -MaybeInitializers (97) - on left: 32 33, on right: 17 26 -DerivedDefinition (98) - on left: 34, on right: 3 39 -EnumerationDefinition (99) - on left: 35, on right: 5 -StructureDefinition (100) - on left: 36, on right: 6 -FeatureDefinition (101) - on left: 37, on right: 7 -FeatureDeclarationOrDefinition (102) - on left: 38 39 40, on right: 41 42 -FeatureDeclarationsAndDefinitions (103) - on left: 41 42, on right: 37 41 -DeclarationDefinition (104) - on left: 43 44, on right: 38 -Identifier (105) - on left: 45 46, on right: 13 34 35 36 37 43 44 47 48 49 50 53 54 - 141 142 187 188 -Identifiers (106) - on left: 47 48, on right: 35 47 -DotSeparatedIdentifiers (107) - on left: 49 50, on right: 49 51 52 -IdentifierPath (108) - on left: 51 52, on right: 25 66 67 68 69 89 133 134 -Variable (109) - on left: 53 54, on right: 55 56 -AttributedVariable (110) - on left: 55 56, on right: 57 58 136 138 139 140 166 167 168 -Parameters (111) - on left: 57 58, on right: 57 59 -MaybeParameters (112) - on left: 59 60 61, on right: 34 141 142 -Type (113) - on left: 62 63 64 65, on right: 13 21 22 34 43 44 53 68 70 71 142 -BasicType (114) - on left: 66, on right: 62 -ComposedType (115) - on left: 67, on right: 63 -RelationType (116) - on left: 68, on right: 64 -FixedSizedType (117) - on left: 69, on right: 65 -Types (118) - on left: 70 71, on right: 67 70 -Atom (119) - on left: 72 73 74 75 76 77 78 79, on right: 100 -Undefined (120) - on left: 80, on right: 78 -Boolean (121) - on left: 81 82, on right: 79 -String (122) - on left: 83, on right: 77 -BitNumber (123) - on left: 84 85, on right: 73 -IntegerNumber (124) - on left: 86, on right: 74 -FloatingNumber (125) - on left: 87, on right: 75 -RationalNumber (126) - on left: 88, on right: 76 -Reference (127) - on left: 89, on right: 72 -Term (128) - on left: 90 91 92 93 94 95 96 97 98 99 100, on right: 19 27 28 - 29 34 69 101 103 104 105 106 107 108 109 110 111 112 113 114 115 - 116 117 118 119 120 121 122 123 127 128 132 135 136 137 138 139 - 140 157 158 159 160 163 166 167 168 178 188 -Expression (129) - on left: 101 102 103 104 105 106 107 108 109 110 111 112 113 114 - 115 116 117 118 119 120 121 122, on right: 97 -Range (130) - on left: 123, on right: 99 -List (131) - on left: 124 125 126, on right: 98 -Terms (132) - on left: 127 128, on right: 125 127 129 132 -Arguments (133) - on left: 129 130 131, on right: 134 135 -TwoOrMoreArguments (134) - on left: 132, on right: 29 -DirectCallExpression (135) - on left: 133 134, on right: 90 178 179 180 -IndirectCallExpression (136) - on left: 135, on right: 91 181 182 -LetExpression (137) - on left: 136, on right: 92 -ConditionalExpression (138) - on left: 137, on right: 93 -ChooseExpression (139) - on left: 138, on right: 94 -UniversalQuantifierExpression (140) - on left: 139, on right: 95 -ExistentialQuantifierExpression (141) - on left: 140, on right: 96 -RuleDefinition (142) - on left: 141 142, on right: 4 40 -Rule (143) - on left: 143 144 145 146 147 148 149 150 151 152 153, on right: - 141 142 154 155 157 158 161 162 163 166 167 168 169 -Rules (144) - on left: 154 155, on right: 154 170 171 174 175 -SkipRule (145) - on left: 156, on right: 143 -ConditionalRule (146) - on left: 157 158, on right: 144 -CaseRule (147) - on left: 159 160, on right: 145 -CaseLabel (148) - on left: 161 162 163, on right: 164 165 -CaseLabels (149) - on left: 164 165, on right: 159 164 -LetRule (150) - on left: 166, on right: 146 -ForallRule (151) - on left: 167, on right: 147 -ChooseRule (152) - on left: 168, on right: 148 -IterateRule (153) - on left: 169, on right: 149 -BlockRule (154) - on left: 170 171 172 173, on right: 150 -SequenceRule (155) - on left: 174 175 176 177, on right: 151 -UpdateRule (156) - on left: 178, on right: 152 -CallRule (157) - on left: 179 180 181 182, on right: 153 -Attribute (158) - on left: 183 184, on right: 185 186 -Attributes (159) - on left: 185 186, on right: 9 55 185 -BasicAttribute (160) - on left: 187, on right: 183 -ExpressionAttribute (161) - on left: 188, on right: 184 +Definition (88) + on left: 2 3 4 5 6 7 8 9, on right: 10 11 +AttributedDefinition (89) + on left: 10 11, on right: 12 13 +Definitions (90) + on left: 12 13, on right: 1 12 +FunctionDefinition (91) + on left: 14 15, on right: 2 16 17 +FunctionDefinitions (92) + on left: 16 17, on right: 16 37 +MaybeInitially (93) + on left: 18 19, on right: 14 +MaybeDefined (94) + on left: 20 21, on right: 14 +FunctionParameters (95) + on left: 22 23, on right: 22 24 +MaybeFunctionParameters (96) + on left: 24 25, on right: 14 50 51 76 +ProgramFunctionDefinition (97) + on left: 26 27, on right: 15 +Initializer (98) + on left: 28 29 30, on right: 31 32 +Initializers (99) + on left: 31 32, on right: 31 33 +MaybeInitializers (100) + on left: 33 34, on right: 18 27 +DerivedDefinition (101) + on left: 35, on right: 3 40 46 +EnumerationDefinition (102) + on left: 36, on right: 5 +StructureDefinition (103) + on left: 37, on right: 6 +FeatureDefinition (104) + on left: 38, on right: 7 +FeatureDeclarationOrDefinition (105) + on left: 39 40 41, on right: 42 43 +FeatureDeclarationsAndDefinitions (106) + on left: 42 43, on right: 38 42 +ImplementationDefinition (107) + on left: 44 45, on right: 8 +ImplementationDefinitionDefinition (108) + on left: 46 47, on right: 48 49 +ImplementationDefinitionDefinitions (109) + on left: 48 49, on right: 44 45 48 +DeclarationDefinition (110) + on left: 50 51, on right: 39 +Identifier (111) + on left: 52 53, on right: 14 35 36 37 38 50 51 54 55 56 57 61 62 + 149 150 195 196 +Identifiers (112) + on left: 54 55, on right: 36 54 +DotSeparatedIdentifiers (113) + on left: 56 57, on right: 56 58 59 60 +IdentifierPath (114) + on left: 58 59 60, on right: 26 44 74 75 76 77 97 141 142 +Variable (115) + on left: 61 62, on right: 63 64 +AttributedVariable (116) + on left: 63 64, on right: 65 66 144 146 147 148 174 175 176 +Parameters (117) + on left: 65 66, on right: 65 67 +MaybeParameters (118) + on left: 67 68 69, on right: 35 149 150 +Type (119) + on left: 70 71 72 73, on right: 14 22 23 35 44 45 50 51 61 76 78 + 79 150 +BasicType (120) + on left: 74, on right: 70 +ComposedType (121) + on left: 75, on right: 71 +RelationType (122) + on left: 76, on right: 72 +FixedSizedType (123) + on left: 77, on right: 73 +Types (124) + on left: 78 79, on right: 75 78 +Atom (125) + on left: 80 81 82 83 84 85 86 87, on right: 108 +Undefined (126) + on left: 88, on right: 86 +Boolean (127) + on left: 89 90, on right: 87 +String (128) + on left: 91, on right: 85 +BitNumber (129) + on left: 92 93, on right: 81 +IntegerNumber (130) + on left: 94, on right: 82 +FloatingNumber (131) + on left: 95, on right: 83 +RationalNumber (132) + on left: 96, on right: 84 +Reference (133) + on left: 97, on right: 80 +Term (134) + on left: 98 99 100 101 102 103 104 105 106 107 108, on right: 20 + 28 29 30 35 77 109 111 112 113 114 115 116 117 118 119 120 121 + 122 123 124 125 126 127 128 129 130 131 135 136 140 143 144 145 + 146 147 148 165 166 167 168 171 174 175 176 186 196 +Expression (135) + on left: 109 110 111 112 113 114 115 116 117 118 119 120 121 122 + 123 124 125 126 127 128 129 130, on right: 105 +Range (136) + on left: 131, on right: 107 +List (137) + on left: 132 133 134, on right: 106 +Terms (138) + on left: 135 136, on right: 133 135 137 140 +Arguments (139) + on left: 137 138 139, on right: 142 143 +TwoOrMoreArguments (140) + on left: 140, on right: 30 +DirectCallExpression (141) + on left: 141 142, on right: 98 186 187 188 +IndirectCallExpression (142) + on left: 143, on right: 99 189 190 +LetExpression (143) + on left: 144, on right: 100 +ConditionalExpression (144) + on left: 145, on right: 101 +ChooseExpression (145) + on left: 146, on right: 102 +UniversalQuantifierExpression (146) + on left: 147, on right: 103 +ExistentialQuantifierExpression (147) + on left: 148, on right: 104 +RuleDefinition (148) + on left: 149 150, on right: 4 41 47 +Rule (149) + on left: 151 152 153 154 155 156 157 158 159 160 161, on right: + 149 150 162 163 165 166 169 170 171 174 175 176 177 +Rules (150) + on left: 162 163, on right: 162 178 179 182 183 +SkipRule (151) + on left: 164, on right: 151 +ConditionalRule (152) + on left: 165 166, on right: 152 +CaseRule (153) + on left: 167 168, on right: 153 +CaseLabel (154) + on left: 169 170 171, on right: 172 173 +CaseLabels (155) + on left: 172 173, on right: 167 172 +LetRule (156) + on left: 174, on right: 154 +ForallRule (157) + on left: 175, on right: 155 +ChooseRule (158) + on left: 176, on right: 156 +IterateRule (159) + on left: 177, on right: 157 +BlockRule (160) + on left: 178 179 180 181, on right: 158 +SequenceRule (161) + on left: 182 183 184 185, on right: 159 +UpdateRule (162) + on left: 186, on right: 160 +CallRule (163) + on left: 187 188 189 190, on right: 161 +Attribute (164) + on left: 191 192, on right: 193 194 +Attributes (165) + on left: 193 194, on right: 10 63 193 +BasicAttribute (166) + on left: 195, on right: 191 +ExpressionAttribute (167) + on left: 196, on right: 192 State 0 @@ -536,8019 +557,8320 @@ State 1 1 Specification: "CASM" . Definitions - error shift, and go to state 3 - "init" shift, and go to state 4 - "derived" shift, and go to state 5 - "enum" shift, and go to state 6 - "rule" shift, and go to state 7 - "function" shift, and go to state 8 - "structure" shift, and go to state 9 - "feature" shift, and go to state 10 - "[" shift, and go to state 11 - - Definition go to state 12 - AttributedDefinition go to state 13 - Definitions go to state 14 - FunctionDefinition go to state 15 - ProgramFunctionDefinition go to state 16 - DerivedDefinition go to state 17 - EnumerationDefinition go to state 18 - StructureDefinition go to state 19 - FeatureDefinition go to state 20 - RuleDefinition go to state 21 + error shift, and go to state 3 + "init" shift, and go to state 4 + "derived" shift, and go to state 5 + "enum" shift, and go to state 6 + "rule" shift, and go to state 7 + "function" shift, and go to state 8 + "structure" shift, and go to state 9 + "feature" shift, and go to state 10 + "implements" shift, and go to state 11 + "[" shift, and go to state 12 + + Definition go to state 13 + AttributedDefinition go to state 14 + Definitions go to state 15 + FunctionDefinition go to state 16 + ProgramFunctionDefinition go to state 17 + DerivedDefinition go to state 18 + EnumerationDefinition go to state 19 + StructureDefinition go to state 20 + FeatureDefinition go to state 21 + ImplementationDefinition go to state 22 + RuleDefinition go to state 23 State 2 0 $accept: Specification . "end of file" - "end of file" shift, and go to state 22 + "end of file" shift, and go to state 24 State 3 - 8 Definition: error . + 9 Definition: error . - $default reduce using rule 8 (Definition) + $default reduce using rule 9 (Definition) State 4 - 25 ProgramFunctionDefinition: "init" . IdentifierPath - 26 | "init" . "{" MaybeInitializers "}" + 26 ProgramFunctionDefinition: "init" . IdentifierPath + 27 | "init" . "{" MaybeInitializers "}" - "in" shift, and go to state 23 - "{" shift, and go to state 24 - "." shift, and go to state 25 - "identifier" shift, and go to state 26 + "this" shift, and go to state 25 + "in" shift, and go to state 26 + "{" shift, and go to state 27 + "." shift, and go to state 28 + "identifier" shift, and go to state 29 - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 29 + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 32 State 5 - 34 DerivedDefinition: "derived" . Identifier MaybeParameters "->" Type "=" Term + 35 DerivedDefinition: "derived" . Identifier MaybeParameters "->" Type "=" Term - "in" shift, and go to state 23 - "identifier" shift, and go to state 26 + "in" shift, and go to state 26 + "identifier" shift, and go to state 29 - Identifier go to state 30 + Identifier go to state 33 State 6 - 35 EnumerationDefinition: "enum" . Identifier "=" "{" Identifiers "}" + 36 EnumerationDefinition: "enum" . Identifier "=" "{" Identifiers "}" - "in" shift, and go to state 23 - "identifier" shift, and go to state 26 + "in" shift, and go to state 26 + "identifier" shift, and go to state 29 - Identifier go to state 31 + Identifier go to state 34 State 7 - 141 RuleDefinition: "rule" . Identifier MaybeParameters "=" Rule - 142 | "rule" . Identifier MaybeParameters "->" Type "=" Rule + 149 RuleDefinition: "rule" . Identifier MaybeParameters "=" Rule + 150 | "rule" . Identifier MaybeParameters "->" Type "=" Rule - "in" shift, and go to state 23 - "identifier" shift, and go to state 26 + "in" shift, and go to state 26 + "identifier" shift, and go to state 29 - Identifier go to state 32 + Identifier go to state 35 State 8 - 13 FunctionDefinition: "function" . Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially + 14 FunctionDefinition: "function" . Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially - "in" shift, and go to state 23 - "identifier" shift, and go to state 26 + "in" shift, and go to state 26 + "identifier" shift, and go to state 29 - Identifier go to state 33 + Identifier go to state 36 State 9 - 36 StructureDefinition: "structure" . Identifier "=" "{" FunctionDefinitions "}" + 37 StructureDefinition: "structure" . Identifier "=" "{" FunctionDefinitions "}" - "in" shift, and go to state 23 - "identifier" shift, and go to state 26 + "in" shift, and go to state 26 + "identifier" shift, and go to state 29 - Identifier go to state 34 + Identifier go to state 37 State 10 - 37 FeatureDefinition: "feature" . Identifier "=" "{" FeatureDeclarationsAndDefinitions "}" + 38 FeatureDefinition: "feature" . Identifier "=" "{" FeatureDeclarationsAndDefinitions "}" - "in" shift, and go to state 23 - "identifier" shift, and go to state 26 + "in" shift, and go to state 26 + "identifier" shift, and go to state 29 - Identifier go to state 35 + Identifier go to state 38 State 11 - 9 AttributedDefinition: "[" . Attributes "]" Definition + 44 ImplementationDefinition: "implements" . IdentifierPath "for" Type "=" "{" ImplementationDefinitionDefinitions "}" + 45 | "implements" . Type "=" "{" ImplementationDefinitionDefinitions "}" - "in" shift, and go to state 23 - "identifier" shift, and go to state 26 + "this" shift, and go to state 25 + "in" shift, and go to state 26 + "." shift, and go to state 28 + "identifier" shift, and go to state 29 - Identifier go to state 36 - Attribute go to state 37 - Attributes go to state 38 - BasicAttribute go to state 39 - ExpressionAttribute go to state 40 + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 39 + Type go to state 40 + BasicType go to state 41 + ComposedType go to state 42 + RelationType go to state 43 + FixedSizedType go to state 44 State 12 - 10 AttributedDefinition: Definition . + 10 AttributedDefinition: "[" . Attributes "]" Definition - $default reduce using rule 10 (AttributedDefinition) + "in" shift, and go to state 26 + "identifier" shift, and go to state 29 + + Identifier go to state 45 + Attribute go to state 46 + Attributes go to state 47 + BasicAttribute go to state 48 + ExpressionAttribute go to state 49 State 13 - 12 Definitions: AttributedDefinition . + 11 AttributedDefinition: Definition . - $default reduce using rule 12 (Definitions) + $default reduce using rule 11 (AttributedDefinition) State 14 + 13 Definitions: AttributedDefinition . + + $default reduce using rule 13 (Definitions) + + +State 15 + 1 Specification: "CASM" Definitions . - 11 Definitions: Definitions . AttributedDefinition - - error shift, and go to state 3 - "init" shift, and go to state 4 - "derived" shift, and go to state 5 - "enum" shift, and go to state 6 - "rule" shift, and go to state 7 - "function" shift, and go to state 8 - "structure" shift, and go to state 9 - "feature" shift, and go to state 10 - "[" shift, and go to state 11 + 12 Definitions: Definitions . AttributedDefinition + + error shift, and go to state 3 + "init" shift, and go to state 4 + "derived" shift, and go to state 5 + "enum" shift, and go to state 6 + "rule" shift, and go to state 7 + "function" shift, and go to state 8 + "structure" shift, and go to state 9 + "feature" shift, and go to state 10 + "implements" shift, and go to state 11 + "[" shift, and go to state 12 "end of file" reduce using rule 1 (Specification) - Definition go to state 12 - AttributedDefinition go to state 41 - FunctionDefinition go to state 15 - ProgramFunctionDefinition go to state 16 - DerivedDefinition go to state 17 - EnumerationDefinition go to state 18 - StructureDefinition go to state 19 - FeatureDefinition go to state 20 - RuleDefinition go to state 21 + Definition go to state 13 + AttributedDefinition go to state 50 + FunctionDefinition go to state 16 + ProgramFunctionDefinition go to state 17 + DerivedDefinition go to state 18 + EnumerationDefinition go to state 19 + StructureDefinition go to state 20 + FeatureDefinition go to state 21 + ImplementationDefinition go to state 22 + RuleDefinition go to state 23 -State 15 +State 16 2 Definition: FunctionDefinition . $default reduce using rule 2 (Definition) -State 16 +State 17 - 14 FunctionDefinition: ProgramFunctionDefinition . + 15 FunctionDefinition: ProgramFunctionDefinition . - $default reduce using rule 14 (FunctionDefinition) + $default reduce using rule 15 (FunctionDefinition) -State 17 +State 18 3 Definition: DerivedDefinition . $default reduce using rule 3 (Definition) -State 18 +State 19 5 Definition: EnumerationDefinition . $default reduce using rule 5 (Definition) -State 19 +State 20 6 Definition: StructureDefinition . $default reduce using rule 6 (Definition) -State 20 +State 21 7 Definition: FeatureDefinition . $default reduce using rule 7 (Definition) -State 21 - - 4 Definition: RuleDefinition . - - $default reduce using rule 4 (Definition) - - State 22 - 0 $accept: Specification "end of file" . + 8 Definition: ImplementationDefinition . - $default accept + $default reduce using rule 8 (Definition) State 23 - 46 Identifier: "in" . + 4 Definition: RuleDefinition . - $default reduce using rule 46 (Identifier) + $default reduce using rule 4 (Definition) State 24 - 26 ProgramFunctionDefinition: "init" "{" . MaybeInitializers "}" - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 53 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - $default reduce using rule 33 (MaybeInitializers) + 0 $accept: Specification "end of file" . - Initializer go to state 62 - Initializers go to state 63 - MaybeInitializers go to state 64 - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 75 - Expression go to state 76 - Range go to state 77 - List go to state 78 - TwoOrMoreArguments go to state 79 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + $default accept State 25 - 52 IdentifierPath: "." . DotSeparatedIdentifiers - - "in" shift, and go to state 23 - "identifier" shift, and go to state 26 + 60 IdentifierPath: "this" . "." DotSeparatedIdentifiers - Identifier go to state 27 - DotSeparatedIdentifiers go to state 87 + "." shift, and go to state 51 State 26 - 45 Identifier: "identifier" . + 53 Identifier: "in" . - $default reduce using rule 45 (Identifier) + $default reduce using rule 53 (Identifier) State 27 - 50 DotSeparatedIdentifiers: Identifier . - - $default reduce using rule 50 (DotSeparatedIdentifiers) + 27 ProgramFunctionDefinition: "init" "{" . MaybeInitializers "}" + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 63 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + $default reduce using rule 34 (MaybeInitializers) + + Initializer go to state 72 + Initializers go to state 73 + MaybeInitializers go to state 74 + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 85 + Expression go to state 86 + Range go to state 87 + List go to state 88 + TwoOrMoreArguments go to state 89 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 28 - 49 DotSeparatedIdentifiers: DotSeparatedIdentifiers . "." Identifier - 51 IdentifierPath: DotSeparatedIdentifiers . + 59 IdentifierPath: "." . DotSeparatedIdentifiers - "." shift, and go to state 88 + "in" shift, and go to state 26 + "identifier" shift, and go to state 29 - $default reduce using rule 51 (IdentifierPath) + Identifier go to state 30 + DotSeparatedIdentifiers go to state 97 State 29 - 25 ProgramFunctionDefinition: "init" IdentifierPath . + 52 Identifier: "identifier" . - $default reduce using rule 25 (ProgramFunctionDefinition) + $default reduce using rule 52 (Identifier) State 30 - 34 DerivedDefinition: "derived" Identifier . MaybeParameters "->" Type "=" Term + 57 DotSeparatedIdentifiers: Identifier . - "(" shift, and go to state 89 - - $default reduce using rule 61 (MaybeParameters) - - MaybeParameters go to state 90 + $default reduce using rule 57 (DotSeparatedIdentifiers) State 31 - 35 EnumerationDefinition: "enum" Identifier . "=" "{" Identifiers "}" + 56 DotSeparatedIdentifiers: DotSeparatedIdentifiers . "." Identifier + 58 IdentifierPath: DotSeparatedIdentifiers . + + "." shift, and go to state 98 - "=" shift, and go to state 91 + $default reduce using rule 58 (IdentifierPath) State 32 - 141 RuleDefinition: "rule" Identifier . MaybeParameters "=" Rule - 142 | "rule" Identifier . MaybeParameters "->" Type "=" Rule + 26 ProgramFunctionDefinition: "init" IdentifierPath . - "(" shift, and go to state 89 + $default reduce using rule 26 (ProgramFunctionDefinition) - $default reduce using rule 61 (MaybeParameters) - MaybeParameters go to state 92 +State 33 + 35 DerivedDefinition: "derived" Identifier . MaybeParameters "->" Type "=" Term -State 33 + "(" shift, and go to state 99 - 13 FunctionDefinition: "function" Identifier . ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially + $default reduce using rule 69 (MaybeParameters) - ":" shift, and go to state 93 + MaybeParameters go to state 100 State 34 - 36 StructureDefinition: "structure" Identifier . "=" "{" FunctionDefinitions "}" + 36 EnumerationDefinition: "enum" Identifier . "=" "{" Identifiers "}" - "=" shift, and go to state 94 + "=" shift, and go to state 101 State 35 - 37 FeatureDefinition: "feature" Identifier . "=" "{" FeatureDeclarationsAndDefinitions "}" + 149 RuleDefinition: "rule" Identifier . MaybeParameters "=" Rule + 150 | "rule" Identifier . MaybeParameters "->" Type "=" Rule - "=" shift, and go to state 95 + "(" shift, and go to state 99 + + $default reduce using rule 69 (MaybeParameters) + + MaybeParameters go to state 102 State 36 - 187 BasicAttribute: Identifier . - 188 ExpressionAttribute: Identifier . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - $default reduce using rule 187 (BasicAttribute) - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 97 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 14 FunctionDefinition: "function" Identifier . ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially + + ":" shift, and go to state 103 State 37 - 186 Attributes: Attribute . + 37 StructureDefinition: "structure" Identifier . "=" "{" FunctionDefinitions "}" - $default reduce using rule 186 (Attributes) + "=" shift, and go to state 104 State 38 - 9 AttributedDefinition: "[" Attributes . "]" Definition - 185 Attributes: Attributes . "," Attribute + 38 FeatureDefinition: "feature" Identifier . "=" "{" FeatureDeclarationsAndDefinitions "}" - "]" shift, and go to state 98 - "," shift, and go to state 99 + "=" shift, and go to state 105 State 39 - 183 Attribute: BasicAttribute . + 44 ImplementationDefinition: "implements" IdentifierPath . "for" Type "=" "{" ImplementationDefinitionDefinitions "}" + 74 BasicType: IdentifierPath . + 75 ComposedType: IdentifierPath . "<" Types ">" + 76 RelationType: IdentifierPath . "<" MaybeFunctionParameters "->" Type ">" + 77 FixedSizedType: IdentifierPath . "'" Term + + "for" shift, and go to state 106 + "<" shift, and go to state 107 + "'" shift, and go to state 108 - $default reduce using rule 183 (Attribute) + $default reduce using rule 74 (BasicType) State 40 - 184 Attribute: ExpressionAttribute . + 45 ImplementationDefinition: "implements" Type . "=" "{" ImplementationDefinitionDefinitions "}" - $default reduce using rule 184 (Attribute) + "=" shift, and go to state 109 State 41 - 11 Definitions: Definitions AttributedDefinition . + 70 Type: BasicType . - $default reduce using rule 11 (Definitions) + $default reduce using rule 70 (Type) State 42 - 136 LetExpression: "let" . AttributedVariable "=" Term "in" Term + 71 Type: ComposedType . - "in" shift, and go to state 23 - "[" shift, and go to state 100 - "identifier" shift, and go to state 26 - - Identifier go to state 101 - Variable go to state 102 - AttributedVariable go to state 103 + $default reduce using rule 71 (Type) State 43 - 139 UniversalQuantifierExpression: "forall" . AttributedVariable "in" Term "holds" Term - - "in" shift, and go to state 23 - "[" shift, and go to state 100 - "identifier" shift, and go to state 26 + 72 Type: RelationType . - Identifier go to state 101 - Variable go to state 102 - AttributedVariable go to state 104 + $default reduce using rule 72 (Type) State 44 - 138 ChooseExpression: "choose" . AttributedVariable "in" Term "do" Term - - "in" shift, and go to state 23 - "[" shift, and go to state 100 - "identifier" shift, and go to state 26 + 73 Type: FixedSizedType . - Identifier go to state 101 - Variable go to state 102 - AttributedVariable go to state 105 + $default reduce using rule 73 (Type) State 45 - 137 ConditionalExpression: "if" . Term "then" Term "else" Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 106 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 195 BasicAttribute: Identifier . + 196 ExpressionAttribute: Identifier . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + $default reduce using rule 195 (BasicAttribute) + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 111 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 46 - 140 ExistentialQuantifierExpression: "exists" . AttributedVariable "in" Term "with" Term + 194 Attributes: Attribute . - "in" shift, and go to state 23 - "[" shift, and go to state 100 - "identifier" shift, and go to state 26 - - Identifier go to state 101 - Variable go to state 102 - AttributedVariable go to state 107 + $default reduce using rule 194 (Attributes) State 47 - 80 Undefined: "undef" . + 10 AttributedDefinition: "[" Attributes . "]" Definition + 193 Attributes: Attributes . "," Attribute - $default reduce using rule 80 (Undefined) + "]" shift, and go to state 112 + "," shift, and go to state 113 State 48 - 82 Boolean: "false" . + 191 Attribute: BasicAttribute . - $default reduce using rule 82 (Boolean) + $default reduce using rule 191 (Attribute) State 49 - 81 Boolean: "true" . + 192 Attribute: ExpressionAttribute . - $default reduce using rule 81 (Boolean) + $default reduce using rule 192 (Attribute) State 50 - 122 Expression: "not" . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 108 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 12 Definitions: Definitions AttributedDefinition . + + $default reduce using rule 12 (Definitions) State 51 - 103 Expression: "+" . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 109 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 60 IdentifierPath: "this" "." . DotSeparatedIdentifiers + + "in" shift, and go to state 26 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 114 State 52 - 104 Expression: "-" . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 110 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 144 LetExpression: "let" . AttributedVariable "=" Term "in" Term + + "in" shift, and go to state 26 + "[" shift, and go to state 115 + "identifier" shift, and go to state 29 + + Identifier go to state 116 + Variable go to state 117 + AttributedVariable go to state 118 State 53 - 101 Expression: "(" . Term ")" - 102 | "(" . error ")" - 132 TwoOrMoreArguments: "(" . Terms "," Term ")" - 135 IndirectCallExpression: "(" . "*" Term ")" Arguments - - error shift, and go to state 111 - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "*" shift, and go to state 112 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 113 - Expression go to state 76 - Range go to state 77 - List go to state 78 - Terms go to state 114 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 147 UniversalQuantifierExpression: "forall" . AttributedVariable "in" Term "holds" Term + + "in" shift, and go to state 26 + "[" shift, and go to state 115 + "identifier" shift, and go to state 29 + + Identifier go to state 116 + Variable go to state 117 + AttributedVariable go to state 119 State 54 - 123 Range: "[" . Term ".." Term "]" - 124 List: "[" . "]" - 125 | "[" . Terms "]" - 126 | "[" . error "]" - - error shift, and go to state 115 - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "]" shift, and go to state 116 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 117 - Expression go to state 76 - Range go to state 77 - List go to state 78 - Terms go to state 118 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 146 ChooseExpression: "choose" . AttributedVariable "in" Term "do" Term + "in" shift, and go to state 26 + "[" shift, and go to state 115 + "identifier" shift, and go to state 29 -State 55 + Identifier go to state 116 + Variable go to state 117 + AttributedVariable go to state 120 - 89 Reference: "@" . IdentifierPath - "in" shift, and go to state 23 - "." shift, and go to state 25 - "identifier" shift, and go to state 26 +State 55 - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 119 + 145 ConditionalExpression: "if" . Term "then" Term "else" Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 121 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 56 - 84 BitNumber: "binary" . + 148 ExistentialQuantifierExpression: "exists" . AttributedVariable "in" Term "with" Term - $default reduce using rule 84 (BitNumber) + "in" shift, and go to state 26 + "[" shift, and go to state 115 + "identifier" shift, and go to state 29 + + Identifier go to state 116 + Variable go to state 117 + AttributedVariable go to state 122 State 57 - 85 BitNumber: "hexadecimal" . + 88 Undefined: "undef" . - $default reduce using rule 85 (BitNumber) + $default reduce using rule 88 (Undefined) State 58 - 86 IntegerNumber: "integer" . + 90 Boolean: "false" . - $default reduce using rule 86 (IntegerNumber) + $default reduce using rule 90 (Boolean) State 59 - 88 RationalNumber: "rational" . + 89 Boolean: "true" . - $default reduce using rule 88 (RationalNumber) + $default reduce using rule 89 (Boolean) State 60 - 87 FloatingNumber: "floating" . - - $default reduce using rule 87 (FloatingNumber) + 130 Expression: "not" . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 123 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 61 - 83 String: "string" . - - $default reduce using rule 83 (String) + 111 Expression: "+" . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 124 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 62 - 31 Initializers: Initializer . - - $default reduce using rule 31 (Initializers) + 112 Expression: "-" . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 125 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 63 - 30 Initializers: Initializers . "," Initializer - 32 MaybeInitializers: Initializers . - - "," shift, and go to state 120 - - $default reduce using rule 32 (MaybeInitializers) + 109 Expression: "(" . Term ")" + 110 | "(" . error ")" + 140 TwoOrMoreArguments: "(" . Terms "," Term ")" + 143 IndirectCallExpression: "(" . "*" Term ")" Arguments + + error shift, and go to state 126 + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "*" shift, and go to state 127 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 128 + Expression go to state 86 + Range go to state 87 + List go to state 88 + Terms go to state 129 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 64 - 26 ProgramFunctionDefinition: "init" "{" MaybeInitializers . "}" - - "}" shift, and go to state 121 + 131 Range: "[" . Term ".." Term "]" + 132 List: "[" . "]" + 133 | "[" . Terms "]" + 134 | "[" . error "]" + + error shift, and go to state 130 + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "]" shift, and go to state 131 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 132 + Expression go to state 86 + Range go to state 87 + List go to state 88 + Terms go to state 133 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 65 - 133 DirectCallExpression: IdentifierPath . - 134 | IdentifierPath . Arguments - - "(" shift, and go to state 122 + 97 Reference: "@" . IdentifierPath - $default reduce using rule 133 (DirectCallExpression) + "this" shift, and go to state 25 + "in" shift, and go to state 26 + "." shift, and go to state 28 + "identifier" shift, and go to state 29 - Arguments go to state 123 + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 134 State 66 - 100 Term: Atom . + 92 BitNumber: "binary" . - $default reduce using rule 100 (Term) + $default reduce using rule 92 (BitNumber) State 67 - 78 Atom: Undefined . + 93 BitNumber: "hexadecimal" . - $default reduce using rule 78 (Atom) + $default reduce using rule 93 (BitNumber) State 68 - 79 Atom: Boolean . + 94 IntegerNumber: "integer" . - $default reduce using rule 79 (Atom) + $default reduce using rule 94 (IntegerNumber) State 69 - 77 Atom: String . + 96 RationalNumber: "rational" . - $default reduce using rule 77 (Atom) + $default reduce using rule 96 (RationalNumber) State 70 - 73 Atom: BitNumber . + 95 FloatingNumber: "floating" . - $default reduce using rule 73 (Atom) + $default reduce using rule 95 (FloatingNumber) State 71 - 74 Atom: IntegerNumber . + 91 String: "string" . - $default reduce using rule 74 (Atom) + $default reduce using rule 91 (String) State 72 - 75 Atom: FloatingNumber . + 32 Initializers: Initializer . - $default reduce using rule 75 (Atom) + $default reduce using rule 32 (Initializers) State 73 - 76 Atom: RationalNumber . + 31 Initializers: Initializers . "," Initializer + 33 MaybeInitializers: Initializers . - $default reduce using rule 76 (Atom) + "," shift, and go to state 135 + + $default reduce using rule 33 (MaybeInitializers) State 74 - 72 Atom: Reference . + 27 ProgramFunctionDefinition: "init" "{" MaybeInitializers . "}" - $default reduce using rule 72 (Atom) + "}" shift, and go to state 136 State 75 - 27 Initializer: Term . - 28 | Term . "->" Term - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "implies" shift, and go to state 127 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "->" shift, and go to state 137 - "=>" shift, and go to state 138 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 - - $default reduce using rule 27 (Initializer) + 141 DirectCallExpression: IdentifierPath . + 142 | IdentifierPath . Arguments + + "(" shift, and go to state 137 + + $default reduce using rule 141 (DirectCallExpression) + + Arguments go to state 138 State 76 - 97 Term: Expression . + 108 Term: Atom . - $default reduce using rule 97 (Term) + $default reduce using rule 108 (Term) State 77 - 99 Term: Range . + 86 Atom: Undefined . - $default reduce using rule 99 (Term) + $default reduce using rule 86 (Atom) State 78 - 98 Term: List . + 87 Atom: Boolean . - $default reduce using rule 98 (Term) + $default reduce using rule 87 (Atom) State 79 - 29 Initializer: TwoOrMoreArguments . "->" Term + 85 Atom: String . - "->" shift, and go to state 142 + $default reduce using rule 85 (Atom) State 80 - 90 Term: DirectCallExpression . + 81 Atom: BitNumber . - $default reduce using rule 90 (Term) + $default reduce using rule 81 (Atom) State 81 - 91 Term: IndirectCallExpression . + 82 Atom: IntegerNumber . - $default reduce using rule 91 (Term) + $default reduce using rule 82 (Atom) State 82 - 92 Term: LetExpression . + 83 Atom: FloatingNumber . - $default reduce using rule 92 (Term) + $default reduce using rule 83 (Atom) State 83 - 93 Term: ConditionalExpression . + 84 Atom: RationalNumber . - $default reduce using rule 93 (Term) + $default reduce using rule 84 (Atom) State 84 - 94 Term: ChooseExpression . + 80 Atom: Reference . - $default reduce using rule 94 (Term) + $default reduce using rule 80 (Atom) State 85 - 95 Term: UniversalQuantifierExpression . + 28 Initializer: Term . + 29 | Term . "->" Term + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "implies" shift, and go to state 142 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "->" shift, and go to state 152 + "=>" shift, and go to state 153 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 - $default reduce using rule 95 (Term) + $default reduce using rule 28 (Initializer) State 86 - 96 Term: ExistentialQuantifierExpression . + 105 Term: Expression . - $default reduce using rule 96 (Term) + $default reduce using rule 105 (Term) State 87 - 49 DotSeparatedIdentifiers: DotSeparatedIdentifiers . "." Identifier - 52 IdentifierPath: "." DotSeparatedIdentifiers . + 107 Term: Range . - $default reduce using rule 52 (IdentifierPath) + $default reduce using rule 107 (Term) State 88 - 49 DotSeparatedIdentifiers: DotSeparatedIdentifiers "." . Identifier - - "in" shift, and go to state 23 - "identifier" shift, and go to state 26 + 106 Term: List . - Identifier go to state 143 + $default reduce using rule 106 (Term) State 89 - 59 MaybeParameters: "(" . Parameters ")" - 60 | "(" . error ")" + 30 Initializer: TwoOrMoreArguments . "->" Term - error shift, and go to state 144 - "in" shift, and go to state 23 - "[" shift, and go to state 100 - "identifier" shift, and go to state 26 - - Identifier go to state 101 - Variable go to state 102 - AttributedVariable go to state 145 - Parameters go to state 146 + "->" shift, and go to state 157 State 90 - 34 DerivedDefinition: "derived" Identifier MaybeParameters . "->" Type "=" Term + 98 Term: DirectCallExpression . - "->" shift, and go to state 147 + $default reduce using rule 98 (Term) State 91 - 35 EnumerationDefinition: "enum" Identifier "=" . "{" Identifiers "}" + 99 Term: IndirectCallExpression . - "{" shift, and go to state 148 + $default reduce using rule 99 (Term) State 92 - 141 RuleDefinition: "rule" Identifier MaybeParameters . "=" Rule - 142 | "rule" Identifier MaybeParameters . "->" Type "=" Rule + 100 Term: LetExpression . - "=" shift, and go to state 149 - "->" shift, and go to state 150 + $default reduce using rule 100 (Term) State 93 - 13 FunctionDefinition: "function" Identifier ":" . MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially + 101 Term: ConditionalExpression . - "in" shift, and go to state 23 - "." shift, and go to state 25 - "identifier" shift, and go to state 26 - - $default reduce using rule 24 (MaybeFunctionParameters) - - FunctionParameters go to state 151 - MaybeFunctionParameters go to state 152 - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 153 - Type go to state 154 - BasicType go to state 155 - ComposedType go to state 156 - RelationType go to state 157 - FixedSizedType go to state 158 + $default reduce using rule 101 (Term) State 94 - 36 StructureDefinition: "structure" Identifier "=" . "{" FunctionDefinitions "}" + 102 Term: ChooseExpression . - "{" shift, and go to state 159 + $default reduce using rule 102 (Term) State 95 - 37 FeatureDefinition: "feature" Identifier "=" . "{" FeatureDeclarationsAndDefinitions "}" + 103 Term: UniversalQuantifierExpression . - "{" shift, and go to state 160 + $default reduce using rule 103 (Term) State 96 - 101 Expression: "(" . Term ")" - 102 | "(" . error ")" - 135 IndirectCallExpression: "(" . "*" Term ")" Arguments - - error shift, and go to state 111 - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "*" shift, and go to state 112 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 161 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 104 Term: ExistentialQuantifierExpression . + + $default reduce using rule 104 (Term) State 97 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - 188 ExpressionAttribute: Identifier Term . - - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "implies" shift, and go to state 127 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "=>" shift, and go to state 138 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 - - $default reduce using rule 188 (ExpressionAttribute) + 56 DotSeparatedIdentifiers: DotSeparatedIdentifiers . "." Identifier + 59 IdentifierPath: "." DotSeparatedIdentifiers . + + $default reduce using rule 59 (IdentifierPath) State 98 - 9 AttributedDefinition: "[" Attributes "]" . Definition + 56 DotSeparatedIdentifiers: DotSeparatedIdentifiers "." . Identifier - error shift, and go to state 3 - "init" shift, and go to state 4 - "derived" shift, and go to state 5 - "enum" shift, and go to state 6 - "rule" shift, and go to state 7 - "function" shift, and go to state 8 - "structure" shift, and go to state 9 - "feature" shift, and go to state 10 + "in" shift, and go to state 26 + "identifier" shift, and go to state 29 - Definition go to state 162 - FunctionDefinition go to state 15 - ProgramFunctionDefinition go to state 16 - DerivedDefinition go to state 17 - EnumerationDefinition go to state 18 - StructureDefinition go to state 19 - FeatureDefinition go to state 20 - RuleDefinition go to state 21 + Identifier go to state 158 State 99 - 185 Attributes: Attributes "," . Attribute + 67 MaybeParameters: "(" . Parameters ")" + 68 | "(" . error ")" - "in" shift, and go to state 23 - "identifier" shift, and go to state 26 + error shift, and go to state 159 + "in" shift, and go to state 26 + "[" shift, and go to state 115 + "identifier" shift, and go to state 29 - Identifier go to state 36 - Attribute go to state 163 - BasicAttribute go to state 39 - ExpressionAttribute go to state 40 + Identifier go to state 116 + Variable go to state 117 + AttributedVariable go to state 160 + Parameters go to state 161 State 100 - 55 AttributedVariable: "[" . Attributes "]" Variable + 35 DerivedDefinition: "derived" Identifier MaybeParameters . "->" Type "=" Term - "in" shift, and go to state 23 - "identifier" shift, and go to state 26 - - Identifier go to state 36 - Attribute go to state 37 - Attributes go to state 164 - BasicAttribute go to state 39 - ExpressionAttribute go to state 40 + "->" shift, and go to state 162 State 101 - 53 Variable: Identifier . ":" Type - 54 | Identifier . - - ":" shift, and go to state 165 + 36 EnumerationDefinition: "enum" Identifier "=" . "{" Identifiers "}" - $default reduce using rule 54 (Variable) + "{" shift, and go to state 163 State 102 - 56 AttributedVariable: Variable . + 149 RuleDefinition: "rule" Identifier MaybeParameters . "=" Rule + 150 | "rule" Identifier MaybeParameters . "->" Type "=" Rule - $default reduce using rule 56 (AttributedVariable) + "=" shift, and go to state 164 + "->" shift, and go to state 165 State 103 - 136 LetExpression: "let" AttributedVariable . "=" Term "in" Term + 14 FunctionDefinition: "function" Identifier ":" . MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially + + "this" shift, and go to state 25 + "in" shift, and go to state 26 + "." shift, and go to state 28 + "identifier" shift, and go to state 29 - "=" shift, and go to state 166 + $default reduce using rule 25 (MaybeFunctionParameters) + + FunctionParameters go to state 166 + MaybeFunctionParameters go to state 167 + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 168 + Type go to state 169 + BasicType go to state 41 + ComposedType go to state 42 + RelationType go to state 43 + FixedSizedType go to state 44 State 104 - 139 UniversalQuantifierExpression: "forall" AttributedVariable . "in" Term "holds" Term + 37 StructureDefinition: "structure" Identifier "=" . "{" FunctionDefinitions "}" - "in" shift, and go to state 167 + "{" shift, and go to state 170 State 105 - 138 ChooseExpression: "choose" AttributedVariable . "in" Term "do" Term + 38 FeatureDefinition: "feature" Identifier "=" . "{" FeatureDeclarationsAndDefinitions "}" - "in" shift, and go to state 168 + "{" shift, and go to state 171 State 106 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - 137 ConditionalExpression: "if" Term . "then" Term "else" Term - - "then" shift, and go to state 169 - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "implies" shift, and go to state 127 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "=>" shift, and go to state 138 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 + 44 ImplementationDefinition: "implements" IdentifierPath "for" . Type "=" "{" ImplementationDefinitionDefinitions "}" + + "this" shift, and go to state 25 + "in" shift, and go to state 26 + "." shift, and go to state 28 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 168 + Type go to state 172 + BasicType go to state 41 + ComposedType go to state 42 + RelationType go to state 43 + FixedSizedType go to state 44 State 107 - 140 ExistentialQuantifierExpression: "exists" AttributedVariable . "in" Term "with" Term + 75 ComposedType: IdentifierPath "<" . Types ">" + 76 RelationType: IdentifierPath "<" . MaybeFunctionParameters "->" Type ">" - "in" shift, and go to state 170 + "this" shift, and go to state 25 + "in" shift, and go to state 26 + "." shift, and go to state 28 + "identifier" shift, and go to state 29 + $default reduce using rule 25 (MaybeFunctionParameters) -State 108 + FunctionParameters go to state 166 + MaybeFunctionParameters go to state 173 + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 168 + Type go to state 174 + BasicType go to state 41 + ComposedType go to state 42 + RelationType go to state 43 + FixedSizedType go to state 44 + Types go to state 175 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - 122 | "not" Term . - $default reduce using rule 122 (Expression) +State 108 + + 77 FixedSizedType: IdentifierPath "'" . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 176 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 109 - 103 Expression: "+" Term . - 105 | Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - - $default reduce using rule 103 (Expression) + 45 ImplementationDefinition: "implements" Type "=" . "{" ImplementationDefinitionDefinitions "}" + + "{" shift, and go to state 177 State 110 - 104 Expression: "-" Term . - 105 | Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - - $default reduce using rule 104 (Expression) + 109 Expression: "(" . Term ")" + 110 | "(" . error ")" + 143 IndirectCallExpression: "(" . "*" Term ")" Arguments + + error shift, and go to state 126 + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "*" shift, and go to state 127 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 178 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 111 - 102 Expression: "(" error . ")" - - ")" shift, and go to state 171 + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + 196 ExpressionAttribute: Identifier Term . + + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "implies" shift, and go to state 142 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "=>" shift, and go to state 153 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 + + $default reduce using rule 196 (ExpressionAttribute) State 112 - 135 IndirectCallExpression: "(" "*" . Term ")" Arguments - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 172 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 10 AttributedDefinition: "[" Attributes "]" . Definition + + error shift, and go to state 3 + "init" shift, and go to state 4 + "derived" shift, and go to state 5 + "enum" shift, and go to state 6 + "rule" shift, and go to state 7 + "function" shift, and go to state 8 + "structure" shift, and go to state 9 + "feature" shift, and go to state 10 + "implements" shift, and go to state 11 + + Definition go to state 179 + FunctionDefinition go to state 16 + ProgramFunctionDefinition go to state 17 + DerivedDefinition go to state 18 + EnumerationDefinition go to state 19 + StructureDefinition go to state 20 + FeatureDefinition go to state 21 + ImplementationDefinition go to state 22 + RuleDefinition go to state 23 State 113 - 101 Expression: "(" Term . ")" - 105 | Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - 128 Terms: Term . - - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "implies" shift, and go to state 127 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - ")" shift, and go to state 173 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "=>" shift, and go to state 138 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 - - $default reduce using rule 128 (Terms) + 193 Attributes: Attributes "," . Attribute + + "in" shift, and go to state 26 + "identifier" shift, and go to state 29 + + Identifier go to state 45 + Attribute go to state 180 + BasicAttribute go to state 48 + ExpressionAttribute go to state 49 State 114 - 127 Terms: Terms . "," Term - 132 TwoOrMoreArguments: "(" Terms . "," Term ")" + 56 DotSeparatedIdentifiers: DotSeparatedIdentifiers . "." Identifier + 60 IdentifierPath: "this" "." DotSeparatedIdentifiers . - "," shift, and go to state 174 + $default reduce using rule 60 (IdentifierPath) State 115 - 126 List: "[" error . "]" + 63 AttributedVariable: "[" . Attributes "]" Variable + + "in" shift, and go to state 26 + "identifier" shift, and go to state 29 - "]" shift, and go to state 175 + Identifier go to state 45 + Attribute go to state 46 + Attributes go to state 181 + BasicAttribute go to state 48 + ExpressionAttribute go to state 49 State 116 - 124 List: "[" "]" . + 61 Variable: Identifier . ":" Type + 62 | Identifier . + + ":" shift, and go to state 182 - $default reduce using rule 124 (List) + $default reduce using rule 62 (Variable) State 117 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - 123 Range: "[" Term . ".." Term "]" - 128 Terms: Term . - - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "implies" shift, and go to state 127 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - ".." shift, and go to state 176 - "=>" shift, and go to state 138 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 - - $default reduce using rule 128 (Terms) + 64 AttributedVariable: Variable . + + $default reduce using rule 64 (AttributedVariable) State 118 - 125 List: "[" Terms . "]" - 127 Terms: Terms . "," Term + 144 LetExpression: "let" AttributedVariable . "=" Term "in" Term - "]" shift, and go to state 177 - "," shift, and go to state 178 + "=" shift, and go to state 183 State 119 - 89 Reference: "@" IdentifierPath . + 147 UniversalQuantifierExpression: "forall" AttributedVariable . "in" Term "holds" Term - $default reduce using rule 89 (Reference) + "in" shift, and go to state 184 State 120 - 30 Initializers: Initializers "," . Initializer - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 53 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Initializer go to state 179 - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 75 - Expression go to state 76 - Range go to state 77 - List go to state 78 - TwoOrMoreArguments go to state 79 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 146 ChooseExpression: "choose" AttributedVariable . "in" Term "do" Term + "in" shift, and go to state 185 -State 121 - 26 ProgramFunctionDefinition: "init" "{" MaybeInitializers "}" . +State 121 - $default reduce using rule 26 (ProgramFunctionDefinition) + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + 145 ConditionalExpression: "if" Term . "then" Term "else" Term + + "then" shift, and go to state 186 + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "implies" shift, and go to state 142 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "=>" shift, and go to state 153 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 State 122 - 129 Arguments: "(" . Terms ")" - 130 | "(" . error ")" - 131 | "(" . ")" - - error shift, and go to state 180 - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - ")" shift, and go to state 181 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 182 - Expression go to state 76 - Range go to state 77 - List go to state 78 - Terms go to state 183 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 148 ExistentialQuantifierExpression: "exists" AttributedVariable . "in" Term "with" Term + "in" shift, and go to state 187 -State 123 - 134 DirectCallExpression: IdentifierPath Arguments . +State 123 - $default reduce using rule 134 (DirectCallExpression) + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + 130 | "not" Term . + + $default reduce using rule 130 (Expression) State 124 - 119 Expression: Term "and" . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 184 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 111 Expression: "+" Term . + 113 | Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + + $default reduce using rule 111 (Expression) State 125 - 117 Expression: Term "or" . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 185 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 112 Expression: "-" Term . + 113 | Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + + $default reduce using rule 112 (Expression) State 126 - 118 Expression: Term "xor" . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 186 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 110 Expression: "(" error . ")" + + ")" shift, and go to state 188 State 127 - 121 Expression: Term "implies" . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 187 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 143 IndirectCallExpression: "(" "*" . Term ")" Arguments + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 189 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 128 - 105 Expression: Term "+" . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 188 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 109 Expression: "(" Term . ")" + 113 | Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + 136 Terms: Term . + + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "implies" shift, and go to state 142 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + ")" shift, and go to state 190 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "=>" shift, and go to state 153 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 + + $default reduce using rule 136 (Terms) State 129 - 106 Expression: Term "-" . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 189 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 135 Terms: Terms . "," Term + 140 TwoOrMoreArguments: "(" Terms . "," Term ")" + + "," shift, and go to state 191 State 130 - 112 Expression: Term "=" . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 190 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 134 List: "[" error . "]" + + "]" shift, and go to state 192 State 131 - 113 Expression: Term "<" . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 191 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 132 List: "[" "]" . + + $default reduce using rule 132 (List) State 132 - 114 Expression: Term ">" . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 192 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + 131 Range: "[" Term . ".." Term "]" + 136 Terms: Term . + + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "implies" shift, and go to state 142 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + ".." shift, and go to state 193 + "=>" shift, and go to state 153 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 + + $default reduce using rule 136 (Terms) State 133 - 107 Expression: Term "*" . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 193 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 133 List: "[" Terms . "]" + 135 Terms: Terms . "," Term + + "]" shift, and go to state 194 + "," shift, and go to state 195 State 134 - 108 Expression: Term "/" . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 194 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 97 Reference: "@" IdentifierPath . + + $default reduce using rule 97 (Reference) State 135 - 109 Expression: Term "%" . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 195 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 31 Initializers: Initializers "," . Initializer + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 63 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Initializer go to state 196 + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 85 + Expression go to state 86 + Range go to state 87 + List go to state 88 + TwoOrMoreArguments go to state 89 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 136 - 110 Expression: Term "^" . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 196 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 27 ProgramFunctionDefinition: "init" "{" MaybeInitializers "}" . + + $default reduce using rule 27 (ProgramFunctionDefinition) State 137 - 28 Initializer: Term "->" . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 197 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 137 Arguments: "(" . Terms ")" + 138 | "(" . error ")" + 139 | "(" . ")" + + error shift, and go to state 197 + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + ")" shift, and go to state 198 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 199 + Expression go to state 86 + Range go to state 87 + List go to state 88 + Terms go to state 200 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 138 - 120 Expression: Term "=>" . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 198 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 142 DirectCallExpression: IdentifierPath Arguments . + + $default reduce using rule 142 (DirectCallExpression) State 139 - 111 Expression: Term "!=" . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 199 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 127 Expression: Term "and" . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 201 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 140 - 115 Expression: Term "<=" . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 200 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 125 Expression: Term "or" . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 202 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 141 - 116 Expression: Term ">=" . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 201 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 126 Expression: Term "xor" . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 203 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 142 - 29 Initializer: TwoOrMoreArguments "->" . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 202 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 129 Expression: Term "implies" . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 204 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 143 - 49 DotSeparatedIdentifiers: DotSeparatedIdentifiers "." Identifier . - - $default reduce using rule 49 (DotSeparatedIdentifiers) + 113 Expression: Term "+" . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 205 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 144 - 60 MaybeParameters: "(" error . ")" - - ")" shift, and go to state 203 + 114 Expression: Term "-" . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 206 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 145 - 58 Parameters: AttributedVariable . - - $default reduce using rule 58 (Parameters) + 120 Expression: Term "=" . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 207 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 146 - 57 Parameters: Parameters . "," AttributedVariable - 59 MaybeParameters: "(" Parameters . ")" - - ")" shift, and go to state 204 - "," shift, and go to state 205 + 121 Expression: Term "<" . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 208 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 147 - 34 DerivedDefinition: "derived" Identifier MaybeParameters "->" . Type "=" Term - - "in" shift, and go to state 23 - "." shift, and go to state 25 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 153 - Type go to state 206 - BasicType go to state 155 - ComposedType go to state 156 - RelationType go to state 157 - FixedSizedType go to state 158 + 122 Expression: Term ">" . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 209 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 148 - 35 EnumerationDefinition: "enum" Identifier "=" "{" . Identifiers "}" - - "in" shift, and go to state 23 - "identifier" shift, and go to state 26 - - Identifier go to state 207 - Identifiers go to state 208 + 115 Expression: Term "*" . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 210 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 149 - 141 RuleDefinition: "rule" Identifier MaybeParameters "=" . Rule - - "seq" shift, and go to state 209 - "par" shift, and go to state 210 - "skip" shift, and go to state 211 - "let" shift, and go to state 212 - "in" shift, and go to state 23 - "forall" shift, and go to state 213 - "choose" shift, and go to state 214 - "iterate" shift, and go to state 215 - "call" shift, and go to state 216 - "if" shift, and go to state 217 - "case" shift, and go to state 218 - "(" shift, and go to state 219 - "{" shift, and go to state 220 - "." shift, and go to state 25 - "{|" shift, and go to state 221 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - DirectCallExpression go to state 222 - IndirectCallExpression go to state 223 - Rule go to state 224 - SkipRule go to state 225 - ConditionalRule go to state 226 - CaseRule go to state 227 - LetRule go to state 228 - ForallRule go to state 229 - ChooseRule go to state 230 - IterateRule go to state 231 - BlockRule go to state 232 - SequenceRule go to state 233 - UpdateRule go to state 234 - CallRule go to state 235 + 116 Expression: Term "/" . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 211 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 150 - 142 RuleDefinition: "rule" Identifier MaybeParameters "->" . Type "=" Rule - - "in" shift, and go to state 23 - "." shift, and go to state 25 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 153 - Type go to state 236 - BasicType go to state 155 - ComposedType go to state 156 - RelationType go to state 157 - FixedSizedType go to state 158 + 117 Expression: Term "%" . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 212 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 151 - 21 FunctionParameters: FunctionParameters . "*" Type - 23 MaybeFunctionParameters: FunctionParameters . - - "*" shift, and go to state 237 - - $default reduce using rule 23 (MaybeFunctionParameters) + 118 Expression: Term "^" . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 213 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 152 - 13 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters . "->" Type MaybeDefined MaybeInitially - - "->" shift, and go to state 238 + 29 Initializer: Term "->" . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 214 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 153 - 66 BasicType: IdentifierPath . - 67 ComposedType: IdentifierPath . "<" Types ">" - 68 RelationType: IdentifierPath . "<" MaybeFunctionParameters "->" Type ">" - 69 FixedSizedType: IdentifierPath . "'" Term - - "<" shift, and go to state 239 - "'" shift, and go to state 240 - - $default reduce using rule 66 (BasicType) + 128 Expression: Term "=>" . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 215 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 154 - 22 FunctionParameters: Type . - - $default reduce using rule 22 (FunctionParameters) + 119 Expression: Term "!=" . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 216 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 155 - 62 Type: BasicType . - - $default reduce using rule 62 (Type) + 123 Expression: Term "<=" . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 217 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 156 - 63 Type: ComposedType . - - $default reduce using rule 63 (Type) + 124 Expression: Term ">=" . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 218 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 157 - 64 Type: RelationType . - - $default reduce using rule 64 (Type) + 30 Initializer: TwoOrMoreArguments "->" . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 219 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 158 - 65 Type: FixedSizedType . + 56 DotSeparatedIdentifiers: DotSeparatedIdentifiers "." Identifier . - $default reduce using rule 65 (Type) + $default reduce using rule 56 (DotSeparatedIdentifiers) State 159 - 36 StructureDefinition: "structure" Identifier "=" "{" . FunctionDefinitions "}" - - "init" shift, and go to state 4 - "function" shift, and go to state 8 + 68 MaybeParameters: "(" error . ")" - FunctionDefinition go to state 241 - FunctionDefinitions go to state 242 - ProgramFunctionDefinition go to state 16 + ")" shift, and go to state 220 State 160 - 37 FeatureDefinition: "feature" Identifier "=" "{" . FeatureDeclarationsAndDefinitions "}" - - "derived" shift, and go to state 243 - "rule" shift, and go to state 244 + 66 Parameters: AttributedVariable . - DerivedDefinition go to state 245 - FeatureDeclarationOrDefinition go to state 246 - FeatureDeclarationsAndDefinitions go to state 247 - DeclarationDefinition go to state 248 - RuleDefinition go to state 249 + $default reduce using rule 66 (Parameters) State 161 - 101 Expression: "(" Term . ")" - 105 | Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "implies" shift, and go to state 127 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - ")" shift, and go to state 173 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "=>" shift, and go to state 138 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 + 65 Parameters: Parameters . "," AttributedVariable + 67 MaybeParameters: "(" Parameters . ")" + + ")" shift, and go to state 221 + "," shift, and go to state 222 State 162 - 9 AttributedDefinition: "[" Attributes "]" Definition . + 35 DerivedDefinition: "derived" Identifier MaybeParameters "->" . Type "=" Term + + "this" shift, and go to state 25 + "in" shift, and go to state 26 + "." shift, and go to state 28 + "identifier" shift, and go to state 29 - $default reduce using rule 9 (AttributedDefinition) + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 168 + Type go to state 223 + BasicType go to state 41 + ComposedType go to state 42 + RelationType go to state 43 + FixedSizedType go to state 44 State 163 - 185 Attributes: Attributes "," Attribute . + 36 EnumerationDefinition: "enum" Identifier "=" "{" . Identifiers "}" - $default reduce using rule 185 (Attributes) + "in" shift, and go to state 26 + "identifier" shift, and go to state 29 + Identifier go to state 224 + Identifiers go to state 225 -State 164 - 55 AttributedVariable: "[" Attributes . "]" Variable - 185 Attributes: Attributes . "," Attribute +State 164 - "]" shift, and go to state 250 - "," shift, and go to state 99 + 149 RuleDefinition: "rule" Identifier MaybeParameters "=" . Rule + + "this" shift, and go to state 25 + "seq" shift, and go to state 226 + "par" shift, and go to state 227 + "skip" shift, and go to state 228 + "let" shift, and go to state 229 + "in" shift, and go to state 26 + "forall" shift, and go to state 230 + "choose" shift, and go to state 231 + "iterate" shift, and go to state 232 + "call" shift, and go to state 233 + "if" shift, and go to state 234 + "case" shift, and go to state 235 + "(" shift, and go to state 236 + "{" shift, and go to state 237 + "." shift, and go to state 28 + "{|" shift, and go to state 238 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + DirectCallExpression go to state 239 + IndirectCallExpression go to state 240 + Rule go to state 241 + SkipRule go to state 242 + ConditionalRule go to state 243 + CaseRule go to state 244 + LetRule go to state 245 + ForallRule go to state 246 + ChooseRule go to state 247 + IterateRule go to state 248 + BlockRule go to state 249 + SequenceRule go to state 250 + UpdateRule go to state 251 + CallRule go to state 252 State 165 - 53 Variable: Identifier ":" . Type + 150 RuleDefinition: "rule" Identifier MaybeParameters "->" . Type "=" Rule - "in" shift, and go to state 23 - "." shift, and go to state 25 - "identifier" shift, and go to state 26 + "this" shift, and go to state 25 + "in" shift, and go to state 26 + "." shift, and go to state 28 + "identifier" shift, and go to state 29 - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 153 - Type go to state 251 - BasicType go to state 155 - ComposedType go to state 156 - RelationType go to state 157 - FixedSizedType go to state 158 + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 168 + Type go to state 253 + BasicType go to state 41 + ComposedType go to state 42 + RelationType go to state 43 + FixedSizedType go to state 44 State 166 - 136 LetExpression: "let" AttributedVariable "=" . Term "in" Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 252 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 22 FunctionParameters: FunctionParameters . "*" Type + 24 MaybeFunctionParameters: FunctionParameters . + + "*" shift, and go to state 254 + + $default reduce using rule 24 (MaybeFunctionParameters) State 167 - 139 UniversalQuantifierExpression: "forall" AttributedVariable "in" . Term "holds" Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 253 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 14 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters . "->" Type MaybeDefined MaybeInitially + + "->" shift, and go to state 255 State 168 - 138 ChooseExpression: "choose" AttributedVariable "in" . Term "do" Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 254 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 74 BasicType: IdentifierPath . + 75 ComposedType: IdentifierPath . "<" Types ">" + 76 RelationType: IdentifierPath . "<" MaybeFunctionParameters "->" Type ">" + 77 FixedSizedType: IdentifierPath . "'" Term + + "<" shift, and go to state 107 + "'" shift, and go to state 108 + + $default reduce using rule 74 (BasicType) State 169 - 137 ConditionalExpression: "if" Term "then" . Term "else" Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 255 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 23 FunctionParameters: Type . + + $default reduce using rule 23 (FunctionParameters) State 170 - 140 ExistentialQuantifierExpression: "exists" AttributedVariable "in" . Term "with" Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 256 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 37 StructureDefinition: "structure" Identifier "=" "{" . FunctionDefinitions "}" + + "init" shift, and go to state 4 + "function" shift, and go to state 8 + + FunctionDefinition go to state 256 + FunctionDefinitions go to state 257 + ProgramFunctionDefinition go to state 17 State 171 - 102 Expression: "(" error ")" . + 38 FeatureDefinition: "feature" Identifier "=" "{" . FeatureDeclarationsAndDefinitions "}" + + "derived" shift, and go to state 258 + "rule" shift, and go to state 259 - $default reduce using rule 102 (Expression) + DerivedDefinition go to state 260 + FeatureDeclarationOrDefinition go to state 261 + FeatureDeclarationsAndDefinitions go to state 262 + DeclarationDefinition go to state 263 + RuleDefinition go to state 264 State 172 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - 135 IndirectCallExpression: "(" "*" Term . ")" Arguments - - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "implies" shift, and go to state 127 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - ")" shift, and go to state 257 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "=>" shift, and go to state 138 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 + 44 ImplementationDefinition: "implements" IdentifierPath "for" Type . "=" "{" ImplementationDefinitionDefinitions "}" + + "=" shift, and go to state 265 State 173 - 101 Expression: "(" Term ")" . + 76 RelationType: IdentifierPath "<" MaybeFunctionParameters . "->" Type ">" - $default reduce using rule 101 (Expression) + "->" shift, and go to state 266 State 174 - 127 Terms: Terms "," . Term - 132 TwoOrMoreArguments: "(" Terms "," . Term ")" - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 258 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 23 FunctionParameters: Type . + 79 Types: Type . + + "," reduce using rule 79 (Types) + ">" reduce using rule 79 (Types) + $default reduce using rule 23 (FunctionParameters) State 175 - 126 List: "[" error "]" . + 75 ComposedType: IdentifierPath "<" Types . ">" + 78 Types: Types . "," Type - $default reduce using rule 126 (List) + "," shift, and go to state 267 + ">" shift, and go to state 268 State 176 - 123 Range: "[" Term ".." . Term "]" - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 259 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 77 FixedSizedType: IdentifierPath "'" Term . + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "implies" shift, and go to state 142 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "<" shift, and go to state 146 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "=>" shift, and go to state 153 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 + + $default reduce using rule 77 (FixedSizedType) State 177 - 125 List: "[" Terms "]" . + 45 ImplementationDefinition: "implements" Type "=" "{" . ImplementationDefinitionDefinitions "}" + + "derived" shift, and go to state 5 + "rule" shift, and go to state 7 - $default reduce using rule 125 (List) + DerivedDefinition go to state 269 + ImplementationDefinitionDefinition go to state 270 + ImplementationDefinitionDefinitions go to state 271 + RuleDefinition go to state 272 State 178 - 127 Terms: Terms "," . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 260 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 109 Expression: "(" Term . ")" + 113 | Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "implies" shift, and go to state 142 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + ")" shift, and go to state 190 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "=>" shift, and go to state 153 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 State 179 - 30 Initializers: Initializers "," Initializer . + 10 AttributedDefinition: "[" Attributes "]" Definition . - $default reduce using rule 30 (Initializers) + $default reduce using rule 10 (AttributedDefinition) State 180 - 130 Arguments: "(" error . ")" + 193 Attributes: Attributes "," Attribute . - ")" shift, and go to state 261 + $default reduce using rule 193 (Attributes) State 181 - 131 Arguments: "(" ")" . + 63 AttributedVariable: "[" Attributes . "]" Variable + 193 Attributes: Attributes . "," Attribute - $default reduce using rule 131 (Arguments) + "]" shift, and go to state 273 + "," shift, and go to state 113 State 182 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - 128 Terms: Term . - - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "implies" shift, and go to state 127 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "=>" shift, and go to state 138 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 - - $default reduce using rule 128 (Terms) + 61 Variable: Identifier ":" . Type + "this" shift, and go to state 25 + "in" shift, and go to state 26 + "." shift, and go to state 28 + "identifier" shift, and go to state 29 -State 183 + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 168 + Type go to state 274 + BasicType go to state 41 + ComposedType go to state 42 + RelationType go to state 43 + FixedSizedType go to state 44 - 127 Terms: Terms . "," Term - 129 Arguments: "(" Terms . ")" - ")" shift, and go to state 262 - "," shift, and go to state 178 +State 183 + 144 LetExpression: "let" AttributedVariable "=" . Term "in" Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 275 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 -State 184 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 119 | Term "and" Term . - 120 | Term . "=>" Term - 121 | Term . "implies" Term - - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 +State 184 - $default reduce using rule 119 (Expression) + 147 UniversalQuantifierExpression: "forall" AttributedVariable "in" . Term "holds" Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 276 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 185 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 117 | Term "or" Term . - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - - "and" shift, and go to state 124 - "xor" shift, and go to state 126 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 - - $default reduce using rule 117 (Expression) + 146 ChooseExpression: "choose" AttributedVariable "in" . Term "do" Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 277 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 186 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 118 | Term "xor" Term . - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - - "and" shift, and go to state 124 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 - - $default reduce using rule 118 (Expression) + 145 ConditionalExpression: "if" Term "then" . Term "else" Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 278 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 187 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - 121 | Term "implies" Term . - - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 - - $default reduce using rule 121 (Expression) + 148 ExistentialQuantifierExpression: "exists" AttributedVariable "in" . Term "with" Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 279 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 188 - 105 Expression: Term . "+" Term - 105 | Term "+" Term . - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - - $default reduce using rule 105 (Expression) + 110 Expression: "(" error ")" . + + $default reduce using rule 110 (Expression) State 189 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 106 | Term "-" Term . - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - - $default reduce using rule 106 (Expression) + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + 143 IndirectCallExpression: "(" "*" Term . ")" Arguments + + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "implies" shift, and go to state 142 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + ")" shift, and go to state 280 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "=>" shift, and go to state 153 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 State 190 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 112 | Term "=" Term . - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 + 109 Expression: "(" Term ")" . - $default reduce using rule 112 (Expression) + $default reduce using rule 109 (Expression) State 191 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 113 | Term "<" Term . - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - - $default reduce using rule 113 (Expression) + 135 Terms: Terms "," . Term + 140 TwoOrMoreArguments: "(" Terms "," . Term ")" + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 281 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 192 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 114 | Term ">" Term . - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 + 134 List: "[" error "]" . - $default reduce using rule 114 (Expression) + $default reduce using rule 134 (List) State 193 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 107 | Term "*" Term . - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - - "^" shift, and go to state 136 - - $default reduce using rule 107 (Expression) + 131 Range: "[" Term ".." . Term "]" + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 282 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 194 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 108 | Term "/" Term . - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - - "^" shift, and go to state 136 - - $default reduce using rule 108 (Expression) + 133 List: "[" Terms "]" . + $default reduce using rule 133 (List) -State 195 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 109 | Term "%" Term . - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - - "^" shift, and go to state 136 +State 195 - $default reduce using rule 109 (Expression) + 135 Terms: Terms "," . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 283 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 196 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 110 | Term "^" Term . - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term + 31 Initializers: Initializers "," Initializer . - $default reduce using rule 110 (Expression) + $default reduce using rule 31 (Initializers) State 197 - 28 Initializer: Term "->" Term . - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "implies" shift, and go to state 127 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "=>" shift, and go to state 138 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 + 138 Arguments: "(" error . ")" - $default reduce using rule 28 (Initializer) + ")" shift, and go to state 284 State 198 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 120 | Term "=>" Term . - 121 | Term . "implies" Term - - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 + 139 Arguments: "(" ")" . - $default reduce using rule 120 (Expression) + $default reduce using rule 139 (Arguments) State 199 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 111 | Term "!=" Term . - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 - - $default reduce using rule 111 (Expression) + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + 136 Terms: Term . + + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "implies" shift, and go to state 142 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "=>" shift, and go to state 153 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 + + $default reduce using rule 136 (Terms) State 200 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 115 | Term "<=" Term . - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 + 135 Terms: Terms . "," Term + 137 Arguments: "(" Terms . ")" - $default reduce using rule 115 (Expression) + ")" shift, and go to state 285 + "," shift, and go to state 195 State 201 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 116 | Term ">=" Term . - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - - $default reduce using rule 116 (Expression) + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 127 | Term "and" Term . + 128 | Term . "=>" Term + 129 | Term . "implies" Term + + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 + + $default reduce using rule 127 (Expression) State 202 - 29 Initializer: TwoOrMoreArguments "->" Term . - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "implies" shift, and go to state 127 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "=>" shift, and go to state 138 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 - - $default reduce using rule 29 (Initializer) + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 125 | Term "or" Term . + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + + "and" shift, and go to state 139 + "xor" shift, and go to state 141 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 + + $default reduce using rule 125 (Expression) State 203 - 60 MaybeParameters: "(" error ")" . - - $default reduce using rule 60 (MaybeParameters) + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 126 | Term "xor" Term . + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + + "and" shift, and go to state 139 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 + + $default reduce using rule 126 (Expression) State 204 - 59 MaybeParameters: "(" Parameters ")" . - - $default reduce using rule 59 (MaybeParameters) + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + 129 | Term "implies" Term . + + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 + + $default reduce using rule 129 (Expression) State 205 - 57 Parameters: Parameters "," . AttributedVariable - - "in" shift, and go to state 23 - "[" shift, and go to state 100 - "identifier" shift, and go to state 26 + 113 Expression: Term . "+" Term + 113 | Term "+" Term . + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 - Identifier go to state 101 - Variable go to state 102 - AttributedVariable go to state 263 + $default reduce using rule 113 (Expression) State 206 - 34 DerivedDefinition: "derived" Identifier MaybeParameters "->" Type . "=" Term + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 114 | Term "-" Term . + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 - "=" shift, and go to state 264 + $default reduce using rule 114 (Expression) State 207 - 48 Identifiers: Identifier . + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 120 | Term "=" Term . + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 - $default reduce using rule 48 (Identifiers) + $default reduce using rule 120 (Expression) State 208 - 35 EnumerationDefinition: "enum" Identifier "=" "{" Identifiers . "}" - 47 Identifiers: Identifiers . "," Identifier + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 121 | Term "<" Term . + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 - "}" shift, and go to state 265 - "," shift, and go to state 266 + $default reduce using rule 121 (Expression) State 209 - 175 SequenceRule: "seq" . Rules "endseq" - 177 | "seq" . error "endseq" - - error shift, and go to state 267 - "seq" shift, and go to state 209 - "par" shift, and go to state 210 - "skip" shift, and go to state 211 - "let" shift, and go to state 212 - "in" shift, and go to state 23 - "forall" shift, and go to state 213 - "choose" shift, and go to state 214 - "iterate" shift, and go to state 215 - "call" shift, and go to state 216 - "if" shift, and go to state 217 - "case" shift, and go to state 218 - "(" shift, and go to state 219 - "{" shift, and go to state 220 - "." shift, and go to state 25 - "{|" shift, and go to state 221 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - DirectCallExpression go to state 222 - IndirectCallExpression go to state 223 - Rule go to state 268 - Rules go to state 269 - SkipRule go to state 225 - ConditionalRule go to state 226 - CaseRule go to state 227 - LetRule go to state 228 - ForallRule go to state 229 - ChooseRule go to state 230 - IterateRule go to state 231 - BlockRule go to state 232 - SequenceRule go to state 233 - UpdateRule go to state 234 - CallRule go to state 235 + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 122 | Term ">" Term . + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + + $default reduce using rule 122 (Expression) State 210 - 171 BlockRule: "par" . Rules "endpar" - 173 | "par" . error "endpar" - - error shift, and go to state 270 - "seq" shift, and go to state 209 - "par" shift, and go to state 210 - "skip" shift, and go to state 211 - "let" shift, and go to state 212 - "in" shift, and go to state 23 - "forall" shift, and go to state 213 - "choose" shift, and go to state 214 - "iterate" shift, and go to state 215 - "call" shift, and go to state 216 - "if" shift, and go to state 217 - "case" shift, and go to state 218 - "(" shift, and go to state 219 - "{" shift, and go to state 220 - "." shift, and go to state 25 - "{|" shift, and go to state 221 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - DirectCallExpression go to state 222 - IndirectCallExpression go to state 223 - Rule go to state 268 - Rules go to state 271 - SkipRule go to state 225 - ConditionalRule go to state 226 - CaseRule go to state 227 - LetRule go to state 228 - ForallRule go to state 229 - ChooseRule go to state 230 - IterateRule go to state 231 - BlockRule go to state 232 - SequenceRule go to state 233 - UpdateRule go to state 234 - CallRule go to state 235 + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 115 | Term "*" Term . + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + + "^" shift, and go to state 151 + + $default reduce using rule 115 (Expression) State 211 - 156 SkipRule: "skip" . + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 116 | Term "/" Term . + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + + "^" shift, and go to state 151 - $default reduce using rule 156 (SkipRule) + $default reduce using rule 116 (Expression) State 212 - 166 LetRule: "let" . AttributedVariable "=" Term "in" Rule - - "in" shift, and go to state 23 - "[" shift, and go to state 100 - "identifier" shift, and go to state 26 + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 117 | Term "%" Term . + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + + "^" shift, and go to state 151 - Identifier go to state 101 - Variable go to state 102 - AttributedVariable go to state 272 + $default reduce using rule 117 (Expression) State 213 - 167 ForallRule: "forall" . AttributedVariable "in" Term "do" Rule - - "in" shift, and go to state 23 - "[" shift, and go to state 100 - "identifier" shift, and go to state 26 + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 118 | Term "^" Term . + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term - Identifier go to state 101 - Variable go to state 102 - AttributedVariable go to state 273 + $default reduce using rule 118 (Expression) State 214 - 168 ChooseRule: "choose" . AttributedVariable "in" Term "do" Rule - - "in" shift, and go to state 23 - "[" shift, and go to state 100 - "identifier" shift, and go to state 26 + 29 Initializer: Term "->" Term . + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "implies" shift, and go to state 142 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "=>" shift, and go to state 153 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 - Identifier go to state 101 - Variable go to state 102 - AttributedVariable go to state 274 + $default reduce using rule 29 (Initializer) State 215 - 169 IterateRule: "iterate" . Rule - - "seq" shift, and go to state 209 - "par" shift, and go to state 210 - "skip" shift, and go to state 211 - "let" shift, and go to state 212 - "in" shift, and go to state 23 - "forall" shift, and go to state 213 - "choose" shift, and go to state 214 - "iterate" shift, and go to state 215 - "call" shift, and go to state 216 - "if" shift, and go to state 217 - "case" shift, and go to state 218 - "(" shift, and go to state 219 - "{" shift, and go to state 220 - "." shift, and go to state 25 - "{|" shift, and go to state 221 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - DirectCallExpression go to state 222 - IndirectCallExpression go to state 223 - Rule go to state 275 - SkipRule go to state 225 - ConditionalRule go to state 226 - CaseRule go to state 227 - LetRule go to state 228 - ForallRule go to state 229 - ChooseRule go to state 230 - IterateRule go to state 231 - BlockRule go to state 232 - SequenceRule go to state 233 - UpdateRule go to state 234 - CallRule go to state 235 + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 128 | Term "=>" Term . + 129 | Term . "implies" Term + + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 + + $default reduce using rule 128 (Expression) State 216 - 179 CallRule: "call" . DirectCallExpression - 181 | "call" . IndirectCallExpression - - "in" shift, and go to state 23 - "(" shift, and go to state 219 - "." shift, and go to state 25 - "identifier" shift, and go to state 26 + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 119 | Term "!=" Term . + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - DirectCallExpression go to state 276 - IndirectCallExpression go to state 277 + $default reduce using rule 119 (Expression) State 217 - 157 ConditionalRule: "if" . Term "then" Rule - 158 | "if" . Term "then" Rule "else" Rule - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 278 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 123 | Term "<=" Term . + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + + $default reduce using rule 123 (Expression) State 218 - 159 CaseRule: "case" . Term "of" "{" CaseLabels "}" - 160 | "case" . Term "of" "{" error "}" - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 279 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 124 | Term ">=" Term . + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + + $default reduce using rule 124 (Expression) State 219 - 135 IndirectCallExpression: "(" . "*" Term ")" Arguments - - "*" shift, and go to state 112 + 30 Initializer: TwoOrMoreArguments "->" Term . + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "implies" shift, and go to state 142 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "=>" shift, and go to state 153 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 + + $default reduce using rule 30 (Initializer) State 220 - 170 BlockRule: "{" . Rules "}" - 172 | "{" . error "}" - - error shift, and go to state 280 - "seq" shift, and go to state 209 - "par" shift, and go to state 210 - "skip" shift, and go to state 211 - "let" shift, and go to state 212 - "in" shift, and go to state 23 - "forall" shift, and go to state 213 - "choose" shift, and go to state 214 - "iterate" shift, and go to state 215 - "call" shift, and go to state 216 - "if" shift, and go to state 217 - "case" shift, and go to state 218 - "(" shift, and go to state 219 - "{" shift, and go to state 220 - "." shift, and go to state 25 - "{|" shift, and go to state 221 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - DirectCallExpression go to state 222 - IndirectCallExpression go to state 223 - Rule go to state 268 - Rules go to state 281 - SkipRule go to state 225 - ConditionalRule go to state 226 - CaseRule go to state 227 - LetRule go to state 228 - ForallRule go to state 229 - ChooseRule go to state 230 - IterateRule go to state 231 - BlockRule go to state 232 - SequenceRule go to state 233 - UpdateRule go to state 234 - CallRule go to state 235 + 68 MaybeParameters: "(" error ")" . + + $default reduce using rule 68 (MaybeParameters) State 221 - 174 SequenceRule: "{|" . Rules "|}" - 176 | "{|" . error "|}" - - error shift, and go to state 282 - "seq" shift, and go to state 209 - "par" shift, and go to state 210 - "skip" shift, and go to state 211 - "let" shift, and go to state 212 - "in" shift, and go to state 23 - "forall" shift, and go to state 213 - "choose" shift, and go to state 214 - "iterate" shift, and go to state 215 - "call" shift, and go to state 216 - "if" shift, and go to state 217 - "case" shift, and go to state 218 - "(" shift, and go to state 219 - "{" shift, and go to state 220 - "." shift, and go to state 25 - "{|" shift, and go to state 221 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - DirectCallExpression go to state 222 - IndirectCallExpression go to state 223 - Rule go to state 268 - Rules go to state 283 - SkipRule go to state 225 - ConditionalRule go to state 226 - CaseRule go to state 227 - LetRule go to state 228 - ForallRule go to state 229 - ChooseRule go to state 230 - IterateRule go to state 231 - BlockRule go to state 232 - SequenceRule go to state 233 - UpdateRule go to state 234 - CallRule go to state 235 + 67 MaybeParameters: "(" Parameters ")" . + + $default reduce using rule 67 (MaybeParameters) State 222 - 178 UpdateRule: DirectCallExpression . ":=" Term - 180 CallRule: DirectCallExpression . + 65 Parameters: Parameters "," . AttributedVariable - ":=" shift, and go to state 284 + "in" shift, and go to state 26 + "[" shift, and go to state 115 + "identifier" shift, and go to state 29 - $default reduce using rule 180 (CallRule) + Identifier go to state 116 + Variable go to state 117 + AttributedVariable go to state 286 State 223 - 182 CallRule: IndirectCallExpression . + 35 DerivedDefinition: "derived" Identifier MaybeParameters "->" Type . "=" Term - $default reduce using rule 182 (CallRule) + "=" shift, and go to state 287 State 224 - 141 RuleDefinition: "rule" Identifier MaybeParameters "=" Rule . + 55 Identifiers: Identifier . - $default reduce using rule 141 (RuleDefinition) + $default reduce using rule 55 (Identifiers) State 225 - 143 Rule: SkipRule . + 36 EnumerationDefinition: "enum" Identifier "=" "{" Identifiers . "}" + 54 Identifiers: Identifiers . "," Identifier - $default reduce using rule 143 (Rule) + "}" shift, and go to state 288 + "," shift, and go to state 289 State 226 - 144 Rule: ConditionalRule . - - $default reduce using rule 144 (Rule) + 183 SequenceRule: "seq" . Rules "endseq" + 185 | "seq" . error "endseq" + + error shift, and go to state 290 + "this" shift, and go to state 25 + "seq" shift, and go to state 226 + "par" shift, and go to state 227 + "skip" shift, and go to state 228 + "let" shift, and go to state 229 + "in" shift, and go to state 26 + "forall" shift, and go to state 230 + "choose" shift, and go to state 231 + "iterate" shift, and go to state 232 + "call" shift, and go to state 233 + "if" shift, and go to state 234 + "case" shift, and go to state 235 + "(" shift, and go to state 236 + "{" shift, and go to state 237 + "." shift, and go to state 28 + "{|" shift, and go to state 238 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + DirectCallExpression go to state 239 + IndirectCallExpression go to state 240 + Rule go to state 291 + Rules go to state 292 + SkipRule go to state 242 + ConditionalRule go to state 243 + CaseRule go to state 244 + LetRule go to state 245 + ForallRule go to state 246 + ChooseRule go to state 247 + IterateRule go to state 248 + BlockRule go to state 249 + SequenceRule go to state 250 + UpdateRule go to state 251 + CallRule go to state 252 State 227 - 145 Rule: CaseRule . - - $default reduce using rule 145 (Rule) + 179 BlockRule: "par" . Rules "endpar" + 181 | "par" . error "endpar" + + error shift, and go to state 293 + "this" shift, and go to state 25 + "seq" shift, and go to state 226 + "par" shift, and go to state 227 + "skip" shift, and go to state 228 + "let" shift, and go to state 229 + "in" shift, and go to state 26 + "forall" shift, and go to state 230 + "choose" shift, and go to state 231 + "iterate" shift, and go to state 232 + "call" shift, and go to state 233 + "if" shift, and go to state 234 + "case" shift, and go to state 235 + "(" shift, and go to state 236 + "{" shift, and go to state 237 + "." shift, and go to state 28 + "{|" shift, and go to state 238 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + DirectCallExpression go to state 239 + IndirectCallExpression go to state 240 + Rule go to state 291 + Rules go to state 294 + SkipRule go to state 242 + ConditionalRule go to state 243 + CaseRule go to state 244 + LetRule go to state 245 + ForallRule go to state 246 + ChooseRule go to state 247 + IterateRule go to state 248 + BlockRule go to state 249 + SequenceRule go to state 250 + UpdateRule go to state 251 + CallRule go to state 252 State 228 - 146 Rule: LetRule . + 164 SkipRule: "skip" . - $default reduce using rule 146 (Rule) + $default reduce using rule 164 (SkipRule) State 229 - 147 Rule: ForallRule . + 174 LetRule: "let" . AttributedVariable "=" Term "in" Rule - $default reduce using rule 147 (Rule) + "in" shift, and go to state 26 + "[" shift, and go to state 115 + "identifier" shift, and go to state 29 + + Identifier go to state 116 + Variable go to state 117 + AttributedVariable go to state 295 State 230 - 148 Rule: ChooseRule . + 175 ForallRule: "forall" . AttributedVariable "in" Term "do" Rule + + "in" shift, and go to state 26 + "[" shift, and go to state 115 + "identifier" shift, and go to state 29 - $default reduce using rule 148 (Rule) + Identifier go to state 116 + Variable go to state 117 + AttributedVariable go to state 296 State 231 - 149 Rule: IterateRule . + 176 ChooseRule: "choose" . AttributedVariable "in" Term "do" Rule - $default reduce using rule 149 (Rule) + "in" shift, and go to state 26 + "[" shift, and go to state 115 + "identifier" shift, and go to state 29 + Identifier go to state 116 + Variable go to state 117 + AttributedVariable go to state 297 -State 232 - 150 Rule: BlockRule . +State 232 - $default reduce using rule 150 (Rule) + 177 IterateRule: "iterate" . Rule + + "this" shift, and go to state 25 + "seq" shift, and go to state 226 + "par" shift, and go to state 227 + "skip" shift, and go to state 228 + "let" shift, and go to state 229 + "in" shift, and go to state 26 + "forall" shift, and go to state 230 + "choose" shift, and go to state 231 + "iterate" shift, and go to state 232 + "call" shift, and go to state 233 + "if" shift, and go to state 234 + "case" shift, and go to state 235 + "(" shift, and go to state 236 + "{" shift, and go to state 237 + "." shift, and go to state 28 + "{|" shift, and go to state 238 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + DirectCallExpression go to state 239 + IndirectCallExpression go to state 240 + Rule go to state 298 + SkipRule go to state 242 + ConditionalRule go to state 243 + CaseRule go to state 244 + LetRule go to state 245 + ForallRule go to state 246 + ChooseRule go to state 247 + IterateRule go to state 248 + BlockRule go to state 249 + SequenceRule go to state 250 + UpdateRule go to state 251 + CallRule go to state 252 State 233 - 151 Rule: SequenceRule . + 187 CallRule: "call" . DirectCallExpression + 189 | "call" . IndirectCallExpression - $default reduce using rule 151 (Rule) + "this" shift, and go to state 25 + "in" shift, and go to state 26 + "(" shift, and go to state 236 + "." shift, and go to state 28 + "identifier" shift, and go to state 29 + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + DirectCallExpression go to state 299 + IndirectCallExpression go to state 300 -State 234 - 152 Rule: UpdateRule . +State 234 - $default reduce using rule 152 (Rule) + 165 ConditionalRule: "if" . Term "then" Rule + 166 | "if" . Term "then" Rule "else" Rule + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 301 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 235 - 153 Rule: CallRule . - - $default reduce using rule 153 (Rule) + 167 CaseRule: "case" . Term "of" "{" CaseLabels "}" + 168 | "case" . Term "of" "{" error "}" + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 302 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 236 - 142 RuleDefinition: "rule" Identifier MaybeParameters "->" Type . "=" Rule + 143 IndirectCallExpression: "(" . "*" Term ")" Arguments - "=" shift, and go to state 285 + "*" shift, and go to state 127 State 237 - 21 FunctionParameters: FunctionParameters "*" . Type - - "in" shift, and go to state 23 - "." shift, and go to state 25 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 153 - Type go to state 286 - BasicType go to state 155 - ComposedType go to state 156 - RelationType go to state 157 - FixedSizedType go to state 158 + 178 BlockRule: "{" . Rules "}" + 180 | "{" . error "}" + + error shift, and go to state 303 + "this" shift, and go to state 25 + "seq" shift, and go to state 226 + "par" shift, and go to state 227 + "skip" shift, and go to state 228 + "let" shift, and go to state 229 + "in" shift, and go to state 26 + "forall" shift, and go to state 230 + "choose" shift, and go to state 231 + "iterate" shift, and go to state 232 + "call" shift, and go to state 233 + "if" shift, and go to state 234 + "case" shift, and go to state 235 + "(" shift, and go to state 236 + "{" shift, and go to state 237 + "." shift, and go to state 28 + "{|" shift, and go to state 238 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + DirectCallExpression go to state 239 + IndirectCallExpression go to state 240 + Rule go to state 291 + Rules go to state 304 + SkipRule go to state 242 + ConditionalRule go to state 243 + CaseRule go to state 244 + LetRule go to state 245 + ForallRule go to state 246 + ChooseRule go to state 247 + IterateRule go to state 248 + BlockRule go to state 249 + SequenceRule go to state 250 + UpdateRule go to state 251 + CallRule go to state 252 State 238 - 13 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" . Type MaybeDefined MaybeInitially - - "in" shift, and go to state 23 - "." shift, and go to state 25 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 153 - Type go to state 287 - BasicType go to state 155 - ComposedType go to state 156 - RelationType go to state 157 - FixedSizedType go to state 158 + 182 SequenceRule: "{|" . Rules "|}" + 184 | "{|" . error "|}" + + error shift, and go to state 305 + "this" shift, and go to state 25 + "seq" shift, and go to state 226 + "par" shift, and go to state 227 + "skip" shift, and go to state 228 + "let" shift, and go to state 229 + "in" shift, and go to state 26 + "forall" shift, and go to state 230 + "choose" shift, and go to state 231 + "iterate" shift, and go to state 232 + "call" shift, and go to state 233 + "if" shift, and go to state 234 + "case" shift, and go to state 235 + "(" shift, and go to state 236 + "{" shift, and go to state 237 + "." shift, and go to state 28 + "{|" shift, and go to state 238 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + DirectCallExpression go to state 239 + IndirectCallExpression go to state 240 + Rule go to state 291 + Rules go to state 306 + SkipRule go to state 242 + ConditionalRule go to state 243 + CaseRule go to state 244 + LetRule go to state 245 + ForallRule go to state 246 + ChooseRule go to state 247 + IterateRule go to state 248 + BlockRule go to state 249 + SequenceRule go to state 250 + UpdateRule go to state 251 + CallRule go to state 252 State 239 - 67 ComposedType: IdentifierPath "<" . Types ">" - 68 RelationType: IdentifierPath "<" . MaybeFunctionParameters "->" Type ">" + 186 UpdateRule: DirectCallExpression . ":=" Term + 188 CallRule: DirectCallExpression . - "in" shift, and go to state 23 - "." shift, and go to state 25 - "identifier" shift, and go to state 26 + ":=" shift, and go to state 307 - $default reduce using rule 24 (MaybeFunctionParameters) - - FunctionParameters go to state 151 - MaybeFunctionParameters go to state 288 - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 153 - Type go to state 289 - BasicType go to state 155 - ComposedType go to state 156 - RelationType go to state 157 - FixedSizedType go to state 158 - Types go to state 290 + $default reduce using rule 188 (CallRule) State 240 - 69 FixedSizedType: IdentifierPath "'" . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 291 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 190 CallRule: IndirectCallExpression . + + $default reduce using rule 190 (CallRule) State 241 - 16 FunctionDefinitions: FunctionDefinition . + 149 RuleDefinition: "rule" Identifier MaybeParameters "=" Rule . - $default reduce using rule 16 (FunctionDefinitions) + $default reduce using rule 149 (RuleDefinition) State 242 - 15 FunctionDefinitions: FunctionDefinitions . "," FunctionDefinition - 36 StructureDefinition: "structure" Identifier "=" "{" FunctionDefinitions . "}" + 151 Rule: SkipRule . - "}" shift, and go to state 292 - "," shift, and go to state 293 + $default reduce using rule 151 (Rule) State 243 - 34 DerivedDefinition: "derived" . Identifier MaybeParameters "->" Type "=" Term - 43 DeclarationDefinition: "derived" . Identifier ":" MaybeFunctionParameters "->" Type - - "in" shift, and go to state 23 - "identifier" shift, and go to state 26 + 152 Rule: ConditionalRule . - Identifier go to state 294 + $default reduce using rule 152 (Rule) State 244 - 44 DeclarationDefinition: "rule" . Identifier ":" MaybeFunctionParameters "->" Type - 141 RuleDefinition: "rule" . Identifier MaybeParameters "=" Rule - 142 | "rule" . Identifier MaybeParameters "->" Type "=" Rule + 153 Rule: CaseRule . - "in" shift, and go to state 23 - "identifier" shift, and go to state 26 - - Identifier go to state 295 + $default reduce using rule 153 (Rule) State 245 - 39 FeatureDeclarationOrDefinition: DerivedDefinition . + 154 Rule: LetRule . - $default reduce using rule 39 (FeatureDeclarationOrDefinition) + $default reduce using rule 154 (Rule) State 246 - 42 FeatureDeclarationsAndDefinitions: FeatureDeclarationOrDefinition . + 155 Rule: ForallRule . - $default reduce using rule 42 (FeatureDeclarationsAndDefinitions) + $default reduce using rule 155 (Rule) State 247 - 37 FeatureDefinition: "feature" Identifier "=" "{" FeatureDeclarationsAndDefinitions . "}" - 41 FeatureDeclarationsAndDefinitions: FeatureDeclarationsAndDefinitions . "," FeatureDeclarationOrDefinition + 156 Rule: ChooseRule . - "}" shift, and go to state 296 - "," shift, and go to state 297 + $default reduce using rule 156 (Rule) State 248 - 38 FeatureDeclarationOrDefinition: DeclarationDefinition . + 157 Rule: IterateRule . - $default reduce using rule 38 (FeatureDeclarationOrDefinition) + $default reduce using rule 157 (Rule) State 249 - 40 FeatureDeclarationOrDefinition: RuleDefinition . + 158 Rule: BlockRule . - $default reduce using rule 40 (FeatureDeclarationOrDefinition) + $default reduce using rule 158 (Rule) State 250 - 55 AttributedVariable: "[" Attributes "]" . Variable - - "in" shift, and go to state 23 - "identifier" shift, and go to state 26 + 159 Rule: SequenceRule . - Identifier go to state 101 - Variable go to state 298 + $default reduce using rule 159 (Rule) State 251 - 53 Variable: Identifier ":" Type . + 160 Rule: UpdateRule . - $default reduce using rule 53 (Variable) + $default reduce using rule 160 (Rule) State 252 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - 136 LetExpression: "let" AttributedVariable "=" Term . "in" Term - - "in" shift, and go to state 299 - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "implies" shift, and go to state 127 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "=>" shift, and go to state 138 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 + 161 Rule: CallRule . + + $default reduce using rule 161 (Rule) State 253 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - 139 UniversalQuantifierExpression: "forall" AttributedVariable "in" Term . "holds" Term - - "holds" shift, and go to state 300 - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "implies" shift, and go to state 127 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "=>" shift, and go to state 138 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 + 150 RuleDefinition: "rule" Identifier MaybeParameters "->" Type . "=" Rule + + "=" shift, and go to state 308 State 254 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - 138 ChooseExpression: "choose" AttributedVariable "in" Term . "do" Term - - "do" shift, and go to state 301 - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "implies" shift, and go to state 127 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "=>" shift, and go to state 138 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 + 22 FunctionParameters: FunctionParameters "*" . Type + + "this" shift, and go to state 25 + "in" shift, and go to state 26 + "." shift, and go to state 28 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 168 + Type go to state 309 + BasicType go to state 41 + ComposedType go to state 42 + RelationType go to state 43 + FixedSizedType go to state 44 State 255 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - 137 ConditionalExpression: "if" Term "then" Term . "else" Term - - "else" shift, and go to state 302 - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "implies" shift, and go to state 127 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "=>" shift, and go to state 138 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 + 14 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" . Type MaybeDefined MaybeInitially + + "this" shift, and go to state 25 + "in" shift, and go to state 26 + "." shift, and go to state 28 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 168 + Type go to state 310 + BasicType go to state 41 + ComposedType go to state 42 + RelationType go to state 43 + FixedSizedType go to state 44 State 256 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - 140 ExistentialQuantifierExpression: "exists" AttributedVariable "in" Term . "with" Term - - "with" shift, and go to state 303 - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "implies" shift, and go to state 127 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "=>" shift, and go to state 138 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 + 17 FunctionDefinitions: FunctionDefinition . + $default reduce using rule 17 (FunctionDefinitions) -State 257 - 135 IndirectCallExpression: "(" "*" Term ")" . Arguments +State 257 - "(" shift, and go to state 122 + 16 FunctionDefinitions: FunctionDefinitions . "," FunctionDefinition + 37 StructureDefinition: "structure" Identifier "=" "{" FunctionDefinitions . "}" - Arguments go to state 304 + "}" shift, and go to state 311 + "," shift, and go to state 312 State 258 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - 127 Terms: Terms "," Term . - 132 TwoOrMoreArguments: "(" Terms "," Term . ")" - - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "implies" shift, and go to state 127 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - ")" shift, and go to state 305 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "=>" shift, and go to state 138 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 - - $default reduce using rule 127 (Terms) + 35 DerivedDefinition: "derived" . Identifier MaybeParameters "->" Type "=" Term + 50 DeclarationDefinition: "derived" . Identifier ":" MaybeFunctionParameters "->" Type + + "in" shift, and go to state 26 + "identifier" shift, and go to state 29 + + Identifier go to state 313 State 259 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - 123 Range: "[" Term ".." Term . "]" - - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "implies" shift, and go to state 127 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - "]" shift, and go to state 306 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "=>" shift, and go to state 138 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 + 51 DeclarationDefinition: "rule" . Identifier ":" MaybeFunctionParameters "->" Type + 149 RuleDefinition: "rule" . Identifier MaybeParameters "=" Rule + 150 | "rule" . Identifier MaybeParameters "->" Type "=" Rule + + "in" shift, and go to state 26 + "identifier" shift, and go to state 29 + + Identifier go to state 314 State 260 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - 127 Terms: Terms "," Term . - - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "implies" shift, and go to state 127 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "=>" shift, and go to state 138 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 - - $default reduce using rule 127 (Terms) + 40 FeatureDeclarationOrDefinition: DerivedDefinition . + + $default reduce using rule 40 (FeatureDeclarationOrDefinition) State 261 - 130 Arguments: "(" error ")" . + 43 FeatureDeclarationsAndDefinitions: FeatureDeclarationOrDefinition . - $default reduce using rule 130 (Arguments) + $default reduce using rule 43 (FeatureDeclarationsAndDefinitions) State 262 - 129 Arguments: "(" Terms ")" . + 38 FeatureDefinition: "feature" Identifier "=" "{" FeatureDeclarationsAndDefinitions . "}" + 42 FeatureDeclarationsAndDefinitions: FeatureDeclarationsAndDefinitions . FeatureDeclarationOrDefinition - $default reduce using rule 129 (Arguments) + "derived" shift, and go to state 258 + "rule" shift, and go to state 259 + "}" shift, and go to state 315 + + DerivedDefinition go to state 260 + FeatureDeclarationOrDefinition go to state 316 + DeclarationDefinition go to state 263 + RuleDefinition go to state 264 State 263 - 57 Parameters: Parameters "," AttributedVariable . + 39 FeatureDeclarationOrDefinition: DeclarationDefinition . - $default reduce using rule 57 (Parameters) + $default reduce using rule 39 (FeatureDeclarationOrDefinition) State 264 - 34 DerivedDefinition: "derived" Identifier MaybeParameters "->" Type "=" . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 307 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 41 FeatureDeclarationOrDefinition: RuleDefinition . + + $default reduce using rule 41 (FeatureDeclarationOrDefinition) State 265 - 35 EnumerationDefinition: "enum" Identifier "=" "{" Identifiers "}" . + 44 ImplementationDefinition: "implements" IdentifierPath "for" Type "=" . "{" ImplementationDefinitionDefinitions "}" - $default reduce using rule 35 (EnumerationDefinition) + "{" shift, and go to state 317 State 266 - 47 Identifiers: Identifiers "," . Identifier + 76 RelationType: IdentifierPath "<" MaybeFunctionParameters "->" . Type ">" - "in" shift, and go to state 23 - "identifier" shift, and go to state 26 + "this" shift, and go to state 25 + "in" shift, and go to state 26 + "." shift, and go to state 28 + "identifier" shift, and go to state 29 - Identifier go to state 308 + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 168 + Type go to state 318 + BasicType go to state 41 + ComposedType go to state 42 + RelationType go to state 43 + FixedSizedType go to state 44 State 267 - 177 SequenceRule: "seq" error . "endseq" + 78 Types: Types "," . Type + + "this" shift, and go to state 25 + "in" shift, and go to state 26 + "." shift, and go to state 28 + "identifier" shift, and go to state 29 - "endseq" shift, and go to state 309 + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 168 + Type go to state 319 + BasicType go to state 41 + ComposedType go to state 42 + RelationType go to state 43 + FixedSizedType go to state 44 State 268 - 155 Rules: Rule . + 75 ComposedType: IdentifierPath "<" Types ">" . - $default reduce using rule 155 (Rules) + $default reduce using rule 75 (ComposedType) State 269 - 154 Rules: Rules . Rule - 175 SequenceRule: "seq" Rules . "endseq" - - "seq" shift, and go to state 209 - "endseq" shift, and go to state 310 - "par" shift, and go to state 210 - "skip" shift, and go to state 211 - "let" shift, and go to state 212 - "in" shift, and go to state 23 - "forall" shift, and go to state 213 - "choose" shift, and go to state 214 - "iterate" shift, and go to state 215 - "call" shift, and go to state 216 - "if" shift, and go to state 217 - "case" shift, and go to state 218 - "(" shift, and go to state 219 - "{" shift, and go to state 220 - "." shift, and go to state 25 - "{|" shift, and go to state 221 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - DirectCallExpression go to state 222 - IndirectCallExpression go to state 223 - Rule go to state 311 - SkipRule go to state 225 - ConditionalRule go to state 226 - CaseRule go to state 227 - LetRule go to state 228 - ForallRule go to state 229 - ChooseRule go to state 230 - IterateRule go to state 231 - BlockRule go to state 232 - SequenceRule go to state 233 - UpdateRule go to state 234 - CallRule go to state 235 + 46 ImplementationDefinitionDefinition: DerivedDefinition . + + $default reduce using rule 46 (ImplementationDefinitionDefinition) State 270 - 173 BlockRule: "par" error . "endpar" + 49 ImplementationDefinitionDefinitions: ImplementationDefinitionDefinition . - "endpar" shift, and go to state 312 + $default reduce using rule 49 (ImplementationDefinitionDefinitions) State 271 - 154 Rules: Rules . Rule - 171 BlockRule: "par" Rules . "endpar" - - "seq" shift, and go to state 209 - "par" shift, and go to state 210 - "endpar" shift, and go to state 313 - "skip" shift, and go to state 211 - "let" shift, and go to state 212 - "in" shift, and go to state 23 - "forall" shift, and go to state 213 - "choose" shift, and go to state 214 - "iterate" shift, and go to state 215 - "call" shift, and go to state 216 - "if" shift, and go to state 217 - "case" shift, and go to state 218 - "(" shift, and go to state 219 - "{" shift, and go to state 220 - "." shift, and go to state 25 - "{|" shift, and go to state 221 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - DirectCallExpression go to state 222 - IndirectCallExpression go to state 223 - Rule go to state 311 - SkipRule go to state 225 - ConditionalRule go to state 226 - CaseRule go to state 227 - LetRule go to state 228 - ForallRule go to state 229 - ChooseRule go to state 230 - IterateRule go to state 231 - BlockRule go to state 232 - SequenceRule go to state 233 - UpdateRule go to state 234 - CallRule go to state 235 + 45 ImplementationDefinition: "implements" Type "=" "{" ImplementationDefinitionDefinitions . "}" + 48 ImplementationDefinitionDefinitions: ImplementationDefinitionDefinitions . ImplementationDefinitionDefinition + + "derived" shift, and go to state 5 + "rule" shift, and go to state 7 + "}" shift, and go to state 320 + + DerivedDefinition go to state 269 + ImplementationDefinitionDefinition go to state 321 + RuleDefinition go to state 272 State 272 - 166 LetRule: "let" AttributedVariable . "=" Term "in" Rule + 47 ImplementationDefinitionDefinition: RuleDefinition . - "=" shift, and go to state 314 + $default reduce using rule 47 (ImplementationDefinitionDefinition) State 273 - 167 ForallRule: "forall" AttributedVariable . "in" Term "do" Rule + 63 AttributedVariable: "[" Attributes "]" . Variable - "in" shift, and go to state 315 + "in" shift, and go to state 26 + "identifier" shift, and go to state 29 + + Identifier go to state 116 + Variable go to state 322 State 274 - 168 ChooseRule: "choose" AttributedVariable . "in" Term "do" Rule + 61 Variable: Identifier ":" Type . - "in" shift, and go to state 316 + $default reduce using rule 61 (Variable) State 275 - 169 IterateRule: "iterate" Rule . - - $default reduce using rule 169 (IterateRule) + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + 144 LetExpression: "let" AttributedVariable "=" Term . "in" Term + + "in" shift, and go to state 323 + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "implies" shift, and go to state 142 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "=>" shift, and go to state 153 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 State 276 - 179 CallRule: "call" DirectCallExpression . - - $default reduce using rule 179 (CallRule) + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + 147 UniversalQuantifierExpression: "forall" AttributedVariable "in" Term . "holds" Term + + "holds" shift, and go to state 324 + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "implies" shift, and go to state 142 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "=>" shift, and go to state 153 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 State 277 - 181 CallRule: "call" IndirectCallExpression . - - $default reduce using rule 181 (CallRule) + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + 146 ChooseExpression: "choose" AttributedVariable "in" Term . "do" Term + + "do" shift, and go to state 325 + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "implies" shift, and go to state 142 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "=>" shift, and go to state 153 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 State 278 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - 157 ConditionalRule: "if" Term . "then" Rule - 158 | "if" Term . "then" Rule "else" Rule - - "then" shift, and go to state 317 - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "implies" shift, and go to state 127 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "=>" shift, and go to state 138 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + 145 ConditionalExpression: "if" Term "then" Term . "else" Term + + "else" shift, and go to state 326 + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "implies" shift, and go to state 142 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "=>" shift, and go to state 153 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 State 279 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - 159 CaseRule: "case" Term . "of" "{" CaseLabels "}" - 160 | "case" Term . "of" "{" error "}" - - "of" shift, and go to state 318 - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "implies" shift, and go to state 127 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "=>" shift, and go to state 138 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + 148 ExistentialQuantifierExpression: "exists" AttributedVariable "in" Term . "with" Term + + "with" shift, and go to state 327 + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "implies" shift, and go to state 142 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "=>" shift, and go to state 153 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 State 280 - 172 BlockRule: "{" error . "}" + 143 IndirectCallExpression: "(" "*" Term ")" . Arguments - "}" shift, and go to state 319 + "(" shift, and go to state 137 + + Arguments go to state 328 State 281 - 154 Rules: Rules . Rule - 170 BlockRule: "{" Rules . "}" - - "seq" shift, and go to state 209 - "par" shift, and go to state 210 - "skip" shift, and go to state 211 - "let" shift, and go to state 212 - "in" shift, and go to state 23 - "forall" shift, and go to state 213 - "choose" shift, and go to state 214 - "iterate" shift, and go to state 215 - "call" shift, and go to state 216 - "if" shift, and go to state 217 - "case" shift, and go to state 218 - "(" shift, and go to state 219 - "{" shift, and go to state 220 - "}" shift, and go to state 320 - "." shift, and go to state 25 - "{|" shift, and go to state 221 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - DirectCallExpression go to state 222 - IndirectCallExpression go to state 223 - Rule go to state 311 - SkipRule go to state 225 - ConditionalRule go to state 226 - CaseRule go to state 227 - LetRule go to state 228 - ForallRule go to state 229 - ChooseRule go to state 230 - IterateRule go to state 231 - BlockRule go to state 232 - SequenceRule go to state 233 - UpdateRule go to state 234 - CallRule go to state 235 + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + 135 Terms: Terms "," Term . + 140 TwoOrMoreArguments: "(" Terms "," Term . ")" + + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "implies" shift, and go to state 142 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + ")" shift, and go to state 329 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "=>" shift, and go to state 153 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 + + $default reduce using rule 135 (Terms) State 282 - 176 SequenceRule: "{|" error . "|}" - - "|}" shift, and go to state 321 + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + 131 Range: "[" Term ".." Term . "]" + + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "implies" shift, and go to state 142 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + "]" shift, and go to state 330 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "=>" shift, and go to state 153 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 State 283 - 154 Rules: Rules . Rule - 174 SequenceRule: "{|" Rules . "|}" - - "seq" shift, and go to state 209 - "par" shift, and go to state 210 - "skip" shift, and go to state 211 - "let" shift, and go to state 212 - "in" shift, and go to state 23 - "forall" shift, and go to state 213 - "choose" shift, and go to state 214 - "iterate" shift, and go to state 215 - "call" shift, and go to state 216 - "if" shift, and go to state 217 - "case" shift, and go to state 218 - "(" shift, and go to state 219 - "{" shift, and go to state 220 - "." shift, and go to state 25 - "{|" shift, and go to state 221 - "|}" shift, and go to state 322 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - DirectCallExpression go to state 222 - IndirectCallExpression go to state 223 - Rule go to state 311 - SkipRule go to state 225 - ConditionalRule go to state 226 - CaseRule go to state 227 - LetRule go to state 228 - ForallRule go to state 229 - ChooseRule go to state 230 - IterateRule go to state 231 - BlockRule go to state 232 - SequenceRule go to state 233 - UpdateRule go to state 234 - CallRule go to state 235 + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + 135 Terms: Terms "," Term . + + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "implies" shift, and go to state 142 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "=>" shift, and go to state 153 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 + + $default reduce using rule 135 (Terms) State 284 - 178 UpdateRule: DirectCallExpression ":=" . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 323 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 138 Arguments: "(" error ")" . + + $default reduce using rule 138 (Arguments) State 285 - 142 RuleDefinition: "rule" Identifier MaybeParameters "->" Type "=" . Rule - - "seq" shift, and go to state 209 - "par" shift, and go to state 210 - "skip" shift, and go to state 211 - "let" shift, and go to state 212 - "in" shift, and go to state 23 - "forall" shift, and go to state 213 - "choose" shift, and go to state 214 - "iterate" shift, and go to state 215 - "call" shift, and go to state 216 - "if" shift, and go to state 217 - "case" shift, and go to state 218 - "(" shift, and go to state 219 - "{" shift, and go to state 220 - "." shift, and go to state 25 - "{|" shift, and go to state 221 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - DirectCallExpression go to state 222 - IndirectCallExpression go to state 223 - Rule go to state 324 - SkipRule go to state 225 - ConditionalRule go to state 226 - CaseRule go to state 227 - LetRule go to state 228 - ForallRule go to state 229 - ChooseRule go to state 230 - IterateRule go to state 231 - BlockRule go to state 232 - SequenceRule go to state 233 - UpdateRule go to state 234 - CallRule go to state 235 + 137 Arguments: "(" Terms ")" . + + $default reduce using rule 137 (Arguments) State 286 - 21 FunctionParameters: FunctionParameters "*" Type . + 65 Parameters: Parameters "," AttributedVariable . - $default reduce using rule 21 (FunctionParameters) + $default reduce using rule 65 (Parameters) State 287 - 13 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" Type . MaybeDefined MaybeInitially - - "defined" shift, and go to state 325 - - $default reduce using rule 20 (MaybeDefined) - - MaybeDefined go to state 326 + 35 DerivedDefinition: "derived" Identifier MaybeParameters "->" Type "=" . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 331 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 288 - 68 RelationType: IdentifierPath "<" MaybeFunctionParameters . "->" Type ">" + 36 EnumerationDefinition: "enum" Identifier "=" "{" Identifiers "}" . - "->" shift, and go to state 327 + $default reduce using rule 36 (EnumerationDefinition) State 289 - 22 FunctionParameters: Type . - 71 Types: Type . + 54 Identifiers: Identifiers "," . Identifier - "," reduce using rule 71 (Types) - ">" reduce using rule 71 (Types) - $default reduce using rule 22 (FunctionParameters) + "in" shift, and go to state 26 + "identifier" shift, and go to state 29 + + Identifier go to state 332 State 290 - 67 ComposedType: IdentifierPath "<" Types . ">" - 70 Types: Types . "," Type + 185 SequenceRule: "seq" error . "endseq" - "," shift, and go to state 328 - ">" shift, and go to state 329 + "endseq" shift, and go to state 333 State 291 - 69 FixedSizedType: IdentifierPath "'" Term . - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "implies" shift, and go to state 127 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "<" shift, and go to state 131 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "=>" shift, and go to state 138 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 - - $default reduce using rule 69 (FixedSizedType) + 163 Rules: Rule . + $default reduce using rule 163 (Rules) -State 292 - 36 StructureDefinition: "structure" Identifier "=" "{" FunctionDefinitions "}" . +State 292 - $default reduce using rule 36 (StructureDefinition) + 162 Rules: Rules . Rule + 183 SequenceRule: "seq" Rules . "endseq" + + "this" shift, and go to state 25 + "seq" shift, and go to state 226 + "endseq" shift, and go to state 334 + "par" shift, and go to state 227 + "skip" shift, and go to state 228 + "let" shift, and go to state 229 + "in" shift, and go to state 26 + "forall" shift, and go to state 230 + "choose" shift, and go to state 231 + "iterate" shift, and go to state 232 + "call" shift, and go to state 233 + "if" shift, and go to state 234 + "case" shift, and go to state 235 + "(" shift, and go to state 236 + "{" shift, and go to state 237 + "." shift, and go to state 28 + "{|" shift, and go to state 238 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + DirectCallExpression go to state 239 + IndirectCallExpression go to state 240 + Rule go to state 335 + SkipRule go to state 242 + ConditionalRule go to state 243 + CaseRule go to state 244 + LetRule go to state 245 + ForallRule go to state 246 + ChooseRule go to state 247 + IterateRule go to state 248 + BlockRule go to state 249 + SequenceRule go to state 250 + UpdateRule go to state 251 + CallRule go to state 252 State 293 - 15 FunctionDefinitions: FunctionDefinitions "," . FunctionDefinition + 181 BlockRule: "par" error . "endpar" - "init" shift, and go to state 4 - "function" shift, and go to state 8 - - FunctionDefinition go to state 330 - ProgramFunctionDefinition go to state 16 + "endpar" shift, and go to state 336 State 294 - 34 DerivedDefinition: "derived" Identifier . MaybeParameters "->" Type "=" Term - 43 DeclarationDefinition: "derived" Identifier . ":" MaybeFunctionParameters "->" Type - - "(" shift, and go to state 89 - ":" shift, and go to state 331 - - $default reduce using rule 61 (MaybeParameters) - - MaybeParameters go to state 90 + 162 Rules: Rules . Rule + 179 BlockRule: "par" Rules . "endpar" + + "this" shift, and go to state 25 + "seq" shift, and go to state 226 + "par" shift, and go to state 227 + "endpar" shift, and go to state 337 + "skip" shift, and go to state 228 + "let" shift, and go to state 229 + "in" shift, and go to state 26 + "forall" shift, and go to state 230 + "choose" shift, and go to state 231 + "iterate" shift, and go to state 232 + "call" shift, and go to state 233 + "if" shift, and go to state 234 + "case" shift, and go to state 235 + "(" shift, and go to state 236 + "{" shift, and go to state 237 + "." shift, and go to state 28 + "{|" shift, and go to state 238 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + DirectCallExpression go to state 239 + IndirectCallExpression go to state 240 + Rule go to state 335 + SkipRule go to state 242 + ConditionalRule go to state 243 + CaseRule go to state 244 + LetRule go to state 245 + ForallRule go to state 246 + ChooseRule go to state 247 + IterateRule go to state 248 + BlockRule go to state 249 + SequenceRule go to state 250 + UpdateRule go to state 251 + CallRule go to state 252 State 295 - 44 DeclarationDefinition: "rule" Identifier . ":" MaybeFunctionParameters "->" Type - 141 RuleDefinition: "rule" Identifier . MaybeParameters "=" Rule - 142 | "rule" Identifier . MaybeParameters "->" Type "=" Rule - - "(" shift, and go to state 89 - ":" shift, and go to state 332 + 174 LetRule: "let" AttributedVariable . "=" Term "in" Rule - $default reduce using rule 61 (MaybeParameters) - - MaybeParameters go to state 92 + "=" shift, and go to state 338 State 296 - 37 FeatureDefinition: "feature" Identifier "=" "{" FeatureDeclarationsAndDefinitions "}" . + 175 ForallRule: "forall" AttributedVariable . "in" Term "do" Rule - $default reduce using rule 37 (FeatureDefinition) + "in" shift, and go to state 339 State 297 - 41 FeatureDeclarationsAndDefinitions: FeatureDeclarationsAndDefinitions "," . FeatureDeclarationOrDefinition - - "derived" shift, and go to state 243 - "rule" shift, and go to state 244 + 176 ChooseRule: "choose" AttributedVariable . "in" Term "do" Rule - DerivedDefinition go to state 245 - FeatureDeclarationOrDefinition go to state 333 - DeclarationDefinition go to state 248 - RuleDefinition go to state 249 + "in" shift, and go to state 340 State 298 - 55 AttributedVariable: "[" Attributes "]" Variable . + 177 IterateRule: "iterate" Rule . - $default reduce using rule 55 (AttributedVariable) + $default reduce using rule 177 (IterateRule) State 299 - 136 LetExpression: "let" AttributedVariable "=" Term "in" . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 334 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 187 CallRule: "call" DirectCallExpression . + + $default reduce using rule 187 (CallRule) State 300 - 139 UniversalQuantifierExpression: "forall" AttributedVariable "in" Term "holds" . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 335 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 189 CallRule: "call" IndirectCallExpression . + + $default reduce using rule 189 (CallRule) State 301 - 138 ChooseExpression: "choose" AttributedVariable "in" Term "do" . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 336 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + 165 ConditionalRule: "if" Term . "then" Rule + 166 | "if" Term . "then" Rule "else" Rule + + "then" shift, and go to state 341 + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "implies" shift, and go to state 142 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "=>" shift, and go to state 153 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 State 302 - 137 ConditionalExpression: "if" Term "then" Term "else" . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 337 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + 167 CaseRule: "case" Term . "of" "{" CaseLabels "}" + 168 | "case" Term . "of" "{" error "}" + + "of" shift, and go to state 342 + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "implies" shift, and go to state 142 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "=>" shift, and go to state 153 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 State 303 - 140 ExistentialQuantifierExpression: "exists" AttributedVariable "in" Term "with" . Term - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 338 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 180 BlockRule: "{" error . "}" + "}" shift, and go to state 343 -State 304 - 135 IndirectCallExpression: "(" "*" Term ")" Arguments . +State 304 - $default reduce using rule 135 (IndirectCallExpression) + 162 Rules: Rules . Rule + 178 BlockRule: "{" Rules . "}" + + "this" shift, and go to state 25 + "seq" shift, and go to state 226 + "par" shift, and go to state 227 + "skip" shift, and go to state 228 + "let" shift, and go to state 229 + "in" shift, and go to state 26 + "forall" shift, and go to state 230 + "choose" shift, and go to state 231 + "iterate" shift, and go to state 232 + "call" shift, and go to state 233 + "if" shift, and go to state 234 + "case" shift, and go to state 235 + "(" shift, and go to state 236 + "{" shift, and go to state 237 + "}" shift, and go to state 344 + "." shift, and go to state 28 + "{|" shift, and go to state 238 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + DirectCallExpression go to state 239 + IndirectCallExpression go to state 240 + Rule go to state 335 + SkipRule go to state 242 + ConditionalRule go to state 243 + CaseRule go to state 244 + LetRule go to state 245 + ForallRule go to state 246 + ChooseRule go to state 247 + IterateRule go to state 248 + BlockRule go to state 249 + SequenceRule go to state 250 + UpdateRule go to state 251 + CallRule go to state 252 State 305 - 132 TwoOrMoreArguments: "(" Terms "," Term ")" . + 184 SequenceRule: "{|" error . "|}" - $default reduce using rule 132 (TwoOrMoreArguments) + "|}" shift, and go to state 345 State 306 - 123 Range: "[" Term ".." Term "]" . - - $default reduce using rule 123 (Range) + 162 Rules: Rules . Rule + 182 SequenceRule: "{|" Rules . "|}" + + "this" shift, and go to state 25 + "seq" shift, and go to state 226 + "par" shift, and go to state 227 + "skip" shift, and go to state 228 + "let" shift, and go to state 229 + "in" shift, and go to state 26 + "forall" shift, and go to state 230 + "choose" shift, and go to state 231 + "iterate" shift, and go to state 232 + "call" shift, and go to state 233 + "if" shift, and go to state 234 + "case" shift, and go to state 235 + "(" shift, and go to state 236 + "{" shift, and go to state 237 + "." shift, and go to state 28 + "{|" shift, and go to state 238 + "|}" shift, and go to state 346 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + DirectCallExpression go to state 239 + IndirectCallExpression go to state 240 + Rule go to state 335 + SkipRule go to state 242 + ConditionalRule go to state 243 + CaseRule go to state 244 + LetRule go to state 245 + ForallRule go to state 246 + ChooseRule go to state 247 + IterateRule go to state 248 + BlockRule go to state 249 + SequenceRule go to state 250 + UpdateRule go to state 251 + CallRule go to state 252 State 307 - 34 DerivedDefinition: "derived" Identifier MaybeParameters "->" Type "=" Term . - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "implies" shift, and go to state 127 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "=>" shift, and go to state 138 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 - - $default reduce using rule 34 (DerivedDefinition) + 186 UpdateRule: DirectCallExpression ":=" . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 347 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 308 - 47 Identifiers: Identifiers "," Identifier . - - $default reduce using rule 47 (Identifiers) + 150 RuleDefinition: "rule" Identifier MaybeParameters "->" Type "=" . Rule + + "this" shift, and go to state 25 + "seq" shift, and go to state 226 + "par" shift, and go to state 227 + "skip" shift, and go to state 228 + "let" shift, and go to state 229 + "in" shift, and go to state 26 + "forall" shift, and go to state 230 + "choose" shift, and go to state 231 + "iterate" shift, and go to state 232 + "call" shift, and go to state 233 + "if" shift, and go to state 234 + "case" shift, and go to state 235 + "(" shift, and go to state 236 + "{" shift, and go to state 237 + "." shift, and go to state 28 + "{|" shift, and go to state 238 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + DirectCallExpression go to state 239 + IndirectCallExpression go to state 240 + Rule go to state 348 + SkipRule go to state 242 + ConditionalRule go to state 243 + CaseRule go to state 244 + LetRule go to state 245 + ForallRule go to state 246 + ChooseRule go to state 247 + IterateRule go to state 248 + BlockRule go to state 249 + SequenceRule go to state 250 + UpdateRule go to state 251 + CallRule go to state 252 State 309 - 177 SequenceRule: "seq" error "endseq" . + 22 FunctionParameters: FunctionParameters "*" Type . - $default reduce using rule 177 (SequenceRule) + $default reduce using rule 22 (FunctionParameters) State 310 - 175 SequenceRule: "seq" Rules "endseq" . + 14 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" Type . MaybeDefined MaybeInitially + + "defined" shift, and go to state 349 + + $default reduce using rule 21 (MaybeDefined) - $default reduce using rule 175 (SequenceRule) + MaybeDefined go to state 350 State 311 - 154 Rules: Rules Rule . + 37 StructureDefinition: "structure" Identifier "=" "{" FunctionDefinitions "}" . - $default reduce using rule 154 (Rules) + $default reduce using rule 37 (StructureDefinition) State 312 - 173 BlockRule: "par" error "endpar" . + 16 FunctionDefinitions: FunctionDefinitions "," . FunctionDefinition - $default reduce using rule 173 (BlockRule) + "init" shift, and go to state 4 + "function" shift, and go to state 8 + + FunctionDefinition go to state 351 + ProgramFunctionDefinition go to state 17 State 313 - 171 BlockRule: "par" Rules "endpar" . + 35 DerivedDefinition: "derived" Identifier . MaybeParameters "->" Type "=" Term + 50 DeclarationDefinition: "derived" Identifier . ":" MaybeFunctionParameters "->" Type + + "(" shift, and go to state 99 + ":" shift, and go to state 352 - $default reduce using rule 171 (BlockRule) + $default reduce using rule 69 (MaybeParameters) + + MaybeParameters go to state 100 State 314 - 166 LetRule: "let" AttributedVariable "=" . Term "in" Rule - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 339 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 51 DeclarationDefinition: "rule" Identifier . ":" MaybeFunctionParameters "->" Type + 149 RuleDefinition: "rule" Identifier . MaybeParameters "=" Rule + 150 | "rule" Identifier . MaybeParameters "->" Type "=" Rule + + "(" shift, and go to state 99 + ":" shift, and go to state 353 + + $default reduce using rule 69 (MaybeParameters) + + MaybeParameters go to state 102 State 315 - 167 ForallRule: "forall" AttributedVariable "in" . Term "do" Rule - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 340 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 38 FeatureDefinition: "feature" Identifier "=" "{" FeatureDeclarationsAndDefinitions "}" . + + $default reduce using rule 38 (FeatureDefinition) State 316 - 168 ChooseRule: "choose" AttributedVariable "in" . Term "do" Rule - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 341 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 42 FeatureDeclarationsAndDefinitions: FeatureDeclarationsAndDefinitions FeatureDeclarationOrDefinition . + + $default reduce using rule 42 (FeatureDeclarationsAndDefinitions) State 317 - 157 ConditionalRule: "if" Term "then" . Rule - 158 | "if" Term "then" . Rule "else" Rule - - "seq" shift, and go to state 209 - "par" shift, and go to state 210 - "skip" shift, and go to state 211 - "let" shift, and go to state 212 - "in" shift, and go to state 23 - "forall" shift, and go to state 213 - "choose" shift, and go to state 214 - "iterate" shift, and go to state 215 - "call" shift, and go to state 216 - "if" shift, and go to state 217 - "case" shift, and go to state 218 - "(" shift, and go to state 219 - "{" shift, and go to state 220 - "." shift, and go to state 25 - "{|" shift, and go to state 221 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - DirectCallExpression go to state 222 - IndirectCallExpression go to state 223 - Rule go to state 342 - SkipRule go to state 225 - ConditionalRule go to state 226 - CaseRule go to state 227 - LetRule go to state 228 - ForallRule go to state 229 - ChooseRule go to state 230 - IterateRule go to state 231 - BlockRule go to state 232 - SequenceRule go to state 233 - UpdateRule go to state 234 - CallRule go to state 235 + 44 ImplementationDefinition: "implements" IdentifierPath "for" Type "=" "{" . ImplementationDefinitionDefinitions "}" + + "derived" shift, and go to state 5 + "rule" shift, and go to state 7 + + DerivedDefinition go to state 269 + ImplementationDefinitionDefinition go to state 270 + ImplementationDefinitionDefinitions go to state 354 + RuleDefinition go to state 272 State 318 - 159 CaseRule: "case" Term "of" . "{" CaseLabels "}" - 160 | "case" Term "of" . "{" error "}" + 76 RelationType: IdentifierPath "<" MaybeFunctionParameters "->" Type . ">" - "{" shift, and go to state 343 + ">" shift, and go to state 355 State 319 - 172 BlockRule: "{" error "}" . + 78 Types: Types "," Type . - $default reduce using rule 172 (BlockRule) + $default reduce using rule 78 (Types) State 320 - 170 BlockRule: "{" Rules "}" . + 45 ImplementationDefinition: "implements" Type "=" "{" ImplementationDefinitionDefinitions "}" . - $default reduce using rule 170 (BlockRule) + $default reduce using rule 45 (ImplementationDefinition) State 321 - 176 SequenceRule: "{|" error "|}" . + 48 ImplementationDefinitionDefinitions: ImplementationDefinitionDefinitions ImplementationDefinitionDefinition . - $default reduce using rule 176 (SequenceRule) + $default reduce using rule 48 (ImplementationDefinitionDefinitions) State 322 - 174 SequenceRule: "{|" Rules "|}" . + 63 AttributedVariable: "[" Attributes "]" Variable . - $default reduce using rule 174 (SequenceRule) + $default reduce using rule 63 (AttributedVariable) State 323 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - 178 UpdateRule: DirectCallExpression ":=" Term . - - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "implies" shift, and go to state 127 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "=>" shift, and go to state 138 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 - - $default reduce using rule 178 (UpdateRule) + 144 LetExpression: "let" AttributedVariable "=" Term "in" . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 356 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 324 - 142 RuleDefinition: "rule" Identifier MaybeParameters "->" Type "=" Rule . - - $default reduce using rule 142 (RuleDefinition) + 147 UniversalQuantifierExpression: "forall" AttributedVariable "in" Term "holds" . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 357 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 325 - 19 MaybeDefined: "defined" . "{" Term "}" - - "{" shift, and go to state 344 + 146 ChooseExpression: "choose" AttributedVariable "in" Term "do" . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 358 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 326 - 13 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined . MaybeInitially - - "initially" shift, and go to state 345 - - $default reduce using rule 18 (MaybeInitially) - - MaybeInitially go to state 346 + 145 ConditionalExpression: "if" Term "then" Term "else" . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 359 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 327 - 68 RelationType: IdentifierPath "<" MaybeFunctionParameters "->" . Type ">" - - "in" shift, and go to state 23 - "." shift, and go to state 25 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 153 - Type go to state 347 - BasicType go to state 155 - ComposedType go to state 156 - RelationType go to state 157 - FixedSizedType go to state 158 + 148 ExistentialQuantifierExpression: "exists" AttributedVariable "in" Term "with" . Term + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 360 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 328 - 70 Types: Types "," . Type - - "in" shift, and go to state 23 - "." shift, and go to state 25 - "identifier" shift, and go to state 26 + 143 IndirectCallExpression: "(" "*" Term ")" Arguments . - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 153 - Type go to state 348 - BasicType go to state 155 - ComposedType go to state 156 - RelationType go to state 157 - FixedSizedType go to state 158 + $default reduce using rule 143 (IndirectCallExpression) State 329 - 67 ComposedType: IdentifierPath "<" Types ">" . + 140 TwoOrMoreArguments: "(" Terms "," Term ")" . - $default reduce using rule 67 (ComposedType) + $default reduce using rule 140 (TwoOrMoreArguments) State 330 - 15 FunctionDefinitions: FunctionDefinitions "," FunctionDefinition . + 131 Range: "[" Term ".." Term "]" . - $default reduce using rule 15 (FunctionDefinitions) + $default reduce using rule 131 (Range) State 331 - 43 DeclarationDefinition: "derived" Identifier ":" . MaybeFunctionParameters "->" Type - - "in" shift, and go to state 23 - "." shift, and go to state 25 - "identifier" shift, and go to state 26 - - $default reduce using rule 24 (MaybeFunctionParameters) - - FunctionParameters go to state 151 - MaybeFunctionParameters go to state 349 - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 153 - Type go to state 154 - BasicType go to state 155 - ComposedType go to state 156 - RelationType go to state 157 - FixedSizedType go to state 158 + 35 DerivedDefinition: "derived" Identifier MaybeParameters "->" Type "=" Term . + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "implies" shift, and go to state 142 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "=>" shift, and go to state 153 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 + + $default reduce using rule 35 (DerivedDefinition) State 332 - 44 DeclarationDefinition: "rule" Identifier ":" . MaybeFunctionParameters "->" Type + 54 Identifiers: Identifiers "," Identifier . - "in" shift, and go to state 23 - "." shift, and go to state 25 - "identifier" shift, and go to state 26 - - $default reduce using rule 24 (MaybeFunctionParameters) - - FunctionParameters go to state 151 - MaybeFunctionParameters go to state 350 - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 153 - Type go to state 154 - BasicType go to state 155 - ComposedType go to state 156 - RelationType go to state 157 - FixedSizedType go to state 158 + $default reduce using rule 54 (Identifiers) State 333 - 41 FeatureDeclarationsAndDefinitions: FeatureDeclarationsAndDefinitions "," FeatureDeclarationOrDefinition . + 185 SequenceRule: "seq" error "endseq" . - $default reduce using rule 41 (FeatureDeclarationsAndDefinitions) + $default reduce using rule 185 (SequenceRule) State 334 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - 136 LetExpression: "let" AttributedVariable "=" Term "in" Term . - - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "implies" shift, and go to state 127 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "=>" shift, and go to state 138 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 - - $default reduce using rule 136 (LetExpression) + 183 SequenceRule: "seq" Rules "endseq" . + + $default reduce using rule 183 (SequenceRule) State 335 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - 139 UniversalQuantifierExpression: "forall" AttributedVariable "in" Term "holds" Term . - - $default reduce using rule 139 (UniversalQuantifierExpression) + 162 Rules: Rules Rule . + + $default reduce using rule 162 (Rules) State 336 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - 138 ChooseExpression: "choose" AttributedVariable "in" Term "do" Term . - - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "implies" shift, and go to state 127 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "=>" shift, and go to state 138 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 - - $default reduce using rule 138 (ChooseExpression) + 181 BlockRule: "par" error "endpar" . + + $default reduce using rule 181 (BlockRule) State 337 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - 137 ConditionalExpression: "if" Term "then" Term "else" Term . - - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "implies" shift, and go to state 127 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "=>" shift, and go to state 138 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 - - $default reduce using rule 137 (ConditionalExpression) + 179 BlockRule: "par" Rules "endpar" . + + $default reduce using rule 179 (BlockRule) State 338 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - 140 ExistentialQuantifierExpression: "exists" AttributedVariable "in" Term "with" Term . - - $default reduce using rule 140 (ExistentialQuantifierExpression) + 174 LetRule: "let" AttributedVariable "=" . Term "in" Rule + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 361 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 339 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - 166 LetRule: "let" AttributedVariable "=" Term . "in" Rule - - "in" shift, and go to state 351 - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "implies" shift, and go to state 127 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "=>" shift, and go to state 138 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 + 175 ForallRule: "forall" AttributedVariable "in" . Term "do" Rule + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 362 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 340 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - 167 ForallRule: "forall" AttributedVariable "in" Term . "do" Rule - - "do" shift, and go to state 352 - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "implies" shift, and go to state 127 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "=>" shift, and go to state 138 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 + 176 ChooseRule: "choose" AttributedVariable "in" . Term "do" Rule + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 363 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 341 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - 168 ChooseRule: "choose" AttributedVariable "in" Term . "do" Rule - - "do" shift, and go to state 353 - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "implies" shift, and go to state 127 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "=>" shift, and go to state 138 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 + 165 ConditionalRule: "if" Term "then" . Rule + 166 | "if" Term "then" . Rule "else" Rule + + "this" shift, and go to state 25 + "seq" shift, and go to state 226 + "par" shift, and go to state 227 + "skip" shift, and go to state 228 + "let" shift, and go to state 229 + "in" shift, and go to state 26 + "forall" shift, and go to state 230 + "choose" shift, and go to state 231 + "iterate" shift, and go to state 232 + "call" shift, and go to state 233 + "if" shift, and go to state 234 + "case" shift, and go to state 235 + "(" shift, and go to state 236 + "{" shift, and go to state 237 + "." shift, and go to state 28 + "{|" shift, and go to state 238 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + DirectCallExpression go to state 239 + IndirectCallExpression go to state 240 + Rule go to state 364 + SkipRule go to state 242 + ConditionalRule go to state 243 + CaseRule go to state 244 + LetRule go to state 245 + ForallRule go to state 246 + ChooseRule go to state 247 + IterateRule go to state 248 + BlockRule go to state 249 + SequenceRule go to state 250 + UpdateRule go to state 251 + CallRule go to state 252 State 342 - 157 ConditionalRule: "if" Term "then" Rule . - 158 | "if" Term "then" Rule . "else" Rule + 167 CaseRule: "case" Term "of" . "{" CaseLabels "}" + 168 | "case" Term "of" . "{" error "}" - "else" shift, and go to state 354 - - $default reduce using rule 157 (ConditionalRule) + "{" shift, and go to state 365 State 343 - 159 CaseRule: "case" Term "of" "{" . CaseLabels "}" - 160 | "case" Term "of" "{" . error "}" - - error shift, and go to state 355 - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "default" shift, and go to state 356 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "_" shift, and go to state 357 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 358 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 - CaseLabel go to state 359 - CaseLabels go to state 360 + 180 BlockRule: "{" error "}" . + + $default reduce using rule 180 (BlockRule) State 344 - 19 MaybeDefined: "defined" "{" . Term "}" - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 361 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 178 BlockRule: "{" Rules "}" . + + $default reduce using rule 178 (BlockRule) State 345 - 17 MaybeInitially: "initially" . "{" MaybeInitializers "}" + 184 SequenceRule: "{|" error "|}" . - "{" shift, and go to state 362 + $default reduce using rule 184 (SequenceRule) State 346 - 13 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially . + 182 SequenceRule: "{|" Rules "|}" . - $default reduce using rule 13 (FunctionDefinition) + $default reduce using rule 182 (SequenceRule) State 347 - 68 RelationType: IdentifierPath "<" MaybeFunctionParameters "->" Type . ">" - - ">" shift, and go to state 363 + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + 186 UpdateRule: DirectCallExpression ":=" Term . + + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "implies" shift, and go to state 142 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "=>" shift, and go to state 153 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 + + $default reduce using rule 186 (UpdateRule) State 348 - 70 Types: Types "," Type . + 150 RuleDefinition: "rule" Identifier MaybeParameters "->" Type "=" Rule . - $default reduce using rule 70 (Types) + $default reduce using rule 150 (RuleDefinition) State 349 - 43 DeclarationDefinition: "derived" Identifier ":" MaybeFunctionParameters . "->" Type + 20 MaybeDefined: "defined" . "{" Term "}" - "->" shift, and go to state 364 + "{" shift, and go to state 366 State 350 - 44 DeclarationDefinition: "rule" Identifier ":" MaybeFunctionParameters . "->" Type + 14 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined . MaybeInitially + + "initially" shift, and go to state 367 - "->" shift, and go to state 365 + $default reduce using rule 19 (MaybeInitially) + + MaybeInitially go to state 368 State 351 - 166 LetRule: "let" AttributedVariable "=" Term "in" . Rule - - "seq" shift, and go to state 209 - "par" shift, and go to state 210 - "skip" shift, and go to state 211 - "let" shift, and go to state 212 - "in" shift, and go to state 23 - "forall" shift, and go to state 213 - "choose" shift, and go to state 214 - "iterate" shift, and go to state 215 - "call" shift, and go to state 216 - "if" shift, and go to state 217 - "case" shift, and go to state 218 - "(" shift, and go to state 219 - "{" shift, and go to state 220 - "." shift, and go to state 25 - "{|" shift, and go to state 221 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - DirectCallExpression go to state 222 - IndirectCallExpression go to state 223 - Rule go to state 366 - SkipRule go to state 225 - ConditionalRule go to state 226 - CaseRule go to state 227 - LetRule go to state 228 - ForallRule go to state 229 - ChooseRule go to state 230 - IterateRule go to state 231 - BlockRule go to state 232 - SequenceRule go to state 233 - UpdateRule go to state 234 - CallRule go to state 235 + 16 FunctionDefinitions: FunctionDefinitions "," FunctionDefinition . + + $default reduce using rule 16 (FunctionDefinitions) State 352 - 167 ForallRule: "forall" AttributedVariable "in" Term "do" . Rule - - "seq" shift, and go to state 209 - "par" shift, and go to state 210 - "skip" shift, and go to state 211 - "let" shift, and go to state 212 - "in" shift, and go to state 23 - "forall" shift, and go to state 213 - "choose" shift, and go to state 214 - "iterate" shift, and go to state 215 - "call" shift, and go to state 216 - "if" shift, and go to state 217 - "case" shift, and go to state 218 - "(" shift, and go to state 219 - "{" shift, and go to state 220 - "." shift, and go to state 25 - "{|" shift, and go to state 221 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - DirectCallExpression go to state 222 - IndirectCallExpression go to state 223 - Rule go to state 367 - SkipRule go to state 225 - ConditionalRule go to state 226 - CaseRule go to state 227 - LetRule go to state 228 - ForallRule go to state 229 - ChooseRule go to state 230 - IterateRule go to state 231 - BlockRule go to state 232 - SequenceRule go to state 233 - UpdateRule go to state 234 - CallRule go to state 235 + 50 DeclarationDefinition: "derived" Identifier ":" . MaybeFunctionParameters "->" Type + + "this" shift, and go to state 25 + "in" shift, and go to state 26 + "." shift, and go to state 28 + "identifier" shift, and go to state 29 + + $default reduce using rule 25 (MaybeFunctionParameters) + + FunctionParameters go to state 166 + MaybeFunctionParameters go to state 369 + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 168 + Type go to state 169 + BasicType go to state 41 + ComposedType go to state 42 + RelationType go to state 43 + FixedSizedType go to state 44 State 353 - 168 ChooseRule: "choose" AttributedVariable "in" Term "do" . Rule - - "seq" shift, and go to state 209 - "par" shift, and go to state 210 - "skip" shift, and go to state 211 - "let" shift, and go to state 212 - "in" shift, and go to state 23 - "forall" shift, and go to state 213 - "choose" shift, and go to state 214 - "iterate" shift, and go to state 215 - "call" shift, and go to state 216 - "if" shift, and go to state 217 - "case" shift, and go to state 218 - "(" shift, and go to state 219 - "{" shift, and go to state 220 - "." shift, and go to state 25 - "{|" shift, and go to state 221 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - DirectCallExpression go to state 222 - IndirectCallExpression go to state 223 - Rule go to state 368 - SkipRule go to state 225 - ConditionalRule go to state 226 - CaseRule go to state 227 - LetRule go to state 228 - ForallRule go to state 229 - ChooseRule go to state 230 - IterateRule go to state 231 - BlockRule go to state 232 - SequenceRule go to state 233 - UpdateRule go to state 234 - CallRule go to state 235 + 51 DeclarationDefinition: "rule" Identifier ":" . MaybeFunctionParameters "->" Type + + "this" shift, and go to state 25 + "in" shift, and go to state 26 + "." shift, and go to state 28 + "identifier" shift, and go to state 29 + + $default reduce using rule 25 (MaybeFunctionParameters) + + FunctionParameters go to state 166 + MaybeFunctionParameters go to state 370 + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 168 + Type go to state 169 + BasicType go to state 41 + ComposedType go to state 42 + RelationType go to state 43 + FixedSizedType go to state 44 State 354 - 158 ConditionalRule: "if" Term "then" Rule "else" . Rule - - "seq" shift, and go to state 209 - "par" shift, and go to state 210 - "skip" shift, and go to state 211 - "let" shift, and go to state 212 - "in" shift, and go to state 23 - "forall" shift, and go to state 213 - "choose" shift, and go to state 214 - "iterate" shift, and go to state 215 - "call" shift, and go to state 216 - "if" shift, and go to state 217 - "case" shift, and go to state 218 - "(" shift, and go to state 219 - "{" shift, and go to state 220 - "." shift, and go to state 25 - "{|" shift, and go to state 221 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - DirectCallExpression go to state 222 - IndirectCallExpression go to state 223 - Rule go to state 369 - SkipRule go to state 225 - ConditionalRule go to state 226 - CaseRule go to state 227 - LetRule go to state 228 - ForallRule go to state 229 - ChooseRule go to state 230 - IterateRule go to state 231 - BlockRule go to state 232 - SequenceRule go to state 233 - UpdateRule go to state 234 - CallRule go to state 235 + 44 ImplementationDefinition: "implements" IdentifierPath "for" Type "=" "{" ImplementationDefinitionDefinitions . "}" + 48 ImplementationDefinitionDefinitions: ImplementationDefinitionDefinitions . ImplementationDefinitionDefinition + + "derived" shift, and go to state 5 + "rule" shift, and go to state 7 + "}" shift, and go to state 371 + + DerivedDefinition go to state 269 + ImplementationDefinitionDefinition go to state 321 + RuleDefinition go to state 272 State 355 - 160 CaseRule: "case" Term "of" "{" error . "}" + 76 RelationType: IdentifierPath "<" MaybeFunctionParameters "->" Type ">" . - "}" shift, and go to state 370 + $default reduce using rule 76 (RelationType) State 356 - 161 CaseLabel: "default" . ":" Rule - - ":" shift, and go to state 371 + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + 144 LetExpression: "let" AttributedVariable "=" Term "in" Term . + + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "implies" shift, and go to state 142 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "=>" shift, and go to state 153 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 + + $default reduce using rule 144 (LetExpression) State 357 - 162 CaseLabel: "_" . ":" Rule - - ":" shift, and go to state 372 + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + 147 UniversalQuantifierExpression: "forall" AttributedVariable "in" Term "holds" Term . + + $default reduce using rule 147 (UniversalQuantifierExpression) State 358 - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - 163 CaseLabel: Term . ":" Rule - - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "implies" shift, and go to state 127 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - ":" shift, and go to state 373 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "=>" shift, and go to state 138 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + 146 ChooseExpression: "choose" AttributedVariable "in" Term "do" Term . + + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "implies" shift, and go to state 142 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "=>" shift, and go to state 153 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 + + $default reduce using rule 146 (ChooseExpression) State 359 - 164 CaseLabels: CaseLabel . CaseLabels - 165 | CaseLabel . - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "default" shift, and go to state 356 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 96 - "[" shift, and go to state 54 - "_" shift, and go to state 357 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - $default reduce using rule 165 (CaseLabels) - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 358 - Expression go to state 76 - Range go to state 77 - List go to state 78 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 - CaseLabel go to state 359 - CaseLabels go to state 374 + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + 145 ConditionalExpression: "if" Term "then" Term "else" Term . + + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "implies" shift, and go to state 142 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "=>" shift, and go to state 153 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 + + $default reduce using rule 145 (ConditionalExpression) State 360 - 159 CaseRule: "case" Term "of" "{" CaseLabels . "}" - - "}" shift, and go to state 375 + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + 148 ExistentialQuantifierExpression: "exists" AttributedVariable "in" Term "with" Term . + + $default reduce using rule 148 (ExistentialQuantifierExpression) State 361 - 19 MaybeDefined: "defined" "{" Term . "}" - 105 Expression: Term . "+" Term - 106 | Term . "-" Term - 107 | Term . "*" Term - 108 | Term . "/" Term - 109 | Term . "%" Term - 110 | Term . "^" Term - 111 | Term . "!=" Term - 112 | Term . "=" Term - 113 | Term . "<" Term - 114 | Term . ">" Term - 115 | Term . "<=" Term - 116 | Term . ">=" Term - 117 | Term . "or" Term - 118 | Term . "xor" Term - 119 | Term . "and" Term - 120 | Term . "=>" Term - 121 | Term . "implies" Term - - "and" shift, and go to state 124 - "or" shift, and go to state 125 - "xor" shift, and go to state 126 - "implies" shift, and go to state 127 - "+" shift, and go to state 128 - "-" shift, and go to state 129 - "=" shift, and go to state 130 - "}" shift, and go to state 376 - "<" shift, and go to state 131 - ">" shift, and go to state 132 - "*" shift, and go to state 133 - "/" shift, and go to state 134 - "%" shift, and go to state 135 - "^" shift, and go to state 136 - "=>" shift, and go to state 138 - "!=" shift, and go to state 139 - "<=" shift, and go to state 140 - ">=" shift, and go to state 141 + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + 174 LetRule: "let" AttributedVariable "=" Term . "in" Rule + + "in" shift, and go to state 372 + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "implies" shift, and go to state 142 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "=>" shift, and go to state 153 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 State 362 - 17 MaybeInitially: "initially" "{" . MaybeInitializers "}" - - "let" shift, and go to state 42 - "in" shift, and go to state 23 - "forall" shift, and go to state 43 - "choose" shift, and go to state 44 - "if" shift, and go to state 45 - "exists" shift, and go to state 46 - "undef" shift, and go to state 47 - "false" shift, and go to state 48 - "true" shift, and go to state 49 - "not" shift, and go to state 50 - "+" shift, and go to state 51 - "-" shift, and go to state 52 - "(" shift, and go to state 53 - "[" shift, and go to state 54 - "@" shift, and go to state 55 - "." shift, and go to state 25 - "binary" shift, and go to state 56 - "hexadecimal" shift, and go to state 57 - "integer" shift, and go to state 58 - "rational" shift, and go to state 59 - "floating" shift, and go to state 60 - "string" shift, and go to state 61 - "identifier" shift, and go to state 26 - - $default reduce using rule 33 (MaybeInitializers) - - Initializer go to state 62 - Initializers go to state 63 - MaybeInitializers go to state 377 - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - Atom go to state 66 - Undefined go to state 67 - Boolean go to state 68 - String go to state 69 - BitNumber go to state 70 - IntegerNumber go to state 71 - FloatingNumber go to state 72 - RationalNumber go to state 73 - Reference go to state 74 - Term go to state 75 - Expression go to state 76 - Range go to state 77 - List go to state 78 - TwoOrMoreArguments go to state 79 - DirectCallExpression go to state 80 - IndirectCallExpression go to state 81 - LetExpression go to state 82 - ConditionalExpression go to state 83 - ChooseExpression go to state 84 - UniversalQuantifierExpression go to state 85 - ExistentialQuantifierExpression go to state 86 + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + 175 ForallRule: "forall" AttributedVariable "in" Term . "do" Rule + + "do" shift, and go to state 373 + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "implies" shift, and go to state 142 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "=>" shift, and go to state 153 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 State 363 - 68 RelationType: IdentifierPath "<" MaybeFunctionParameters "->" Type ">" . - - $default reduce using rule 68 (RelationType) + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + 176 ChooseRule: "choose" AttributedVariable "in" Term . "do" Rule + + "do" shift, and go to state 374 + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "implies" shift, and go to state 142 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "=>" shift, and go to state 153 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 State 364 - 43 DeclarationDefinition: "derived" Identifier ":" MaybeFunctionParameters "->" . Type + 165 ConditionalRule: "if" Term "then" Rule . + 166 | "if" Term "then" Rule . "else" Rule - "in" shift, and go to state 23 - "." shift, and go to state 25 - "identifier" shift, and go to state 26 + "else" shift, and go to state 375 - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 153 - Type go to state 378 - BasicType go to state 155 - ComposedType go to state 156 - RelationType go to state 157 - FixedSizedType go to state 158 + $default reduce using rule 165 (ConditionalRule) State 365 - 44 DeclarationDefinition: "rule" Identifier ":" MaybeFunctionParameters "->" . Type - - "in" shift, and go to state 23 - "." shift, and go to state 25 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 153 - Type go to state 379 - BasicType go to state 155 - ComposedType go to state 156 - RelationType go to state 157 - FixedSizedType go to state 158 + 167 CaseRule: "case" Term "of" "{" . CaseLabels "}" + 168 | "case" Term "of" "{" . error "}" + + error shift, and go to state 376 + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "default" shift, and go to state 377 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "_" shift, and go to state 378 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 379 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 + CaseLabel go to state 380 + CaseLabels go to state 381 State 366 - 166 LetRule: "let" AttributedVariable "=" Term "in" Rule . - - $default reduce using rule 166 (LetRule) + 20 MaybeDefined: "defined" "{" . Term "}" + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 382 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 State 367 - 167 ForallRule: "forall" AttributedVariable "in" Term "do" Rule . + 18 MaybeInitially: "initially" . "{" MaybeInitializers "}" - $default reduce using rule 167 (ForallRule) + "{" shift, and go to state 383 State 368 - 168 ChooseRule: "choose" AttributedVariable "in" Term "do" Rule . + 14 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially . - $default reduce using rule 168 (ChooseRule) + $default reduce using rule 14 (FunctionDefinition) State 369 - 158 ConditionalRule: "if" Term "then" Rule "else" Rule . + 50 DeclarationDefinition: "derived" Identifier ":" MaybeFunctionParameters . "->" Type - $default reduce using rule 158 (ConditionalRule) + "->" shift, and go to state 384 State 370 - 160 CaseRule: "case" Term "of" "{" error "}" . + 51 DeclarationDefinition: "rule" Identifier ":" MaybeFunctionParameters . "->" Type - $default reduce using rule 160 (CaseRule) + "->" shift, and go to state 385 State 371 - 161 CaseLabel: "default" ":" . Rule - - "seq" shift, and go to state 209 - "par" shift, and go to state 210 - "skip" shift, and go to state 211 - "let" shift, and go to state 212 - "in" shift, and go to state 23 - "forall" shift, and go to state 213 - "choose" shift, and go to state 214 - "iterate" shift, and go to state 215 - "call" shift, and go to state 216 - "if" shift, and go to state 217 - "case" shift, and go to state 218 - "(" shift, and go to state 219 - "{" shift, and go to state 220 - "." shift, and go to state 25 - "{|" shift, and go to state 221 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - DirectCallExpression go to state 222 - IndirectCallExpression go to state 223 - Rule go to state 380 - SkipRule go to state 225 - ConditionalRule go to state 226 - CaseRule go to state 227 - LetRule go to state 228 - ForallRule go to state 229 - ChooseRule go to state 230 - IterateRule go to state 231 - BlockRule go to state 232 - SequenceRule go to state 233 - UpdateRule go to state 234 - CallRule go to state 235 + 44 ImplementationDefinition: "implements" IdentifierPath "for" Type "=" "{" ImplementationDefinitionDefinitions "}" . + + $default reduce using rule 44 (ImplementationDefinition) State 372 - 162 CaseLabel: "_" ":" . Rule - - "seq" shift, and go to state 209 - "par" shift, and go to state 210 - "skip" shift, and go to state 211 - "let" shift, and go to state 212 - "in" shift, and go to state 23 - "forall" shift, and go to state 213 - "choose" shift, and go to state 214 - "iterate" shift, and go to state 215 - "call" shift, and go to state 216 - "if" shift, and go to state 217 - "case" shift, and go to state 218 - "(" shift, and go to state 219 - "{" shift, and go to state 220 - "." shift, and go to state 25 - "{|" shift, and go to state 221 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - DirectCallExpression go to state 222 - IndirectCallExpression go to state 223 - Rule go to state 381 - SkipRule go to state 225 - ConditionalRule go to state 226 - CaseRule go to state 227 - LetRule go to state 228 - ForallRule go to state 229 - ChooseRule go to state 230 - IterateRule go to state 231 - BlockRule go to state 232 - SequenceRule go to state 233 - UpdateRule go to state 234 - CallRule go to state 235 + 174 LetRule: "let" AttributedVariable "=" Term "in" . Rule + + "this" shift, and go to state 25 + "seq" shift, and go to state 226 + "par" shift, and go to state 227 + "skip" shift, and go to state 228 + "let" shift, and go to state 229 + "in" shift, and go to state 26 + "forall" shift, and go to state 230 + "choose" shift, and go to state 231 + "iterate" shift, and go to state 232 + "call" shift, and go to state 233 + "if" shift, and go to state 234 + "case" shift, and go to state 235 + "(" shift, and go to state 236 + "{" shift, and go to state 237 + "." shift, and go to state 28 + "{|" shift, and go to state 238 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + DirectCallExpression go to state 239 + IndirectCallExpression go to state 240 + Rule go to state 386 + SkipRule go to state 242 + ConditionalRule go to state 243 + CaseRule go to state 244 + LetRule go to state 245 + ForallRule go to state 246 + ChooseRule go to state 247 + IterateRule go to state 248 + BlockRule go to state 249 + SequenceRule go to state 250 + UpdateRule go to state 251 + CallRule go to state 252 State 373 - 163 CaseLabel: Term ":" . Rule - - "seq" shift, and go to state 209 - "par" shift, and go to state 210 - "skip" shift, and go to state 211 - "let" shift, and go to state 212 - "in" shift, and go to state 23 - "forall" shift, and go to state 213 - "choose" shift, and go to state 214 - "iterate" shift, and go to state 215 - "call" shift, and go to state 216 - "if" shift, and go to state 217 - "case" shift, and go to state 218 - "(" shift, and go to state 219 - "{" shift, and go to state 220 - "." shift, and go to state 25 - "{|" shift, and go to state 221 - "identifier" shift, and go to state 26 - - Identifier go to state 27 - DotSeparatedIdentifiers go to state 28 - IdentifierPath go to state 65 - DirectCallExpression go to state 222 - IndirectCallExpression go to state 223 - Rule go to state 382 - SkipRule go to state 225 - ConditionalRule go to state 226 - CaseRule go to state 227 - LetRule go to state 228 - ForallRule go to state 229 - ChooseRule go to state 230 - IterateRule go to state 231 - BlockRule go to state 232 - SequenceRule go to state 233 - UpdateRule go to state 234 - CallRule go to state 235 + 175 ForallRule: "forall" AttributedVariable "in" Term "do" . Rule + + "this" shift, and go to state 25 + "seq" shift, and go to state 226 + "par" shift, and go to state 227 + "skip" shift, and go to state 228 + "let" shift, and go to state 229 + "in" shift, and go to state 26 + "forall" shift, and go to state 230 + "choose" shift, and go to state 231 + "iterate" shift, and go to state 232 + "call" shift, and go to state 233 + "if" shift, and go to state 234 + "case" shift, and go to state 235 + "(" shift, and go to state 236 + "{" shift, and go to state 237 + "." shift, and go to state 28 + "{|" shift, and go to state 238 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + DirectCallExpression go to state 239 + IndirectCallExpression go to state 240 + Rule go to state 387 + SkipRule go to state 242 + ConditionalRule go to state 243 + CaseRule go to state 244 + LetRule go to state 245 + ForallRule go to state 246 + ChooseRule go to state 247 + IterateRule go to state 248 + BlockRule go to state 249 + SequenceRule go to state 250 + UpdateRule go to state 251 + CallRule go to state 252 State 374 - 164 CaseLabels: CaseLabel CaseLabels . - - $default reduce using rule 164 (CaseLabels) + 176 ChooseRule: "choose" AttributedVariable "in" Term "do" . Rule + + "this" shift, and go to state 25 + "seq" shift, and go to state 226 + "par" shift, and go to state 227 + "skip" shift, and go to state 228 + "let" shift, and go to state 229 + "in" shift, and go to state 26 + "forall" shift, and go to state 230 + "choose" shift, and go to state 231 + "iterate" shift, and go to state 232 + "call" shift, and go to state 233 + "if" shift, and go to state 234 + "case" shift, and go to state 235 + "(" shift, and go to state 236 + "{" shift, and go to state 237 + "." shift, and go to state 28 + "{|" shift, and go to state 238 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + DirectCallExpression go to state 239 + IndirectCallExpression go to state 240 + Rule go to state 388 + SkipRule go to state 242 + ConditionalRule go to state 243 + CaseRule go to state 244 + LetRule go to state 245 + ForallRule go to state 246 + ChooseRule go to state 247 + IterateRule go to state 248 + BlockRule go to state 249 + SequenceRule go to state 250 + UpdateRule go to state 251 + CallRule go to state 252 State 375 - 159 CaseRule: "case" Term "of" "{" CaseLabels "}" . - - $default reduce using rule 159 (CaseRule) + 166 ConditionalRule: "if" Term "then" Rule "else" . Rule + + "this" shift, and go to state 25 + "seq" shift, and go to state 226 + "par" shift, and go to state 227 + "skip" shift, and go to state 228 + "let" shift, and go to state 229 + "in" shift, and go to state 26 + "forall" shift, and go to state 230 + "choose" shift, and go to state 231 + "iterate" shift, and go to state 232 + "call" shift, and go to state 233 + "if" shift, and go to state 234 + "case" shift, and go to state 235 + "(" shift, and go to state 236 + "{" shift, and go to state 237 + "." shift, and go to state 28 + "{|" shift, and go to state 238 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + DirectCallExpression go to state 239 + IndirectCallExpression go to state 240 + Rule go to state 389 + SkipRule go to state 242 + ConditionalRule go to state 243 + CaseRule go to state 244 + LetRule go to state 245 + ForallRule go to state 246 + ChooseRule go to state 247 + IterateRule go to state 248 + BlockRule go to state 249 + SequenceRule go to state 250 + UpdateRule go to state 251 + CallRule go to state 252 State 376 - 19 MaybeDefined: "defined" "{" Term "}" . + 168 CaseRule: "case" Term "of" "{" error . "}" - $default reduce using rule 19 (MaybeDefined) + "}" shift, and go to state 390 State 377 - 17 MaybeInitially: "initially" "{" MaybeInitializers . "}" + 169 CaseLabel: "default" . ":" Rule - "}" shift, and go to state 383 + ":" shift, and go to state 391 State 378 - 43 DeclarationDefinition: "derived" Identifier ":" MaybeFunctionParameters "->" Type . + 170 CaseLabel: "_" . ":" Rule - $default reduce using rule 43 (DeclarationDefinition) + ":" shift, and go to state 392 State 379 - 44 DeclarationDefinition: "rule" Identifier ":" MaybeFunctionParameters "->" Type . - - $default reduce using rule 44 (DeclarationDefinition) + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + 171 CaseLabel: Term . ":" Rule + + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "implies" shift, and go to state 142 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + ":" shift, and go to state 393 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "=>" shift, and go to state 153 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 State 380 - 161 CaseLabel: "default" ":" Rule . - - $default reduce using rule 161 (CaseLabel) + 172 CaseLabels: CaseLabel . CaseLabels + 173 | CaseLabel . + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "default" shift, and go to state 377 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 110 + "[" shift, and go to state 64 + "_" shift, and go to state 378 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + $default reduce using rule 173 (CaseLabels) + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 379 + Expression go to state 86 + Range go to state 87 + List go to state 88 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 + CaseLabel go to state 380 + CaseLabels go to state 394 State 381 - 162 CaseLabel: "_" ":" Rule . + 167 CaseRule: "case" Term "of" "{" CaseLabels . "}" - $default reduce using rule 162 (CaseLabel) + "}" shift, and go to state 395 State 382 - 163 CaseLabel: Term ":" Rule . - - $default reduce using rule 163 (CaseLabel) + 20 MaybeDefined: "defined" "{" Term . "}" + 113 Expression: Term . "+" Term + 114 | Term . "-" Term + 115 | Term . "*" Term + 116 | Term . "/" Term + 117 | Term . "%" Term + 118 | Term . "^" Term + 119 | Term . "!=" Term + 120 | Term . "=" Term + 121 | Term . "<" Term + 122 | Term . ">" Term + 123 | Term . "<=" Term + 124 | Term . ">=" Term + 125 | Term . "or" Term + 126 | Term . "xor" Term + 127 | Term . "and" Term + 128 | Term . "=>" Term + 129 | Term . "implies" Term + + "and" shift, and go to state 139 + "or" shift, and go to state 140 + "xor" shift, and go to state 141 + "implies" shift, and go to state 142 + "+" shift, and go to state 143 + "-" shift, and go to state 144 + "=" shift, and go to state 145 + "}" shift, and go to state 396 + "<" shift, and go to state 146 + ">" shift, and go to state 147 + "*" shift, and go to state 148 + "/" shift, and go to state 149 + "%" shift, and go to state 150 + "^" shift, and go to state 151 + "=>" shift, and go to state 153 + "!=" shift, and go to state 154 + "<=" shift, and go to state 155 + ">=" shift, and go to state 156 State 383 - 17 MaybeInitially: "initially" "{" MaybeInitializers "}" . + 18 MaybeInitially: "initially" "{" . MaybeInitializers "}" + + "this" shift, and go to state 25 + "let" shift, and go to state 52 + "in" shift, and go to state 26 + "forall" shift, and go to state 53 + "choose" shift, and go to state 54 + "if" shift, and go to state 55 + "exists" shift, and go to state 56 + "undef" shift, and go to state 57 + "false" shift, and go to state 58 + "true" shift, and go to state 59 + "not" shift, and go to state 60 + "+" shift, and go to state 61 + "-" shift, and go to state 62 + "(" shift, and go to state 63 + "[" shift, and go to state 64 + "@" shift, and go to state 65 + "." shift, and go to state 28 + "binary" shift, and go to state 66 + "hexadecimal" shift, and go to state 67 + "integer" shift, and go to state 68 + "rational" shift, and go to state 69 + "floating" shift, and go to state 70 + "string" shift, and go to state 71 + "identifier" shift, and go to state 29 + + $default reduce using rule 34 (MaybeInitializers) + + Initializer go to state 72 + Initializers go to state 73 + MaybeInitializers go to state 397 + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + Atom go to state 76 + Undefined go to state 77 + Boolean go to state 78 + String go to state 79 + BitNumber go to state 80 + IntegerNumber go to state 81 + FloatingNumber go to state 82 + RationalNumber go to state 83 + Reference go to state 84 + Term go to state 85 + Expression go to state 86 + Range go to state 87 + List go to state 88 + TwoOrMoreArguments go to state 89 + DirectCallExpression go to state 90 + IndirectCallExpression go to state 91 + LetExpression go to state 92 + ConditionalExpression go to state 93 + ChooseExpression go to state 94 + UniversalQuantifierExpression go to state 95 + ExistentialQuantifierExpression go to state 96 + + +State 384 + + 50 DeclarationDefinition: "derived" Identifier ":" MaybeFunctionParameters "->" . Type + + "this" shift, and go to state 25 + "in" shift, and go to state 26 + "." shift, and go to state 28 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 168 + Type go to state 398 + BasicType go to state 41 + ComposedType go to state 42 + RelationType go to state 43 + FixedSizedType go to state 44 + + +State 385 + + 51 DeclarationDefinition: "rule" Identifier ":" MaybeFunctionParameters "->" . Type + + "this" shift, and go to state 25 + "in" shift, and go to state 26 + "." shift, and go to state 28 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 168 + Type go to state 399 + BasicType go to state 41 + ComposedType go to state 42 + RelationType go to state 43 + FixedSizedType go to state 44 + + +State 386 + + 174 LetRule: "let" AttributedVariable "=" Term "in" Rule . + + $default reduce using rule 174 (LetRule) + + +State 387 + + 175 ForallRule: "forall" AttributedVariable "in" Term "do" Rule . + + $default reduce using rule 175 (ForallRule) + + +State 388 + + 176 ChooseRule: "choose" AttributedVariable "in" Term "do" Rule . + + $default reduce using rule 176 (ChooseRule) + + +State 389 + + 166 ConditionalRule: "if" Term "then" Rule "else" Rule . + + $default reduce using rule 166 (ConditionalRule) + + +State 390 + + 168 CaseRule: "case" Term "of" "{" error "}" . + + $default reduce using rule 168 (CaseRule) + + +State 391 + + 169 CaseLabel: "default" ":" . Rule + + "this" shift, and go to state 25 + "seq" shift, and go to state 226 + "par" shift, and go to state 227 + "skip" shift, and go to state 228 + "let" shift, and go to state 229 + "in" shift, and go to state 26 + "forall" shift, and go to state 230 + "choose" shift, and go to state 231 + "iterate" shift, and go to state 232 + "call" shift, and go to state 233 + "if" shift, and go to state 234 + "case" shift, and go to state 235 + "(" shift, and go to state 236 + "{" shift, and go to state 237 + "." shift, and go to state 28 + "{|" shift, and go to state 238 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + DirectCallExpression go to state 239 + IndirectCallExpression go to state 240 + Rule go to state 400 + SkipRule go to state 242 + ConditionalRule go to state 243 + CaseRule go to state 244 + LetRule go to state 245 + ForallRule go to state 246 + ChooseRule go to state 247 + IterateRule go to state 248 + BlockRule go to state 249 + SequenceRule go to state 250 + UpdateRule go to state 251 + CallRule go to state 252 + + +State 392 + + 170 CaseLabel: "_" ":" . Rule + + "this" shift, and go to state 25 + "seq" shift, and go to state 226 + "par" shift, and go to state 227 + "skip" shift, and go to state 228 + "let" shift, and go to state 229 + "in" shift, and go to state 26 + "forall" shift, and go to state 230 + "choose" shift, and go to state 231 + "iterate" shift, and go to state 232 + "call" shift, and go to state 233 + "if" shift, and go to state 234 + "case" shift, and go to state 235 + "(" shift, and go to state 236 + "{" shift, and go to state 237 + "." shift, and go to state 28 + "{|" shift, and go to state 238 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + DirectCallExpression go to state 239 + IndirectCallExpression go to state 240 + Rule go to state 401 + SkipRule go to state 242 + ConditionalRule go to state 243 + CaseRule go to state 244 + LetRule go to state 245 + ForallRule go to state 246 + ChooseRule go to state 247 + IterateRule go to state 248 + BlockRule go to state 249 + SequenceRule go to state 250 + UpdateRule go to state 251 + CallRule go to state 252 + + +State 393 + + 171 CaseLabel: Term ":" . Rule + + "this" shift, and go to state 25 + "seq" shift, and go to state 226 + "par" shift, and go to state 227 + "skip" shift, and go to state 228 + "let" shift, and go to state 229 + "in" shift, and go to state 26 + "forall" shift, and go to state 230 + "choose" shift, and go to state 231 + "iterate" shift, and go to state 232 + "call" shift, and go to state 233 + "if" shift, and go to state 234 + "case" shift, and go to state 235 + "(" shift, and go to state 236 + "{" shift, and go to state 237 + "." shift, and go to state 28 + "{|" shift, and go to state 238 + "identifier" shift, and go to state 29 + + Identifier go to state 30 + DotSeparatedIdentifiers go to state 31 + IdentifierPath go to state 75 + DirectCallExpression go to state 239 + IndirectCallExpression go to state 240 + Rule go to state 402 + SkipRule go to state 242 + ConditionalRule go to state 243 + CaseRule go to state 244 + LetRule go to state 245 + ForallRule go to state 246 + ChooseRule go to state 247 + IterateRule go to state 248 + BlockRule go to state 249 + SequenceRule go to state 250 + UpdateRule go to state 251 + CallRule go to state 252 + + +State 394 + + 172 CaseLabels: CaseLabel CaseLabels . + + $default reduce using rule 172 (CaseLabels) + + +State 395 + + 167 CaseRule: "case" Term "of" "{" CaseLabels "}" . + + $default reduce using rule 167 (CaseRule) + + +State 396 + + 20 MaybeDefined: "defined" "{" Term "}" . + + $default reduce using rule 20 (MaybeDefined) + - $default reduce using rule 17 (MaybeInitially) +State 397 + + 18 MaybeInitially: "initially" "{" MaybeInitializers . "}" + + "}" shift, and go to state 403 + + +State 398 + + 50 DeclarationDefinition: "derived" Identifier ":" MaybeFunctionParameters "->" Type . + + $default reduce using rule 50 (DeclarationDefinition) + + +State 399 + + 51 DeclarationDefinition: "rule" Identifier ":" MaybeFunctionParameters "->" Type . + + $default reduce using rule 51 (DeclarationDefinition) + + +State 400 + + 169 CaseLabel: "default" ":" Rule . + + $default reduce using rule 169 (CaseLabel) + + +State 401 + + 170 CaseLabel: "_" ":" Rule . + + $default reduce using rule 170 (CaseLabel) + + +State 402 + + 171 CaseLabel: Term ":" Rule . + + $default reduce using rule 171 (CaseLabel) + + +State 403 + + 18 MaybeInitially: "initially" "{" MaybeInitializers "}" . + + $default reduce using rule 18 (MaybeInitially) diff --git a/src/various/GrammarParser.tab.h b/src/various/GrammarParser.tab.h index c58b79702..0e99fde05 100644 --- a/src/various/GrammarParser.tab.h +++ b/src/various/GrammarParser.tab.h @@ -348,10 +348,12 @@ namespace libcasm_fe { // Definition // AttributedDefinition // FeatureDeclarationOrDefinition + // ImplementationDefinitionDefinition char dummy16[sizeof(Definition::Ptr)]; // Definitions // FeatureDeclarationsAndDefinitions + // ImplementationDefinitionDefinitions char dummy17[sizeof(Definitions::Ptr)]; // DerivedDefinition @@ -406,77 +408,80 @@ namespace libcasm_fe { // DotSeparatedIdentifiers char dummy32[sizeof(Identifiers::Ptr)]; + // ImplementationDefinition + char dummy33[sizeof(ImplementationDefinition::Ptr)]; + // IndirectCallExpression - char dummy33[sizeof(IndirectCallExpression::Ptr)]; + char dummy34[sizeof(IndirectCallExpression::Ptr)]; // IterateRule - char dummy34[sizeof(IterateRule::Ptr)]; + char dummy35[sizeof(IterateRule::Ptr)]; // LetExpression - char dummy35[sizeof(LetExpression::Ptr)]; + char dummy36[sizeof(LetExpression::Ptr)]; // LetRule - char dummy36[sizeof(LetRule::Ptr)]; + char dummy37[sizeof(LetRule::Ptr)]; // List - char dummy37[sizeof(ListExpression::Ptr)]; + char dummy38[sizeof(ListExpression::Ptr)]; // MaybeInitially // Initializers // MaybeInitializers - char dummy38[sizeof(NodeList< UpdateRule >::Ptr)]; + char dummy39[sizeof(NodeList< UpdateRule >::Ptr)]; // Parameters // MaybeParameters - char dummy39[sizeof(NodeList< VariableDefinition >::Ptr)]; + char dummy40[sizeof(NodeList< VariableDefinition >::Ptr)]; // Range - char dummy40[sizeof(RangeExpression::Ptr)]; + char dummy41[sizeof(RangeExpression::Ptr)]; // Reference - char dummy41[sizeof(ReferenceAtom::Ptr)]; + char dummy42[sizeof(ReferenceAtom::Ptr)]; // RelationType - char dummy42[sizeof(RelationType::Ptr)]; + char dummy43[sizeof(RelationType::Ptr)]; // Rule - char dummy43[sizeof(Rule::Ptr)]; + char dummy44[sizeof(Rule::Ptr)]; // RuleDefinition - char dummy44[sizeof(RuleDefinition::Ptr)]; + char dummy45[sizeof(RuleDefinition::Ptr)]; // Rules - char dummy45[sizeof(Rules::Ptr)]; + char dummy46[sizeof(Rules::Ptr)]; // SequenceRule - char dummy46[sizeof(SequenceRule::Ptr)]; + char dummy47[sizeof(SequenceRule::Ptr)]; // SkipRule - char dummy47[sizeof(SkipRule::Ptr)]; + char dummy48[sizeof(SkipRule::Ptr)]; // Specification - char dummy48[sizeof(Specification::Ptr)]; + char dummy49[sizeof(Specification::Ptr)]; // StructureDefinition - char dummy49[sizeof(StructureDefinition::Ptr)]; + char dummy50[sizeof(StructureDefinition::Ptr)]; // Type - char dummy50[sizeof(Type::Ptr)]; + char dummy51[sizeof(Type::Ptr)]; // FunctionParameters // MaybeFunctionParameters // Types - char dummy51[sizeof(Types::Ptr)]; + char dummy52[sizeof(Types::Ptr)]; // Undefined - char dummy52[sizeof(UndefAtom::Ptr)]; + char dummy53[sizeof(UndefAtom::Ptr)]; // UniversalQuantifierExpression - char dummy53[sizeof(UniversalQuantifierExpression::Ptr)]; + char dummy54[sizeof(UniversalQuantifierExpression::Ptr)]; // Initializer // UpdateRule - char dummy54[sizeof(UpdateRule::Ptr)]; + char dummy55[sizeof(UpdateRule::Ptr)]; // Boolean // String @@ -484,11 +489,11 @@ namespace libcasm_fe { // IntegerNumber // FloatingNumber // RationalNumber - char dummy55[sizeof(ValueAtom::Ptr)]; + char dummy56[sizeof(ValueAtom::Ptr)]; // Variable // AttributedVariable - char dummy56[sizeof(VariableDefinition::Ptr)]; + char dummy57[sizeof(VariableDefinition::Ptr)]; // "binary" // "hexadecimal" @@ -497,7 +502,7 @@ namespace libcasm_fe { // "floating" // "string" // "identifier" - char dummy57[sizeof(std::string)]; + char dummy58[sizeof(std::string)]; }; /// Symbol semantic values. @@ -531,76 +536,79 @@ namespace libcasm_fe { DEFINED = 265, STRUCTURE = 266, FEATURE = 267, - SEQ = 268, - ENDSEQ = 269, - PAR = 270, - ENDPAR = 271, - SKIP = 272, - LET = 273, - IN = 274, - FORALL = 275, - CHOOSE = 276, - ITERATE = 277, - DO = 278, - CALL = 279, - IF = 280, - THEN = 281, - ELSE = 282, - CASE = 283, - OF = 284, - DEFAULT = 285, - HOLDS = 286, - EXISTS = 287, - WITH = 288, - UNDEF = 289, - FALSE = 290, - TRUE = 291, - AND = 292, - OR = 293, - XOR = 294, - IMPLIES = 295, - NOT = 296, - PLUS = 297, - MINUS = 298, - EQUAL = 299, - LPAREN = 300, - RPAREN = 301, - LSQPAREN = 302, - RSQPAREN = 303, - LCURPAREN = 304, - RCURPAREN = 305, - COLON = 306, - UNDERLINE = 307, - AT = 308, - COMMA = 309, - LESSER = 310, - GREATER = 311, - ASTERIX = 312, - SLASH = 313, - PERCENT = 314, - CARET = 315, - MARK = 316, - DOTDOT = 317, - DOT = 318, - MAPS = 319, - ARROW = 320, - UPDATE = 321, - NEQUAL = 322, - LESSEQ = 323, - GREATEREQ = 324, - SEQ_BRACKET = 325, - ENDSEQ_BRACKET = 326, - BINARY = 327, - HEXADECIMAL = 328, - INTEGER = 329, - RATIONAL = 330, - FLOATING = 331, - STRING = 332, - IDENTIFIER = 333, - ABSOLUTE_PATH = 334, - UPLUS = 335, - UMINUS = 336, - CALL_WITHOUT_ARGS = 337 + IMPLEMENTS = 268, + FOR = 269, + THIS = 270, + SEQ = 271, + ENDSEQ = 272, + PAR = 273, + ENDPAR = 274, + SKIP = 275, + LET = 276, + IN = 277, + FORALL = 278, + CHOOSE = 279, + ITERATE = 280, + DO = 281, + CALL = 282, + IF = 283, + THEN = 284, + ELSE = 285, + CASE = 286, + OF = 287, + DEFAULT = 288, + HOLDS = 289, + EXISTS = 290, + WITH = 291, + UNDEF = 292, + FALSE = 293, + TRUE = 294, + AND = 295, + OR = 296, + XOR = 297, + IMPLIES = 298, + NOT = 299, + PLUS = 300, + MINUS = 301, + EQUAL = 302, + LPAREN = 303, + RPAREN = 304, + LSQPAREN = 305, + RSQPAREN = 306, + LCURPAREN = 307, + RCURPAREN = 308, + COLON = 309, + UNDERLINE = 310, + AT = 311, + COMMA = 312, + LESSER = 313, + GREATER = 314, + ASTERIX = 315, + SLASH = 316, + PERCENT = 317, + CARET = 318, + MARK = 319, + DOTDOT = 320, + DOT = 321, + MAPS = 322, + ARROW = 323, + UPDATE = 324, + NEQUAL = 325, + LESSEQ = 326, + GREATEREQ = 327, + SEQ_BRACKET = 328, + ENDSEQ_BRACKET = 329, + BINARY = 330, + HEXADECIMAL = 331, + INTEGER = 332, + RATIONAL = 333, + FLOATING = 334, + STRING = 335, + IDENTIFIER = 336, + ABSOLUTE_PATH = 337, + UPLUS = 338, + UMINUS = 339, + CALL_WITHOUT_ARGS = 340 }; }; @@ -702,6 +710,8 @@ namespace libcasm_fe { basic_symbol (typename Base::kind_type t, const Identifiers::Ptr v, const location_type& l); + basic_symbol (typename Base::kind_type t, const ImplementationDefinition::Ptr v, const location_type& l); + basic_symbol (typename Base::kind_type t, const IndirectCallExpression::Ptr v, const location_type& l); basic_symbol (typename Base::kind_type t, const IterateRule::Ptr v, const location_type& l); @@ -863,6 +873,18 @@ namespace libcasm_fe { symbol_type make_FEATURE (const location_type& l); + static inline + symbol_type + make_IMPLEMENTS (const location_type& l); + + static inline + symbol_type + make_FOR (const location_type& l); + + static inline + symbol_type + make_THIS (const location_type& l); + static inline symbol_type make_SEQ (const location_type& l); @@ -1348,12 +1370,12 @@ namespace libcasm_fe { enum { yyeof_ = 0, - yylast_ = 1904, ///< Last index in yytable_. - yynnts_ = 79, ///< Number of nonterminal symbols. - yyfinal_ = 22, ///< Termination state number. + yylast_ = 1992, ///< Last index in yytable_. + yynnts_ = 82, ///< Number of nonterminal symbols. + yyfinal_ = 24, ///< Termination state number. yyterror_ = 1, yyerrcode_ = 256, - yyntokens_ = 83 ///< Number of tokens. + yyntokens_ = 86 ///< Number of tokens. }; @@ -1406,9 +1428,10 @@ namespace libcasm_fe { 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 + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85 }; - const unsigned int user_token_number_max_ = 337; + const unsigned int user_token_number_max_ = 340; const token_number_type undef_token_ = 2; if (static_cast(t) <= yyeof_) @@ -1441,259 +1464,265 @@ namespace libcasm_fe { { switch (other.type_get ()) { - case 158: // Attribute + case 164: // Attribute value.copy< Attribute::Ptr > (other.value); break; - case 159: // Attributes + case 165: // Attributes value.copy< Attributes::Ptr > (other.value); break; - case 160: // BasicAttribute + case 166: // BasicAttribute value.copy< BasicAttribute::Ptr > (other.value); break; - case 114: // BasicType + case 120: // BasicType value.copy< BasicType::Ptr > (other.value); break; - case 154: // BlockRule + case 160: // BlockRule value.copy< BlockRule::Ptr > (other.value); break; - case 157: // CallRule + case 163: // CallRule value.copy< CallRule::Ptr > (other.value); break; - case 148: // CaseLabel + case 154: // CaseLabel value.copy< Case::Ptr > (other.value); break; - case 147: // CaseRule + case 153: // CaseRule value.copy< CaseRule::Ptr > (other.value); break; - case 149: // CaseLabels + case 155: // CaseLabels value.copy< Cases::Ptr > (other.value); break; - case 139: // ChooseExpression + case 145: // ChooseExpression value.copy< ChooseExpression::Ptr > (other.value); break; - case 152: // ChooseRule + case 158: // ChooseRule value.copy< ChooseRule::Ptr > (other.value); break; - case 115: // ComposedType + case 121: // ComposedType value.copy< ComposedType::Ptr > (other.value); break; - case 138: // ConditionalExpression + case 144: // ConditionalExpression value.copy< ConditionalExpression::Ptr > (other.value); break; - case 146: // ConditionalRule + case 152: // ConditionalRule value.copy< ConditionalRule::Ptr > (other.value); break; - case 104: // DeclarationDefinition + case 110: // DeclarationDefinition value.copy< DeclarationDefinition::Ptr > (other.value); break; - case 85: // Definition - case 86: // AttributedDefinition - case 102: // FeatureDeclarationOrDefinition + case 88: // Definition + case 89: // AttributedDefinition + case 105: // FeatureDeclarationOrDefinition + case 108: // ImplementationDefinitionDefinition value.copy< Definition::Ptr > (other.value); break; - case 87: // Definitions - case 103: // FeatureDeclarationsAndDefinitions + case 90: // Definitions + case 106: // FeatureDeclarationsAndDefinitions + case 109: // ImplementationDefinitionDefinitions value.copy< Definitions::Ptr > (other.value); break; - case 98: // DerivedDefinition + case 101: // DerivedDefinition value.copy< DerivedDefinition::Ptr > (other.value); break; - case 135: // DirectCallExpression + case 141: // DirectCallExpression value.copy< DirectCallExpression::Ptr > (other.value); break; - case 99: // EnumerationDefinition + case 102: // EnumerationDefinition value.copy< EnumerationDefinition::Ptr > (other.value); break; - case 141: // ExistentialQuantifierExpression + case 147: // ExistentialQuantifierExpression value.copy< ExistentialQuantifierExpression::Ptr > (other.value); break; - case 91: // MaybeDefined - case 119: // Atom - case 128: // Term - case 129: // Expression + case 94: // MaybeDefined + case 125: // Atom + case 134: // Term + case 135: // Expression value.copy< Expression::Ptr > (other.value); break; - case 161: // ExpressionAttribute + case 167: // ExpressionAttribute value.copy< ExpressionAttribute::Ptr > (other.value); break; - case 132: // Terms - case 133: // Arguments - case 134: // TwoOrMoreArguments + case 138: // Terms + case 139: // Arguments + case 140: // TwoOrMoreArguments value.copy< Expressions::Ptr > (other.value); break; - case 101: // FeatureDefinition + case 104: // FeatureDefinition value.copy< FeatureDefinition::Ptr > (other.value); break; - case 117: // FixedSizedType + case 123: // FixedSizedType value.copy< FixedSizedType::Ptr > (other.value); break; - case 151: // ForallRule + case 157: // ForallRule value.copy< ForallRule::Ptr > (other.value); break; - case 88: // FunctionDefinition - case 94: // ProgramFunctionDefinition + case 91: // FunctionDefinition + case 97: // ProgramFunctionDefinition value.copy< FunctionDefinition::Ptr > (other.value); break; - case 89: // FunctionDefinitions + case 92: // FunctionDefinitions value.copy< FunctionDefinitions::Ptr > (other.value); break; - case 105: // Identifier + case 111: // Identifier value.copy< Identifier::Ptr > (other.value); break; - case 108: // IdentifierPath + case 114: // IdentifierPath value.copy< IdentifierPath::Ptr > (other.value); break; - case 106: // Identifiers - case 107: // DotSeparatedIdentifiers + case 112: // Identifiers + case 113: // DotSeparatedIdentifiers value.copy< Identifiers::Ptr > (other.value); break; - case 136: // IndirectCallExpression + case 107: // ImplementationDefinition + value.copy< ImplementationDefinition::Ptr > (other.value); + break; + + case 142: // IndirectCallExpression value.copy< IndirectCallExpression::Ptr > (other.value); break; - case 153: // IterateRule + case 159: // IterateRule value.copy< IterateRule::Ptr > (other.value); break; - case 137: // LetExpression + case 143: // LetExpression value.copy< LetExpression::Ptr > (other.value); break; - case 150: // LetRule + case 156: // LetRule value.copy< LetRule::Ptr > (other.value); break; - case 131: // List + case 137: // List value.copy< ListExpression::Ptr > (other.value); break; - case 90: // MaybeInitially - case 96: // Initializers - case 97: // MaybeInitializers + case 93: // MaybeInitially + case 99: // Initializers + case 100: // MaybeInitializers value.copy< NodeList< UpdateRule >::Ptr > (other.value); break; - case 111: // Parameters - case 112: // MaybeParameters + case 117: // Parameters + case 118: // MaybeParameters value.copy< NodeList< VariableDefinition >::Ptr > (other.value); break; - case 130: // Range + case 136: // Range value.copy< RangeExpression::Ptr > (other.value); break; - case 127: // Reference + case 133: // Reference value.copy< ReferenceAtom::Ptr > (other.value); break; - case 116: // RelationType + case 122: // RelationType value.copy< RelationType::Ptr > (other.value); break; - case 143: // Rule + case 149: // Rule value.copy< Rule::Ptr > (other.value); break; - case 142: // RuleDefinition + case 148: // RuleDefinition value.copy< RuleDefinition::Ptr > (other.value); break; - case 144: // Rules + case 150: // Rules value.copy< Rules::Ptr > (other.value); break; - case 155: // SequenceRule + case 161: // SequenceRule value.copy< SequenceRule::Ptr > (other.value); break; - case 145: // SkipRule + case 151: // SkipRule value.copy< SkipRule::Ptr > (other.value); break; - case 84: // Specification + case 87: // Specification value.copy< Specification::Ptr > (other.value); break; - case 100: // StructureDefinition + case 103: // StructureDefinition value.copy< StructureDefinition::Ptr > (other.value); break; - case 113: // Type + case 119: // Type value.copy< Type::Ptr > (other.value); break; - case 92: // FunctionParameters - case 93: // MaybeFunctionParameters - case 118: // Types + case 95: // FunctionParameters + case 96: // MaybeFunctionParameters + case 124: // Types value.copy< Types::Ptr > (other.value); break; - case 120: // Undefined + case 126: // Undefined value.copy< UndefAtom::Ptr > (other.value); break; - case 140: // UniversalQuantifierExpression + case 146: // UniversalQuantifierExpression value.copy< UniversalQuantifierExpression::Ptr > (other.value); break; - case 95: // Initializer - case 156: // UpdateRule + case 98: // Initializer + case 162: // UpdateRule value.copy< UpdateRule::Ptr > (other.value); break; - case 121: // Boolean - case 122: // String - case 123: // BitNumber - case 124: // IntegerNumber - case 125: // FloatingNumber - case 126: // RationalNumber + case 127: // Boolean + case 128: // String + case 129: // BitNumber + case 130: // IntegerNumber + case 131: // FloatingNumber + case 132: // RationalNumber value.copy< ValueAtom::Ptr > (other.value); break; - case 109: // Variable - case 110: // AttributedVariable + case 115: // Variable + case 116: // AttributedVariable value.copy< VariableDefinition::Ptr > (other.value); break; - case 72: // "binary" - case 73: // "hexadecimal" - case 74: // "integer" - case 75: // "rational" - case 76: // "floating" - case 77: // "string" - case 78: // "identifier" + case 75: // "binary" + case 76: // "hexadecimal" + case 77: // "integer" + case 78: // "rational" + case 79: // "floating" + case 80: // "string" + case 81: // "identifier" value.copy< std::string > (other.value); break; @@ -1714,259 +1743,265 @@ namespace libcasm_fe { (void) v; switch (this->type_get ()) { - case 158: // Attribute + case 164: // Attribute value.copy< Attribute::Ptr > (v); break; - case 159: // Attributes + case 165: // Attributes value.copy< Attributes::Ptr > (v); break; - case 160: // BasicAttribute + case 166: // BasicAttribute value.copy< BasicAttribute::Ptr > (v); break; - case 114: // BasicType + case 120: // BasicType value.copy< BasicType::Ptr > (v); break; - case 154: // BlockRule + case 160: // BlockRule value.copy< BlockRule::Ptr > (v); break; - case 157: // CallRule + case 163: // CallRule value.copy< CallRule::Ptr > (v); break; - case 148: // CaseLabel + case 154: // CaseLabel value.copy< Case::Ptr > (v); break; - case 147: // CaseRule + case 153: // CaseRule value.copy< CaseRule::Ptr > (v); break; - case 149: // CaseLabels + case 155: // CaseLabels value.copy< Cases::Ptr > (v); break; - case 139: // ChooseExpression + case 145: // ChooseExpression value.copy< ChooseExpression::Ptr > (v); break; - case 152: // ChooseRule + case 158: // ChooseRule value.copy< ChooseRule::Ptr > (v); break; - case 115: // ComposedType + case 121: // ComposedType value.copy< ComposedType::Ptr > (v); break; - case 138: // ConditionalExpression + case 144: // ConditionalExpression value.copy< ConditionalExpression::Ptr > (v); break; - case 146: // ConditionalRule + case 152: // ConditionalRule value.copy< ConditionalRule::Ptr > (v); break; - case 104: // DeclarationDefinition + case 110: // DeclarationDefinition value.copy< DeclarationDefinition::Ptr > (v); break; - case 85: // Definition - case 86: // AttributedDefinition - case 102: // FeatureDeclarationOrDefinition + case 88: // Definition + case 89: // AttributedDefinition + case 105: // FeatureDeclarationOrDefinition + case 108: // ImplementationDefinitionDefinition value.copy< Definition::Ptr > (v); break; - case 87: // Definitions - case 103: // FeatureDeclarationsAndDefinitions + case 90: // Definitions + case 106: // FeatureDeclarationsAndDefinitions + case 109: // ImplementationDefinitionDefinitions value.copy< Definitions::Ptr > (v); break; - case 98: // DerivedDefinition + case 101: // DerivedDefinition value.copy< DerivedDefinition::Ptr > (v); break; - case 135: // DirectCallExpression + case 141: // DirectCallExpression value.copy< DirectCallExpression::Ptr > (v); break; - case 99: // EnumerationDefinition + case 102: // EnumerationDefinition value.copy< EnumerationDefinition::Ptr > (v); break; - case 141: // ExistentialQuantifierExpression + case 147: // ExistentialQuantifierExpression value.copy< ExistentialQuantifierExpression::Ptr > (v); break; - case 91: // MaybeDefined - case 119: // Atom - case 128: // Term - case 129: // Expression + case 94: // MaybeDefined + case 125: // Atom + case 134: // Term + case 135: // Expression value.copy< Expression::Ptr > (v); break; - case 161: // ExpressionAttribute + case 167: // ExpressionAttribute value.copy< ExpressionAttribute::Ptr > (v); break; - case 132: // Terms - case 133: // Arguments - case 134: // TwoOrMoreArguments + case 138: // Terms + case 139: // Arguments + case 140: // TwoOrMoreArguments value.copy< Expressions::Ptr > (v); break; - case 101: // FeatureDefinition + case 104: // FeatureDefinition value.copy< FeatureDefinition::Ptr > (v); break; - case 117: // FixedSizedType + case 123: // FixedSizedType value.copy< FixedSizedType::Ptr > (v); break; - case 151: // ForallRule + case 157: // ForallRule value.copy< ForallRule::Ptr > (v); break; - case 88: // FunctionDefinition - case 94: // ProgramFunctionDefinition + case 91: // FunctionDefinition + case 97: // ProgramFunctionDefinition value.copy< FunctionDefinition::Ptr > (v); break; - case 89: // FunctionDefinitions + case 92: // FunctionDefinitions value.copy< FunctionDefinitions::Ptr > (v); break; - case 105: // Identifier + case 111: // Identifier value.copy< Identifier::Ptr > (v); break; - case 108: // IdentifierPath + case 114: // IdentifierPath value.copy< IdentifierPath::Ptr > (v); break; - case 106: // Identifiers - case 107: // DotSeparatedIdentifiers + case 112: // Identifiers + case 113: // DotSeparatedIdentifiers value.copy< Identifiers::Ptr > (v); break; - case 136: // IndirectCallExpression + case 107: // ImplementationDefinition + value.copy< ImplementationDefinition::Ptr > (v); + break; + + case 142: // IndirectCallExpression value.copy< IndirectCallExpression::Ptr > (v); break; - case 153: // IterateRule + case 159: // IterateRule value.copy< IterateRule::Ptr > (v); break; - case 137: // LetExpression + case 143: // LetExpression value.copy< LetExpression::Ptr > (v); break; - case 150: // LetRule + case 156: // LetRule value.copy< LetRule::Ptr > (v); break; - case 131: // List + case 137: // List value.copy< ListExpression::Ptr > (v); break; - case 90: // MaybeInitially - case 96: // Initializers - case 97: // MaybeInitializers + case 93: // MaybeInitially + case 99: // Initializers + case 100: // MaybeInitializers value.copy< NodeList< UpdateRule >::Ptr > (v); break; - case 111: // Parameters - case 112: // MaybeParameters + case 117: // Parameters + case 118: // MaybeParameters value.copy< NodeList< VariableDefinition >::Ptr > (v); break; - case 130: // Range + case 136: // Range value.copy< RangeExpression::Ptr > (v); break; - case 127: // Reference + case 133: // Reference value.copy< ReferenceAtom::Ptr > (v); break; - case 116: // RelationType + case 122: // RelationType value.copy< RelationType::Ptr > (v); break; - case 143: // Rule + case 149: // Rule value.copy< Rule::Ptr > (v); break; - case 142: // RuleDefinition + case 148: // RuleDefinition value.copy< RuleDefinition::Ptr > (v); break; - case 144: // Rules + case 150: // Rules value.copy< Rules::Ptr > (v); break; - case 155: // SequenceRule + case 161: // SequenceRule value.copy< SequenceRule::Ptr > (v); break; - case 145: // SkipRule + case 151: // SkipRule value.copy< SkipRule::Ptr > (v); break; - case 84: // Specification + case 87: // Specification value.copy< Specification::Ptr > (v); break; - case 100: // StructureDefinition + case 103: // StructureDefinition value.copy< StructureDefinition::Ptr > (v); break; - case 113: // Type + case 119: // Type value.copy< Type::Ptr > (v); break; - case 92: // FunctionParameters - case 93: // MaybeFunctionParameters - case 118: // Types + case 95: // FunctionParameters + case 96: // MaybeFunctionParameters + case 124: // Types value.copy< Types::Ptr > (v); break; - case 120: // Undefined + case 126: // Undefined value.copy< UndefAtom::Ptr > (v); break; - case 140: // UniversalQuantifierExpression + case 146: // UniversalQuantifierExpression value.copy< UniversalQuantifierExpression::Ptr > (v); break; - case 95: // Initializer - case 156: // UpdateRule + case 98: // Initializer + case 162: // UpdateRule value.copy< UpdateRule::Ptr > (v); break; - case 121: // Boolean - case 122: // String - case 123: // BitNumber - case 124: // IntegerNumber - case 125: // FloatingNumber - case 126: // RationalNumber + case 127: // Boolean + case 128: // String + case 129: // BitNumber + case 130: // IntegerNumber + case 131: // FloatingNumber + case 132: // RationalNumber value.copy< ValueAtom::Ptr > (v); break; - case 109: // Variable - case 110: // AttributedVariable + case 115: // Variable + case 116: // AttributedVariable value.copy< VariableDefinition::Ptr > (v); break; - case 72: // "binary" - case 73: // "hexadecimal" - case 74: // "integer" - case 75: // "rational" - case 76: // "floating" - case 77: // "string" - case 78: // "identifier" + case 75: // "binary" + case 76: // "hexadecimal" + case 77: // "integer" + case 78: // "rational" + case 79: // "floating" + case 80: // "string" + case 81: // "identifier" value.copy< std::string > (v); break; @@ -2209,6 +2244,13 @@ namespace libcasm_fe { , location (l) {} + template + Parser::basic_symbol::basic_symbol (typename Base::kind_type t, const ImplementationDefinition::Ptr v, const location_type& l) + : Base (t) + , value (v) + , location (l) + {} + template Parser::basic_symbol::basic_symbol (typename Base::kind_type t, const IndirectCallExpression::Ptr v, const location_type& l) : Base (t) @@ -2410,259 +2452,265 @@ namespace libcasm_fe { // Type destructor. switch (yytype) { - case 158: // Attribute + case 164: // Attribute value.template destroy< Attribute::Ptr > (); break; - case 159: // Attributes + case 165: // Attributes value.template destroy< Attributes::Ptr > (); break; - case 160: // BasicAttribute + case 166: // BasicAttribute value.template destroy< BasicAttribute::Ptr > (); break; - case 114: // BasicType + case 120: // BasicType value.template destroy< BasicType::Ptr > (); break; - case 154: // BlockRule + case 160: // BlockRule value.template destroy< BlockRule::Ptr > (); break; - case 157: // CallRule + case 163: // CallRule value.template destroy< CallRule::Ptr > (); break; - case 148: // CaseLabel + case 154: // CaseLabel value.template destroy< Case::Ptr > (); break; - case 147: // CaseRule + case 153: // CaseRule value.template destroy< CaseRule::Ptr > (); break; - case 149: // CaseLabels + case 155: // CaseLabels value.template destroy< Cases::Ptr > (); break; - case 139: // ChooseExpression + case 145: // ChooseExpression value.template destroy< ChooseExpression::Ptr > (); break; - case 152: // ChooseRule + case 158: // ChooseRule value.template destroy< ChooseRule::Ptr > (); break; - case 115: // ComposedType + case 121: // ComposedType value.template destroy< ComposedType::Ptr > (); break; - case 138: // ConditionalExpression + case 144: // ConditionalExpression value.template destroy< ConditionalExpression::Ptr > (); break; - case 146: // ConditionalRule + case 152: // ConditionalRule value.template destroy< ConditionalRule::Ptr > (); break; - case 104: // DeclarationDefinition + case 110: // DeclarationDefinition value.template destroy< DeclarationDefinition::Ptr > (); break; - case 85: // Definition - case 86: // AttributedDefinition - case 102: // FeatureDeclarationOrDefinition + case 88: // Definition + case 89: // AttributedDefinition + case 105: // FeatureDeclarationOrDefinition + case 108: // ImplementationDefinitionDefinition value.template destroy< Definition::Ptr > (); break; - case 87: // Definitions - case 103: // FeatureDeclarationsAndDefinitions + case 90: // Definitions + case 106: // FeatureDeclarationsAndDefinitions + case 109: // ImplementationDefinitionDefinitions value.template destroy< Definitions::Ptr > (); break; - case 98: // DerivedDefinition + case 101: // DerivedDefinition value.template destroy< DerivedDefinition::Ptr > (); break; - case 135: // DirectCallExpression + case 141: // DirectCallExpression value.template destroy< DirectCallExpression::Ptr > (); break; - case 99: // EnumerationDefinition + case 102: // EnumerationDefinition value.template destroy< EnumerationDefinition::Ptr > (); break; - case 141: // ExistentialQuantifierExpression + case 147: // ExistentialQuantifierExpression value.template destroy< ExistentialQuantifierExpression::Ptr > (); break; - case 91: // MaybeDefined - case 119: // Atom - case 128: // Term - case 129: // Expression + case 94: // MaybeDefined + case 125: // Atom + case 134: // Term + case 135: // Expression value.template destroy< Expression::Ptr > (); break; - case 161: // ExpressionAttribute + case 167: // ExpressionAttribute value.template destroy< ExpressionAttribute::Ptr > (); break; - case 132: // Terms - case 133: // Arguments - case 134: // TwoOrMoreArguments + case 138: // Terms + case 139: // Arguments + case 140: // TwoOrMoreArguments value.template destroy< Expressions::Ptr > (); break; - case 101: // FeatureDefinition + case 104: // FeatureDefinition value.template destroy< FeatureDefinition::Ptr > (); break; - case 117: // FixedSizedType + case 123: // FixedSizedType value.template destroy< FixedSizedType::Ptr > (); break; - case 151: // ForallRule + case 157: // ForallRule value.template destroy< ForallRule::Ptr > (); break; - case 88: // FunctionDefinition - case 94: // ProgramFunctionDefinition + case 91: // FunctionDefinition + case 97: // ProgramFunctionDefinition value.template destroy< FunctionDefinition::Ptr > (); break; - case 89: // FunctionDefinitions + case 92: // FunctionDefinitions value.template destroy< FunctionDefinitions::Ptr > (); break; - case 105: // Identifier + case 111: // Identifier value.template destroy< Identifier::Ptr > (); break; - case 108: // IdentifierPath + case 114: // IdentifierPath value.template destroy< IdentifierPath::Ptr > (); break; - case 106: // Identifiers - case 107: // DotSeparatedIdentifiers + case 112: // Identifiers + case 113: // DotSeparatedIdentifiers value.template destroy< Identifiers::Ptr > (); break; - case 136: // IndirectCallExpression + case 107: // ImplementationDefinition + value.template destroy< ImplementationDefinition::Ptr > (); + break; + + case 142: // IndirectCallExpression value.template destroy< IndirectCallExpression::Ptr > (); break; - case 153: // IterateRule + case 159: // IterateRule value.template destroy< IterateRule::Ptr > (); break; - case 137: // LetExpression + case 143: // LetExpression value.template destroy< LetExpression::Ptr > (); break; - case 150: // LetRule + case 156: // LetRule value.template destroy< LetRule::Ptr > (); break; - case 131: // List + case 137: // List value.template destroy< ListExpression::Ptr > (); break; - case 90: // MaybeInitially - case 96: // Initializers - case 97: // MaybeInitializers + case 93: // MaybeInitially + case 99: // Initializers + case 100: // MaybeInitializers value.template destroy< NodeList< UpdateRule >::Ptr > (); break; - case 111: // Parameters - case 112: // MaybeParameters + case 117: // Parameters + case 118: // MaybeParameters value.template destroy< NodeList< VariableDefinition >::Ptr > (); break; - case 130: // Range + case 136: // Range value.template destroy< RangeExpression::Ptr > (); break; - case 127: // Reference + case 133: // Reference value.template destroy< ReferenceAtom::Ptr > (); break; - case 116: // RelationType + case 122: // RelationType value.template destroy< RelationType::Ptr > (); break; - case 143: // Rule + case 149: // Rule value.template destroy< Rule::Ptr > (); break; - case 142: // RuleDefinition + case 148: // RuleDefinition value.template destroy< RuleDefinition::Ptr > (); break; - case 144: // Rules + case 150: // Rules value.template destroy< Rules::Ptr > (); break; - case 155: // SequenceRule + case 161: // SequenceRule value.template destroy< SequenceRule::Ptr > (); break; - case 145: // SkipRule + case 151: // SkipRule value.template destroy< SkipRule::Ptr > (); break; - case 84: // Specification + case 87: // Specification value.template destroy< Specification::Ptr > (); break; - case 100: // StructureDefinition + case 103: // StructureDefinition value.template destroy< StructureDefinition::Ptr > (); break; - case 113: // Type + case 119: // Type value.template destroy< Type::Ptr > (); break; - case 92: // FunctionParameters - case 93: // MaybeFunctionParameters - case 118: // Types + case 95: // FunctionParameters + case 96: // MaybeFunctionParameters + case 124: // Types value.template destroy< Types::Ptr > (); break; - case 120: // Undefined + case 126: // Undefined value.template destroy< UndefAtom::Ptr > (); break; - case 140: // UniversalQuantifierExpression + case 146: // UniversalQuantifierExpression value.template destroy< UniversalQuantifierExpression::Ptr > (); break; - case 95: // Initializer - case 156: // UpdateRule + case 98: // Initializer + case 162: // UpdateRule value.template destroy< UpdateRule::Ptr > (); break; - case 121: // Boolean - case 122: // String - case 123: // BitNumber - case 124: // IntegerNumber - case 125: // FloatingNumber - case 126: // RationalNumber + case 127: // Boolean + case 128: // String + case 129: // BitNumber + case 130: // IntegerNumber + case 131: // FloatingNumber + case 132: // RationalNumber value.template destroy< ValueAtom::Ptr > (); break; - case 109: // Variable - case 110: // AttributedVariable + case 115: // Variable + case 116: // AttributedVariable value.template destroy< VariableDefinition::Ptr > (); break; - case 72: // "binary" - case 73: // "hexadecimal" - case 74: // "integer" - case 75: // "rational" - case 76: // "floating" - case 77: // "string" - case 78: // "identifier" + case 75: // "binary" + case 76: // "hexadecimal" + case 77: // "integer" + case 78: // "rational" + case 79: // "floating" + case 80: // "string" + case 81: // "identifier" value.template destroy< std::string > (); break; @@ -2689,259 +2737,265 @@ namespace libcasm_fe { super_type::move(s); switch (this->type_get ()) { - case 158: // Attribute + case 164: // Attribute value.move< Attribute::Ptr > (s.value); break; - case 159: // Attributes + case 165: // Attributes value.move< Attributes::Ptr > (s.value); break; - case 160: // BasicAttribute + case 166: // BasicAttribute value.move< BasicAttribute::Ptr > (s.value); break; - case 114: // BasicType + case 120: // BasicType value.move< BasicType::Ptr > (s.value); break; - case 154: // BlockRule + case 160: // BlockRule value.move< BlockRule::Ptr > (s.value); break; - case 157: // CallRule + case 163: // CallRule value.move< CallRule::Ptr > (s.value); break; - case 148: // CaseLabel + case 154: // CaseLabel value.move< Case::Ptr > (s.value); break; - case 147: // CaseRule + case 153: // CaseRule value.move< CaseRule::Ptr > (s.value); break; - case 149: // CaseLabels + case 155: // CaseLabels value.move< Cases::Ptr > (s.value); break; - case 139: // ChooseExpression + case 145: // ChooseExpression value.move< ChooseExpression::Ptr > (s.value); break; - case 152: // ChooseRule + case 158: // ChooseRule value.move< ChooseRule::Ptr > (s.value); break; - case 115: // ComposedType + case 121: // ComposedType value.move< ComposedType::Ptr > (s.value); break; - case 138: // ConditionalExpression + case 144: // ConditionalExpression value.move< ConditionalExpression::Ptr > (s.value); break; - case 146: // ConditionalRule + case 152: // ConditionalRule value.move< ConditionalRule::Ptr > (s.value); break; - case 104: // DeclarationDefinition + case 110: // DeclarationDefinition value.move< DeclarationDefinition::Ptr > (s.value); break; - case 85: // Definition - case 86: // AttributedDefinition - case 102: // FeatureDeclarationOrDefinition + case 88: // Definition + case 89: // AttributedDefinition + case 105: // FeatureDeclarationOrDefinition + case 108: // ImplementationDefinitionDefinition value.move< Definition::Ptr > (s.value); break; - case 87: // Definitions - case 103: // FeatureDeclarationsAndDefinitions + case 90: // Definitions + case 106: // FeatureDeclarationsAndDefinitions + case 109: // ImplementationDefinitionDefinitions value.move< Definitions::Ptr > (s.value); break; - case 98: // DerivedDefinition + case 101: // DerivedDefinition value.move< DerivedDefinition::Ptr > (s.value); break; - case 135: // DirectCallExpression + case 141: // DirectCallExpression value.move< DirectCallExpression::Ptr > (s.value); break; - case 99: // EnumerationDefinition + case 102: // EnumerationDefinition value.move< EnumerationDefinition::Ptr > (s.value); break; - case 141: // ExistentialQuantifierExpression + case 147: // ExistentialQuantifierExpression value.move< ExistentialQuantifierExpression::Ptr > (s.value); break; - case 91: // MaybeDefined - case 119: // Atom - case 128: // Term - case 129: // Expression + case 94: // MaybeDefined + case 125: // Atom + case 134: // Term + case 135: // Expression value.move< Expression::Ptr > (s.value); break; - case 161: // ExpressionAttribute + case 167: // ExpressionAttribute value.move< ExpressionAttribute::Ptr > (s.value); break; - case 132: // Terms - case 133: // Arguments - case 134: // TwoOrMoreArguments + case 138: // Terms + case 139: // Arguments + case 140: // TwoOrMoreArguments value.move< Expressions::Ptr > (s.value); break; - case 101: // FeatureDefinition + case 104: // FeatureDefinition value.move< FeatureDefinition::Ptr > (s.value); break; - case 117: // FixedSizedType + case 123: // FixedSizedType value.move< FixedSizedType::Ptr > (s.value); break; - case 151: // ForallRule + case 157: // ForallRule value.move< ForallRule::Ptr > (s.value); break; - case 88: // FunctionDefinition - case 94: // ProgramFunctionDefinition + case 91: // FunctionDefinition + case 97: // ProgramFunctionDefinition value.move< FunctionDefinition::Ptr > (s.value); break; - case 89: // FunctionDefinitions + case 92: // FunctionDefinitions value.move< FunctionDefinitions::Ptr > (s.value); break; - case 105: // Identifier + case 111: // Identifier value.move< Identifier::Ptr > (s.value); break; - case 108: // IdentifierPath + case 114: // IdentifierPath value.move< IdentifierPath::Ptr > (s.value); break; - case 106: // Identifiers - case 107: // DotSeparatedIdentifiers + case 112: // Identifiers + case 113: // DotSeparatedIdentifiers value.move< Identifiers::Ptr > (s.value); break; - case 136: // IndirectCallExpression + case 107: // ImplementationDefinition + value.move< ImplementationDefinition::Ptr > (s.value); + break; + + case 142: // IndirectCallExpression value.move< IndirectCallExpression::Ptr > (s.value); break; - case 153: // IterateRule + case 159: // IterateRule value.move< IterateRule::Ptr > (s.value); break; - case 137: // LetExpression + case 143: // LetExpression value.move< LetExpression::Ptr > (s.value); break; - case 150: // LetRule + case 156: // LetRule value.move< LetRule::Ptr > (s.value); break; - case 131: // List + case 137: // List value.move< ListExpression::Ptr > (s.value); break; - case 90: // MaybeInitially - case 96: // Initializers - case 97: // MaybeInitializers + case 93: // MaybeInitially + case 99: // Initializers + case 100: // MaybeInitializers value.move< NodeList< UpdateRule >::Ptr > (s.value); break; - case 111: // Parameters - case 112: // MaybeParameters + case 117: // Parameters + case 118: // MaybeParameters value.move< NodeList< VariableDefinition >::Ptr > (s.value); break; - case 130: // Range + case 136: // Range value.move< RangeExpression::Ptr > (s.value); break; - case 127: // Reference + case 133: // Reference value.move< ReferenceAtom::Ptr > (s.value); break; - case 116: // RelationType + case 122: // RelationType value.move< RelationType::Ptr > (s.value); break; - case 143: // Rule + case 149: // Rule value.move< Rule::Ptr > (s.value); break; - case 142: // RuleDefinition + case 148: // RuleDefinition value.move< RuleDefinition::Ptr > (s.value); break; - case 144: // Rules + case 150: // Rules value.move< Rules::Ptr > (s.value); break; - case 155: // SequenceRule + case 161: // SequenceRule value.move< SequenceRule::Ptr > (s.value); break; - case 145: // SkipRule + case 151: // SkipRule value.move< SkipRule::Ptr > (s.value); break; - case 84: // Specification + case 87: // Specification value.move< Specification::Ptr > (s.value); break; - case 100: // StructureDefinition + case 103: // StructureDefinition value.move< StructureDefinition::Ptr > (s.value); break; - case 113: // Type + case 119: // Type value.move< Type::Ptr > (s.value); break; - case 92: // FunctionParameters - case 93: // MaybeFunctionParameters - case 118: // Types + case 95: // FunctionParameters + case 96: // MaybeFunctionParameters + case 124: // Types value.move< Types::Ptr > (s.value); break; - case 120: // Undefined + case 126: // Undefined value.move< UndefAtom::Ptr > (s.value); break; - case 140: // UniversalQuantifierExpression + case 146: // UniversalQuantifierExpression value.move< UniversalQuantifierExpression::Ptr > (s.value); break; - case 95: // Initializer - case 156: // UpdateRule + case 98: // Initializer + case 162: // UpdateRule value.move< UpdateRule::Ptr > (s.value); break; - case 121: // Boolean - case 122: // String - case 123: // BitNumber - case 124: // IntegerNumber - case 125: // FloatingNumber - case 126: // RationalNumber + case 127: // Boolean + case 128: // String + case 129: // BitNumber + case 130: // IntegerNumber + case 131: // FloatingNumber + case 132: // RationalNumber value.move< ValueAtom::Ptr > (s.value); break; - case 109: // Variable - case 110: // AttributedVariable + case 115: // Variable + case 116: // AttributedVariable value.move< VariableDefinition::Ptr > (s.value); break; - case 72: // "binary" - case 73: // "hexadecimal" - case 74: // "integer" - case 75: // "rational" - case 76: // "floating" - case 77: // "string" - case 78: // "identifier" + case 75: // "binary" + case 76: // "hexadecimal" + case 77: // "integer" + case 78: // "rational" + case 79: // "floating" + case 80: // "string" + case 81: // "identifier" value.move< std::string > (s.value); break; @@ -3008,7 +3062,7 @@ namespace libcasm_fe { 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 + 335, 336, 337, 338, 339, 340 }; return static_cast (yytoken_number_[type]); } @@ -3079,6 +3133,24 @@ namespace libcasm_fe { return symbol_type (token::FEATURE, l); } + Parser::symbol_type + Parser::make_IMPLEMENTS (const location_type& l) + { + return symbol_type (token::IMPLEMENTS, l); + } + + Parser::symbol_type + Parser::make_FOR (const location_type& l) + { + return symbol_type (token::FOR, l); + } + + Parser::symbol_type + Parser::make_THIS (const location_type& l) + { + return symbol_type (token::THIS, l); + } + Parser::symbol_type Parser::make_SEQ (const location_type& l) { @@ -3502,7 +3574,7 @@ namespace libcasm_fe { #line 31 "../../obj/src/GrammarParser.yy" // lalr1.cc:377 } // libcasm_fe -#line 3506 "GrammarParser.tab.h" // lalr1.cc:377 +#line 3578 "GrammarParser.tab.h" // lalr1.cc:377