From fce06e413e0a59d64bca198be18e614e30de580e Mon Sep 17 00:00:00 2001 From: Philipp Paulweber Date: Sun, 30 Jul 2017 01:23:50 +0200 Subject: [PATCH] Feature Definition and Declarations * added new AST feature definition node and the new syntax to define a named feature - related to ref #35 * added new AST declaration definition node (needed by feature etc.) --- src/GrammarParser.yy | 64 + src/GrammarToken.hpp | 1 + src/ast/Definition.cpp | 79 + src/ast/Definition.h | 51 + src/ast/EmptyVisitor.cpp | 8 + src/ast/EmptyVisitor.h | 2 + src/ast/Node.cpp | 8 + src/ast/Node.h | 2 + src/ast/RecursiveVisitor.cpp | 13 + src/ast/RecursiveVisitor.h | 2 + src/ast/Visitor.h | 4 + src/transform/AstDumpSourcePass.cpp | 34 + src/various/Grammar.org | 17 + src/various/GrammarLexer.cpp | 581 +- src/various/GrammarParser.cpp | 2793 +++--- src/various/GrammarParser.output | 13293 +++++++++++++------------- src/various/GrammarParser.tab.h | 963 +- 17 files changed, 9353 insertions(+), 8562 deletions(-) diff --git a/src/GrammarParser.yy b/src/GrammarParser.yy index b0340d4cb..188b763de 100644 --- a/src/GrammarParser.yy +++ b/src/GrammarParser.yy @@ -172,6 +172,10 @@ END 0 "end of file" %type RuleDefinition %type EnumerationDefinition %type StructureDefinition +%type FeatureDefinition +%type FeatureDeclarationOrDefinition +%type FeatureDeclarationsAndDefinitions +%type DeclarationDefinition // expressions %type Expression Term Atom @@ -303,6 +307,10 @@ Definition { $$ = $1; } +| FeatureDefinition + { + $$ = $1; + } | error // error recovery { $$ = nullptr; @@ -554,6 +562,62 @@ StructureDefinition ; +FeatureDefinition +: FEATURE Identifier EQUAL LCURPAREN FeatureDeclarationsAndDefinitions RCURPAREN + { + $$ = Ast::make< FeatureDefinition >( @$, $2, $5 ); + } +; + + +FeatureDeclarationOrDefinition +: DeclarationDefinition + { + $$ = $1; + } +| DerivedDefinition + { + $$ = $1; + } +| RuleDefinition + { + $$ = $1; + } +; + + +FeatureDeclarationsAndDefinitions +: FeatureDeclarationsAndDefinitions COMMA FeatureDeclarationOrDefinition + { + auto definitions = $1; + definitions->add( $3 ); + $$ = definitions; + } +| FeatureDeclarationOrDefinition + { + auto definitions = Ast::make< Definitions >( @$ ); + definitions->add( $1 ); + $$ = definitions; + } +; + + +DeclarationDefinition +: DERIVED Identifier COLON MaybeFunctionParameters MAPS Type + { + auto declaration = Ast::make< DeclarationDefinition >( @$, $2, $4, $6 ); + declaration->setKind( DeclarationDefinition::Kind::DERIVED ); + $$ = declaration; + } +| RULE Identifier COLON MaybeFunctionParameters MAPS Type + { + auto declaration = Ast::make< DeclarationDefinition >( @$, $2, $4, $6 ); + declaration->setKind( DeclarationDefinition::Kind::RULE ); + $$ = declaration; + } +; + + Identifier : IDENTIFIER { diff --git a/src/GrammarToken.hpp b/src/GrammarToken.hpp index 1ff842dd5..bde87c907 100644 --- a/src/GrammarToken.hpp +++ b/src/GrammarToken.hpp @@ -36,6 +36,7 @@ INITIALLY "initially" { return Parser::make_INITIALLY(loc); } DEFINED "defined" { return Parser::make_DEFINED(loc); } STRUCTURE "structure" { return Parser::make_STRUCTURE(loc); } +FEATURE "feature" { return Parser::make_FEATURE(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 1cf8c6c60..2e68a3137 100644 --- a/src/ast/Definition.cpp +++ b/src/ast/Definition.cpp @@ -330,6 +330,85 @@ void StructureDefinition::accept( Visitor& visitor ) visitor.visit( *this ); } +// +// +// FeatureDefinition +// + +FeatureDefinition::FeatureDefinition( + const Identifier::Ptr& identifier, const Definitions::Ptr& definitions ) +: Definition( Node::ID::FEATURE_DEFINITION, identifier ) +, m_definitions( definitions ) +{ +} + +const Definitions::Ptr& FeatureDefinition::definitions( void ) const +{ + return m_definitions; +} + +void FeatureDefinition::accept( Visitor& visitor ) +{ + visitor.visit( *this ); +} + +// +// +// DeclarationDefinition +// + +DeclarationDefinition::DeclarationDefinition( const Identifier::Ptr& identifier, + const Types::Ptr& argumentTypes, + const Type::Ptr& returnType ) +: Definition( Node::ID::DECLARATION_DEFINITION, identifier ) +, m_argumentTypes( argumentTypes ) +, m_returnType( returnType ) +{ +} + +const Types::Ptr& DeclarationDefinition::argumentTypes( void ) const +{ + return m_argumentTypes; +} + +const Type::Ptr& DeclarationDefinition::returnType( void ) const +{ + return m_returnType; +} + +void DeclarationDefinition::setKind( const Kind kind ) +{ + m_kind = kind; +} + +DeclarationDefinition::Kind DeclarationDefinition::kind( void ) const +{ + return m_kind; +} + +std::string DeclarationDefinition::kindName( void ) const +{ + switch( kind() ) + { + case DeclarationDefinition::Kind::DERIVED: + { + return "derived"; + } + case DeclarationDefinition::Kind::RULE: + { + return "rule"; + } + } + + assert( !" internal error! " ); + return std::string(); +} + +void DeclarationDefinition::accept( Visitor& visitor ) +{ + visitor.visit( *this ); +} + // // Local variables: // mode: c++ diff --git a/src/ast/Definition.h b/src/ast/Definition.h index 55c7f03e9..3c231904f 100644 --- a/src/ast/Definition.h +++ b/src/ast/Definition.h @@ -234,6 +234,57 @@ namespace libcasm_fe private: const NodeList< FunctionDefinition >::Ptr m_functions; }; + + class FeatureDefinition final : public Definition + { + public: + using Ptr = std::shared_ptr< FeatureDefinition >; + + FeatureDefinition( const Identifier::Ptr& identifier, + const Definitions::Ptr& definitions ); + + const Definitions::Ptr& definitions( void ) const; + + void accept( Visitor& visitor ) override final; + + private: + const Definitions::Ptr m_definitions; + }; + + class DeclarationDefinition final : public Definition + { + public: + using Ptr = std::shared_ptr< DeclarationDefinition >; + + enum class Kind + { + DERIVED = 1, + RULE + }; + + DeclarationDefinition( const Identifier::Ptr& identifier, + const Types::Ptr& argumentTypes, + const Type::Ptr& returnType ); + + const Types::Ptr& argumentTypes( void ) const; + + const Type::Ptr& returnType( void ) const; + + void setKind( const Kind kind ); + + Kind kind( void ) const; + + std::string kindName( void ) const; + + void accept( Visitor& visitor ) override final; + + private: + const Types::Ptr m_argumentTypes; + const Type::Ptr m_returnType; + Kind m_kind; + }; + + using DeclarationDefinitions = NodeList< DeclarationDefinition >; } } diff --git a/src/ast/EmptyVisitor.cpp b/src/ast/EmptyVisitor.cpp index fc531b5af..a49f83517 100644 --- a/src/ast/EmptyVisitor.cpp +++ b/src/ast/EmptyVisitor.cpp @@ -58,6 +58,14 @@ void EmptyVisitor::visit( StructureDefinition& ) { } +void EmptyVisitor::visit( FeatureDefinition& ) +{ +} + +void EmptyVisitor::visit( DeclarationDefinition& ) +{ +} + void EmptyVisitor::visit( ValueAtom& ) { } diff --git a/src/ast/EmptyVisitor.h b/src/ast/EmptyVisitor.h index e84b7f96d..9209e106a 100644 --- a/src/ast/EmptyVisitor.h +++ b/src/ast/EmptyVisitor.h @@ -43,6 +43,8 @@ namespace libcasm_fe void visit( RuleDefinition& node ) override; void visit( EnumerationDefinition& node ) override; void visit( StructureDefinition& node ) override; + void visit( FeatureDefinition& node ) override; + void visit( DeclarationDefinition& node ) override; void visit( ValueAtom& node ) override; void visit( ReferenceAtom& node ) override; diff --git a/src/ast/Node.cpp b/src/ast/Node.cpp index 819374f20..46459f63d 100644 --- a/src/ast/Node.cpp +++ b/src/ast/Node.cpp @@ -81,6 +81,14 @@ std::string Node::description( void ) const { return "structure"; } + case ID::FEATURE_DEFINITION: + { + return "feature"; + } + case ID::DECLARATION_DEFINITION: + { + return "declaration"; + } case ID::VALUE_ATOM: { return "value"; diff --git a/src/ast/Node.h b/src/ast/Node.h index d0f29efe7..0d69ad7f8 100644 --- a/src/ast/Node.h +++ b/src/ast/Node.h @@ -56,6 +56,8 @@ namespace libcasm_fe RULE_DEFINITION, ENUMERATION_DEFINITION, STRUCTURE_DEFINITION, + FEATURE_DEFINITION, + DECLARATION_DEFINITION, // expressions VALUE_ATOM, diff --git a/src/ast/RecursiveVisitor.cpp b/src/ast/RecursiveVisitor.cpp index 78560da02..431f8b276 100644 --- a/src/ast/RecursiveVisitor.cpp +++ b/src/ast/RecursiveVisitor.cpp @@ -84,6 +84,19 @@ void RecursiveVisitor::visit( StructureDefinition& node ) node.functions()->accept( *this ); } +void RecursiveVisitor::visit( FeatureDefinition& node ) +{ + node.identifier()->accept( *this ); + node.definitions()->accept( *this ); +} + +void RecursiveVisitor::visit( DeclarationDefinition& node ) +{ + node.identifier()->accept( *this ); + node.argumentTypes()->accept( *this ); + node.returnType()->accept( *this ); +} + void RecursiveVisitor::visit( ValueAtom& node ) { } diff --git a/src/ast/RecursiveVisitor.h b/src/ast/RecursiveVisitor.h index ba4d3c3b3..65c536d5d 100644 --- a/src/ast/RecursiveVisitor.h +++ b/src/ast/RecursiveVisitor.h @@ -43,6 +43,8 @@ namespace libcasm_fe void visit( RuleDefinition& node ) override; void visit( EnumerationDefinition& node ) override; void visit( StructureDefinition& node ) override; + void visit( FeatureDefinition& node ) override; + void visit( DeclarationDefinition& node ) override; void visit( ValueAtom& node ) override; void visit( ReferenceAtom& node ) override; diff --git a/src/ast/Visitor.h b/src/ast/Visitor.h index 9cae081b4..d640cbf39 100644 --- a/src/ast/Visitor.h +++ b/src/ast/Visitor.h @@ -38,6 +38,8 @@ namespace libcasm_fe class RuleDefinition; class EnumerationDefinition; class StructureDefinition; + class FeatureDefinition; + class DeclarationDefinition; class ValueAtom; class ReferenceAtom; @@ -96,6 +98,8 @@ namespace libcasm_fe virtual void visit( RuleDefinition& node ) = 0; virtual void visit( EnumerationDefinition& node ) = 0; virtual void visit( StructureDefinition& node ) = 0; + virtual void visit( FeatureDefinition& node ) = 0; + virtual void visit( DeclarationDefinition& node ) = 0; virtual void visit( ValueAtom& node ) = 0; virtual void visit( ReferenceAtom& node ) = 0; diff --git a/src/transform/AstDumpSourcePass.cpp b/src/transform/AstDumpSourcePass.cpp index a40a46ede..67b437ff9 100644 --- a/src/transform/AstDumpSourcePass.cpp +++ b/src/transform/AstDumpSourcePass.cpp @@ -131,6 +131,8 @@ class AstDumpSourceVisitor final : public Visitor void visit( RuleDefinition& node ) override; void visit( EnumerationDefinition& node ) override; void visit( StructureDefinition& node ) override; + void visit( FeatureDefinition& node ) override; + void visit( DeclarationDefinition& node ) override; void visit( ValueAtom& node ) override; void visit( ReferenceAtom& node ) override; @@ -337,6 +339,38 @@ void AstDumpSourceVisitor::visit( StructureDefinition& node ) m_stream << "}"; } +void AstDumpSourceVisitor::visit( FeatureDefinition& node ) +{ + m_stream << "feature "; + node.identifier()->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 << " "; + node.identifier()->accept( *this ); + m_stream << " : "; + bool firstArgType = true; + for( auto& t : *node.argumentTypes() ) + { + if( not firstArgType ) + { + m_stream << " * "; + } + t->accept( *this ); + firstArgType = false; + } + m_stream << " -> "; + node.returnType()->accept( *this ); +} + void AstDumpSourceVisitor::visit( ValueAtom& node ) { m_stream << node.value()->name(); diff --git a/src/various/Grammar.org b/src/various/Grammar.org index fff3e8228..289464fdc 100644 --- a/src/various/Grammar.org +++ b/src/various/Grammar.org @@ -8,6 +8,7 @@ Definition | RuleDefinition | EnumerationDefinition | StructureDefinition +| FeatureDefinition | error // error recovery AttributedDefinition @@ -68,6 +69,22 @@ EnumerationDefinition StructureDefinition : STRUCTURE Identifier EQUAL LCURPAREN FunctionDefinitions RCURPAREN +FeatureDefinition +: FEATURE Identifier EQUAL LCURPAREN FeatureDeclarationsAndDefinitions RCURPAREN + +FeatureDeclarationOrDefinition +: DeclarationDefinition +| DerivedDefinition +| RuleDefinition + +FeatureDeclarationsAndDefinitions +: FeatureDeclarationsAndDefinitions COMMA FeatureDeclarationOrDefinition +| FeatureDeclarationOrDefinition + +DeclarationDefinition +: DERIVED Identifier COLON MaybeFunctionParameters MAPS Type +| RULE Identifier COLON MaybeFunctionParameters MAPS Type + Identifier : IDENTIFIER | IN // allow in keyword as identifier diff --git a/src/various/GrammarLexer.cpp b/src/various/GrammarLexer.cpp index fa079101d..1d89247f0 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 93 -#define YY_END_OF_BUFFER 94 +#define YY_NUM_RULES 94 +#define YY_END_OF_BUFFER 95 /* This struct is not used in this scanner, but its presence is necessary. */ struct yy_trans_info @@ -331,35 +331,35 @@ struct yy_trans_info flex_int32_t yy_verify; flex_int32_t yy_nxt; }; -static const flex_int16_t yy_accept[244] = +static const flex_int16_t yy_accept[250] = { 0, - 0, 0, 0, 0, 0, 0, 85, 85, 94, 92, - 75, 76, 92, 84, 61, 63, 47, 48, 59, 44, - 56, 45, 65, 60, 4, 4, 53, 57, 46, 58, - 55, 74, 74, 49, 50, 62, 54, 74, 74, 74, - 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, - 74, 74, 74, 74, 51, 92, 52, 78, 79, 83, - 82, 83, 83, 85, 86, 91, 93, 75, 76, 69, - 66, 64, 80, 77, 4, 0, 4, 0, 0, 0, - 68, 70, 67, 71, 74, 74, 74, 74, 74, 74, - 25, 74, 74, 74, 74, 74, 74, 74, 27, 74, - - 21, 74, 74, 74, 31, 40, 74, 74, 74, 74, - 74, 74, 74, 74, 74, 74, 72, 73, 83, 83, - 81, 85, 89, 90, 87, 88, 4, 5, 1, 3, - 2, 74, 39, 74, 74, 74, 74, 74, 74, 74, - 74, 74, 74, 74, 74, 74, 74, 74, 74, 20, - 43, 17, 74, 15, 74, 74, 74, 74, 74, 74, - 41, 0, 1, 1, 3, 0, 3, 2, 2, 6, - 26, 30, 74, 74, 74, 74, 29, 74, 74, 9, - 74, 74, 74, 74, 74, 74, 7, 74, 10, 19, - 74, 28, 38, 74, 35, 0, 5, 3, 74, 74, - - 74, 74, 74, 74, 74, 37, 74, 74, 33, 74, - 74, 74, 74, 36, 3, 3, 23, 74, 74, 74, - 18, 16, 34, 22, 74, 74, 74, 74, 74, 32, - 13, 8, 74, 42, 74, 24, 74, 11, 74, 74, - 12, 14, 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 } ; static const YY_CHAR yy_ec[256] = @@ -405,71 +405,71 @@ static const YY_CHAR yy_meta[65] = 7, 1, 1, 1 } ; -static const flex_int16_t yy_base[252] = +static const flex_int16_t yy_base[258] = { 0, - 0, 0, 361, 360, 62, 64, 66, 68, 362, 365, - 74, 358, 338, 365, 365, 365, 365, 365, 365, 365, - 365, 336, 343, 66, 97, 71, 335, 334, 332, 332, - 365, 0, 328, 365, 365, 365, 0, 302, 40, 40, - 46, 30, 300, 51, 307, 298, 49, 308, 290, 66, - 54, 296, 299, 293, 280, 278, 365, 365, 365, 337, - 365, 336, 323, 0, 365, 365, 111, 116, 335, 365, - 365, 365, 365, 365, 116, 108, 122, 80, 125, 0, - 365, 365, 365, 365, 0, 304, 294, 73, 284, 92, - 0, 279, 90, 287, 284, 277, 280, 281, 0, 276, - - 281, 283, 269, 268, 0, 0, 269, 274, 268, 274, - 265, 275, 260, 274, 259, 260, 365, 365, 309, 308, - 365, 0, 365, 365, 365, 365, 137, 131, 145, 160, - 303, 279, 0, 261, 265, 256, 112, 260, 262, 114, - 255, 248, 247, 261, 259, 257, 250, 241, 242, 0, - 0, 0, 252, 0, 242, 236, 242, 248, 247, 244, - 0, 168, 173, 175, 180, 153, 186, 280, 279, 0, - 0, 0, 231, 228, 234, 225, 0, 242, 238, 0, - 224, 236, 230, 221, 221, 229, 228, 233, 0, 0, - 231, 0, 0, 227, 0, 189, 192, 204, 227, 220, - - 219, 218, 203, 201, 165, 0, 171, 171, 0, 173, - 174, 157, 145, 0, 207, 210, 0, 144, 153, 147, - 0, 0, 0, 0, 133, 120, 125, 122, 107, 0, - 0, 0, 109, 0, 90, 0, 57, 0, 49, 49, - 0, 0, 365, 229, 236, 243, 245, 252, 259, 78, - 263 + 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 } ; -static const flex_int16_t yy_def[252] = +static const flex_int16_t yy_def[258] = { 0, - 243, 1, 244, 244, 245, 245, 246, 246, 243, 243, - 243, 243, 243, 243, 243, 243, 243, 243, 243, 243, - 243, 243, 243, 243, 243, 243, 243, 243, 243, 243, - 243, 247, 247, 243, 243, 243, 247, 247, 247, 247, - 247, 247, 247, 247, 247, 247, 247, 247, 247, 247, - 247, 247, 247, 247, 243, 243, 243, 243, 243, 248, - 243, 248, 243, 249, 243, 243, 243, 243, 243, 243, - 243, 243, 243, 243, 243, 243, 243, 243, 243, 250, - 243, 243, 243, 243, 247, 247, 247, 247, 247, 247, - 247, 247, 247, 247, 247, 247, 247, 247, 247, 247, - - 247, 247, 247, 247, 247, 247, 247, 247, 247, 247, - 247, 247, 247, 247, 247, 247, 243, 243, 248, 248, - 243, 249, 243, 243, 243, 243, 243, 243, 243, 243, - 251, 247, 247, 247, 247, 247, 247, 247, 247, 247, - 247, 247, 247, 247, 247, 247, 247, 247, 247, 247, - 247, 247, 247, 247, 247, 247, 247, 247, 247, 247, - 247, 243, 243, 243, 243, 243, 243, 251, 251, 247, - 247, 247, 247, 247, 247, 247, 247, 247, 247, 247, - 247, 247, 247, 247, 247, 247, 247, 247, 247, 247, - 247, 247, 247, 247, 247, 243, 243, 243, 247, 247, - - 247, 247, 247, 247, 247, 247, 247, 247, 247, 247, - 247, 247, 247, 247, 243, 243, 247, 247, 247, 247, - 247, 247, 247, 247, 247, 247, 247, 247, 247, 247, - 247, 247, 247, 247, 247, 247, 247, 247, 247, 247, - 247, 247, 0, 243, 243, 243, 243, 243, 243, 243, - 243 + 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 } ; -static const flex_int16_t yy_nxt[430] = +static const flex_int16_t yy_nxt[436] = { 0, 10, 11, 12, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 26, 27, @@ -477,50 +477,51 @@ static const flex_int16_t yy_nxt[430] = 32, 32, 32, 32, 34, 10, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 32, 45, 32, 46, 47, 48, 32, 49, 50, 51, 52, 32, 53, 54, - 32, 55, 56, 57, 61, 62, 61, 62, 65, 95, + 32, 55, 56, 57, 61, 62, 61, 62, 65, 132, 65, 66, 63, 66, 63, 68, 73, 68, 75, 88, - 96, 74, 90, 131, 89, 76, 97, 77, 77, 77, - 91, 242, 105, 92, 99, 93, 129, 129, 112, 100, - - 101, 67, 106, 67, 75, 94, 102, 113, 109, 241, - 240, 76, 110, 77, 77, 77, 123, 68, 124, 68, - 134, 111, 78, 75, 128, 128, 128, 135, 79, 75, - 80, 140, 127, 127, 127, 137, 76, 239, 77, 77, - 77, 130, 130, 130, 75, 138, 141, 128, 128, 128, - 79, 174, 163, 127, 127, 127, 80, 175, 238, 162, - 125, 164, 164, 237, 236, 178, 126, 165, 179, 198, - 198, 198, 235, 162, 234, 166, 167, 167, 167, 196, - 163, 196, 163, 233, 197, 197, 197, 165, 232, 164, - 164, 164, 164, 165, 231, 166, 167, 167, 167, 230, - - 229, 166, 167, 167, 167, 197, 197, 197, 197, 197, - 197, 215, 228, 227, 215, 226, 225, 215, 224, 223, - 216, 216, 216, 216, 216, 216, 216, 216, 216, 58, + 95, 74, 90, 96, 89, 76, 106, 77, 77, 77, + 91, 97, 138, 92, 100, 93, 107, 98, 113, 101, + + 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, 119, 222, 119, 119, 221, 119, 119, 122, - 220, 219, 122, 122, 122, 122, 169, 218, 169, 217, - 214, 213, 212, 211, 210, 209, 208, 207, 206, 205, - 204, 203, 202, 201, 200, 199, 168, 168, 195, 194, - 193, 192, 191, 190, 189, 188, 187, 186, 185, 184, - - 183, 182, 181, 180, 177, 176, 173, 172, 171, 170, - 168, 120, 120, 161, 160, 159, 158, 157, 156, 155, - 154, 153, 152, 151, 150, 149, 148, 147, 146, 145, - 144, 143, 142, 139, 136, 133, 132, 69, 121, 120, - 120, 118, 117, 116, 115, 114, 108, 107, 104, 103, - 98, 87, 86, 84, 83, 82, 81, 72, 71, 70, - 69, 243, 59, 59, 9, 243, 243, 243, 243, 243, - 243, 243, 243, 243, 243, 243, 243, 243, 243, 243, - 243, 243, 243, 243, 243, 243, 243, 243, 243, 243, - 243, 243, 243, 243, 243, 243, 243, 243, 243, 243, - - 243, 243, 243, 243, 243, 243, 243, 243, 243, 243, - 243, 243, 243, 243, 243, 243, 243, 243, 243, 243, - 243, 243, 243, 243, 243, 243, 243, 243, 243 + 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 } ; -static const flex_int16_t yy_chk[430] = +static const flex_int16_t yy_chk[436] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -528,47 +529,48 @@ static const flex_int16_t yy_chk[430] = 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 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, 42, + 1, 1, 1, 1, 5, 5, 6, 6, 7, 256, 8, 7, 5, 8, 6, 11, 24, 11, 26, 39, - 42, 24, 40, 250, 39, 26, 42, 26, 26, 26, - 40, 240, 47, 41, 44, 41, 78, 78, 51, 44, + 42, 24, 40, 42, 39, 26, 47, 26, 26, 26, + 40, 42, 90, 41, 44, 41, 47, 42, 51, 44, - 44, 7, 47, 8, 25, 41, 44, 51, 50, 239, - 237, 25, 50, 25, 25, 25, 67, 68, 67, 68, + 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, 90, 77, 235, 77, 77, - 77, 79, 79, 79, 127, 90, 93, 128, 128, 128, - 25, 137, 129, 127, 127, 127, 25, 137, 233, 128, - 67, 129, 129, 229, 228, 140, 67, 130, 140, 166, - 166, 166, 227, 128, 226, 130, 130, 130, 130, 162, - 163, 162, 164, 225, 162, 162, 162, 165, 220, 163, - 163, 164, 164, 167, 219, 165, 165, 165, 165, 218, - - 213, 167, 167, 167, 167, 196, 196, 196, 197, 197, - 197, 198, 212, 211, 215, 210, 208, 216, 207, 205, - 198, 198, 198, 215, 215, 215, 216, 216, 216, 244, - 244, 244, 244, 244, 244, 244, 245, 245, 245, 245, - 245, 245, 245, 246, 246, 246, 246, 246, 246, 246, - 247, 247, 248, 204, 248, 248, 203, 248, 248, 249, - 202, 201, 249, 249, 249, 249, 251, 200, 251, 199, - 194, 191, 188, 187, 186, 185, 184, 183, 182, 181, - 179, 178, 176, 175, 174, 173, 169, 168, 160, 159, - 158, 157, 156, 155, 153, 149, 148, 147, 146, 145, - - 144, 143, 142, 141, 139, 138, 136, 135, 134, 132, - 131, 120, 119, 116, 115, 114, 113, 112, 111, 110, - 109, 108, 107, 104, 103, 102, 101, 100, 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, 243, 243, 243, 243, 243, 243, - 243, 243, 243, 243, 243, 243, 243, 243, 243, 243, - 243, 243, 243, 243, 243, 243, 243, 243, 243, 243, - 243, 243, 243, 243, 243, 243, 243, 243, 243, 243, - - 243, 243, 243, 243, 243, 243, 243, 243, 243, 243, - 243, 243, 243, 243, 243, 243, 243, 243, 243, 243, - 243, 243, 243, 243, 243, 243, 243, 243, 243 + 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 } ; /* The intent behind this definition is that it'll catch @@ -620,11 +622,11 @@ using namespace libcasm_fe; // Code run each time a pattern is matched. #define YY_USER_ACTION loc.columns( yyleng ); -#line 623 "src/various/GrammarLexer.cpp" +#line 625 "src/various/GrammarLexer.cpp" /* %option debug */ #define YY_NO_INPUT 1 -#line 627 "src/various/GrammarLexer.cpp" +#line 629 "src/various/GrammarLexer.cpp" #define INITIAL 0 #define LCOMMENT 1 @@ -767,7 +769,7 @@ YY_DECL loc.step(); -#line 770 "src/various/GrammarLexer.cpp" +#line 772 "src/various/GrammarLexer.cpp" while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ { @@ -794,13 +796,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 >= 244 ) + if ( yy_current_state >= 250 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; ++yy_cp; } - while ( yy_current_state != 243 ); + while ( yy_current_state != 249 ); yy_cp = (yy_last_accepting_cpos); yy_current_state = (yy_last_accepting_state); @@ -902,338 +904,343 @@ YY_RULE_SETUP YY_BREAK case 15: YY_RULE_SETUP -#line 99 "obj/src/GrammarLexer.l" -{ return Parser::make_SEQ(loc); } +#line 98 "obj/src/GrammarLexer.l" +{ return Parser::make_FEATURE(loc); } YY_BREAK case 16: YY_RULE_SETUP #line 100 "obj/src/GrammarLexer.l" -{ return Parser::make_ENDSEQ(loc); } +{ return Parser::make_SEQ(loc); } YY_BREAK case 17: YY_RULE_SETUP #line 101 "obj/src/GrammarLexer.l" -{ return Parser::make_PAR(loc); } +{ return Parser::make_ENDSEQ(loc); } YY_BREAK case 18: YY_RULE_SETUP #line 102 "obj/src/GrammarLexer.l" -{ return Parser::make_ENDPAR(loc); } +{ return Parser::make_PAR(loc); } YY_BREAK case 19: YY_RULE_SETUP -#line 104 "obj/src/GrammarLexer.l" -{ return Parser::make_SKIP(loc); } +#line 103 "obj/src/GrammarLexer.l" +{ return Parser::make_ENDPAR(loc); } YY_BREAK case 20: YY_RULE_SETUP #line 105 "obj/src/GrammarLexer.l" -{ return Parser::make_LET(loc); } +{ return Parser::make_SKIP(loc); } YY_BREAK case 21: YY_RULE_SETUP #line 106 "obj/src/GrammarLexer.l" -{ return Parser::make_IN(loc); } +{ return Parser::make_LET(loc); } YY_BREAK case 22: YY_RULE_SETUP #line 107 "obj/src/GrammarLexer.l" -{ return Parser::make_FORALL(loc); } +{ return Parser::make_IN(loc); } YY_BREAK case 23: YY_RULE_SETUP #line 108 "obj/src/GrammarLexer.l" -{ return Parser::make_CHOOSE(loc); } +{ return Parser::make_FORALL(loc); } YY_BREAK case 24: YY_RULE_SETUP #line 109 "obj/src/GrammarLexer.l" -{ return Parser::make_ITERATE(loc); } +{ return Parser::make_CHOOSE(loc); } YY_BREAK case 25: YY_RULE_SETUP #line 110 "obj/src/GrammarLexer.l" -{ return Parser::make_DO(loc); } +{ return Parser::make_ITERATE(loc); } YY_BREAK case 26: YY_RULE_SETUP #line 111 "obj/src/GrammarLexer.l" -{ return Parser::make_CALL(loc); } +{ return Parser::make_DO(loc); } YY_BREAK case 27: YY_RULE_SETUP #line 112 "obj/src/GrammarLexer.l" -{ return Parser::make_IF(loc); } +{ return Parser::make_CALL(loc); } YY_BREAK case 28: YY_RULE_SETUP #line 113 "obj/src/GrammarLexer.l" -{ return Parser::make_THEN(loc); } +{ return Parser::make_IF(loc); } YY_BREAK case 29: YY_RULE_SETUP #line 114 "obj/src/GrammarLexer.l" -{ return Parser::make_ELSE(loc); } +{ return Parser::make_THEN(loc); } YY_BREAK case 30: YY_RULE_SETUP #line 115 "obj/src/GrammarLexer.l" -{ return Parser::make_CASE(loc); } +{ return Parser::make_ELSE(loc); } YY_BREAK case 31: YY_RULE_SETUP #line 116 "obj/src/GrammarLexer.l" -{ return Parser::make_OF(loc); } +{ return Parser::make_CASE(loc); } YY_BREAK case 32: YY_RULE_SETUP #line 117 "obj/src/GrammarLexer.l" -{ return Parser::make_DEFAULT(loc); } +{ return Parser::make_OF(loc); } YY_BREAK case 33: YY_RULE_SETUP #line 118 "obj/src/GrammarLexer.l" -{ return Parser::make_HOLDS(loc); } +{ return Parser::make_DEFAULT(loc); } YY_BREAK case 34: YY_RULE_SETUP #line 119 "obj/src/GrammarLexer.l" -{ return Parser::make_EXISTS(loc); } +{ return Parser::make_HOLDS(loc); } YY_BREAK case 35: YY_RULE_SETUP #line 120 "obj/src/GrammarLexer.l" -{ return Parser::make_WITH(loc); } +{ return Parser::make_EXISTS(loc); } YY_BREAK case 36: YY_RULE_SETUP -#line 122 "obj/src/GrammarLexer.l" -{ return Parser::make_UNDEF(loc); } +#line 121 "obj/src/GrammarLexer.l" +{ return Parser::make_WITH(loc); } YY_BREAK case 37: YY_RULE_SETUP #line 123 "obj/src/GrammarLexer.l" -{ return Parser::make_FALSE(loc); } +{ return Parser::make_UNDEF(loc); } YY_BREAK case 38: YY_RULE_SETUP #line 124 "obj/src/GrammarLexer.l" -{ return Parser::make_TRUE(loc); } +{ return Parser::make_FALSE(loc); } YY_BREAK case 39: YY_RULE_SETUP -#line 126 "obj/src/GrammarLexer.l" -{ return Parser::make_AND(loc); } +#line 125 "obj/src/GrammarLexer.l" +{ return Parser::make_TRUE(loc); } YY_BREAK case 40: YY_RULE_SETUP #line 127 "obj/src/GrammarLexer.l" -{ return Parser::make_OR(loc); } +{ return Parser::make_AND(loc); } YY_BREAK case 41: YY_RULE_SETUP #line 128 "obj/src/GrammarLexer.l" -{ return Parser::make_XOR(loc); } +{ return Parser::make_OR(loc); } YY_BREAK case 42: YY_RULE_SETUP #line 129 "obj/src/GrammarLexer.l" -{ return Parser::make_IMPLIES(loc); } +{ return Parser::make_XOR(loc); } YY_BREAK case 43: YY_RULE_SETUP #line 130 "obj/src/GrammarLexer.l" -{ return Parser::make_NOT(loc); } +{ return Parser::make_IMPLIES(loc); } YY_BREAK case 44: YY_RULE_SETUP -#line 132 "obj/src/GrammarLexer.l" -{ return Parser::make_PLUS(loc); } +#line 131 "obj/src/GrammarLexer.l" +{ return Parser::make_NOT(loc); } YY_BREAK case 45: YY_RULE_SETUP #line 133 "obj/src/GrammarLexer.l" -{ return Parser::make_MINUS(loc); } +{ return Parser::make_PLUS(loc); } YY_BREAK case 46: YY_RULE_SETUP #line 134 "obj/src/GrammarLexer.l" -{ return Parser::make_EQUAL(loc); } +{ return Parser::make_MINUS(loc); } YY_BREAK case 47: YY_RULE_SETUP #line 135 "obj/src/GrammarLexer.l" -{ return Parser::make_LPAREN(loc); } +{ return Parser::make_EQUAL(loc); } YY_BREAK case 48: YY_RULE_SETUP #line 136 "obj/src/GrammarLexer.l" -{ return Parser::make_RPAREN(loc); } +{ return Parser::make_LPAREN(loc); } YY_BREAK case 49: YY_RULE_SETUP #line 137 "obj/src/GrammarLexer.l" -{ return Parser::make_LSQPAREN(loc); } +{ return Parser::make_RPAREN(loc); } YY_BREAK case 50: YY_RULE_SETUP #line 138 "obj/src/GrammarLexer.l" -{ return Parser::make_RSQPAREN(loc); } +{ return Parser::make_LSQPAREN(loc); } YY_BREAK case 51: YY_RULE_SETUP #line 139 "obj/src/GrammarLexer.l" -{ return Parser::make_LCURPAREN(loc); } +{ return Parser::make_RSQPAREN(loc); } YY_BREAK case 52: YY_RULE_SETUP #line 140 "obj/src/GrammarLexer.l" -{ return Parser::make_RCURPAREN(loc); } +{ return Parser::make_LCURPAREN(loc); } YY_BREAK case 53: YY_RULE_SETUP #line 141 "obj/src/GrammarLexer.l" -{ return Parser::make_COLON(loc); } +{ return Parser::make_RCURPAREN(loc); } YY_BREAK case 54: YY_RULE_SETUP #line 142 "obj/src/GrammarLexer.l" -{ return Parser::make_UNDERLINE(loc); } +{ return Parser::make_COLON(loc); } YY_BREAK case 55: YY_RULE_SETUP #line 143 "obj/src/GrammarLexer.l" -{ return Parser::make_AT(loc); } +{ return Parser::make_UNDERLINE(loc); } YY_BREAK case 56: YY_RULE_SETUP #line 144 "obj/src/GrammarLexer.l" -{ return Parser::make_COMMA(loc); } +{ return Parser::make_AT(loc); } YY_BREAK case 57: YY_RULE_SETUP #line 145 "obj/src/GrammarLexer.l" -{ return Parser::make_LESSER(loc); } +{ return Parser::make_COMMA(loc); } YY_BREAK case 58: YY_RULE_SETUP #line 146 "obj/src/GrammarLexer.l" -{ return Parser::make_GREATER(loc); } +{ return Parser::make_LESSER(loc); } YY_BREAK case 59: YY_RULE_SETUP #line 147 "obj/src/GrammarLexer.l" -{ return Parser::make_ASTERIX(loc); } +{ return Parser::make_GREATER(loc); } YY_BREAK case 60: YY_RULE_SETUP #line 148 "obj/src/GrammarLexer.l" -{ return Parser::make_SLASH(loc); } +{ return Parser::make_ASTERIX(loc); } YY_BREAK case 61: YY_RULE_SETUP #line 149 "obj/src/GrammarLexer.l" -{ return Parser::make_PERCENT(loc); } +{ return Parser::make_SLASH(loc); } YY_BREAK case 62: YY_RULE_SETUP #line 150 "obj/src/GrammarLexer.l" -{ return Parser::make_CARET(loc); } +{ return Parser::make_PERCENT(loc); } YY_BREAK case 63: YY_RULE_SETUP #line 151 "obj/src/GrammarLexer.l" -{ return Parser::make_MARK(loc); } +{ return Parser::make_CARET(loc); } YY_BREAK case 64: YY_RULE_SETUP -#line 153 "obj/src/GrammarLexer.l" -{ return Parser::make_DOTDOT(loc); } +#line 152 "obj/src/GrammarLexer.l" +{ return Parser::make_MARK(loc); } YY_BREAK case 65: YY_RULE_SETUP #line 154 "obj/src/GrammarLexer.l" -{ return Parser::make_DOT(loc); } +{ return Parser::make_DOTDOT(loc); } YY_BREAK case 66: YY_RULE_SETUP #line 155 "obj/src/GrammarLexer.l" -{ return Parser::make_MAPS(loc); } +{ return Parser::make_DOT(loc); } YY_BREAK case 67: YY_RULE_SETUP #line 156 "obj/src/GrammarLexer.l" -{ return Parser::make_ARROW(loc); } +{ return Parser::make_MAPS(loc); } YY_BREAK case 68: YY_RULE_SETUP #line 157 "obj/src/GrammarLexer.l" -{ return Parser::make_UPDATE(loc); } +{ return Parser::make_ARROW(loc); } YY_BREAK case 69: YY_RULE_SETUP #line 158 "obj/src/GrammarLexer.l" -{ return Parser::make_NEQUAL(loc); } +{ return Parser::make_UPDATE(loc); } YY_BREAK case 70: YY_RULE_SETUP #line 159 "obj/src/GrammarLexer.l" -{ return Parser::make_LESSEQ(loc); } +{ return Parser::make_NEQUAL(loc); } YY_BREAK case 71: YY_RULE_SETUP #line 160 "obj/src/GrammarLexer.l" -{ return Parser::make_GREATEREQ(loc); } +{ return Parser::make_LESSEQ(loc); } YY_BREAK case 72: YY_RULE_SETUP #line 161 "obj/src/GrammarLexer.l" -{ return Parser::make_SEQ_BRACKET(loc); } +{ return Parser::make_GREATEREQ(loc); } YY_BREAK case 73: YY_RULE_SETUP #line 162 "obj/src/GrammarLexer.l" -{ return Parser::make_ENDSEQ_BRACKET(loc); } +{ return Parser::make_SEQ_BRACKET(loc); } YY_BREAK case 74: YY_RULE_SETUP -#line 166 "obj/src/GrammarLexer.l" +#line 163 "obj/src/GrammarLexer.l" +{ return Parser::make_ENDSEQ_BRACKET(loc); } + YY_BREAK +case 75: +YY_RULE_SETUP +#line 167 "obj/src/GrammarLexer.l" { return Parser::make_IDENTIFIER( yytext, loc ); } YY_BREAK -case 75: +case 76: YY_RULE_SETUP -#line 170 "obj/src/GrammarLexer.l" +#line 171 "obj/src/GrammarLexer.l" { // ignore spaces loc.step(); } YY_BREAK -case 76: -/* rule 76 can match eol */ +case 77: +/* rule 77 can match eol */ YY_RULE_SETUP -#line 174 "obj/src/GrammarLexer.l" +#line 175 "obj/src/GrammarLexer.l" { // ignore newlines loc.lines( yyleng ); loc.step(); } YY_BREAK -case 77: +case 78: YY_RULE_SETUP -#line 179 "obj/src/GrammarLexer.l" +#line 180 "obj/src/GrammarLexer.l" { // single-line comments BEGIN( LCOMMENT ); } YY_BREAK -case 78: +case 79: YY_RULE_SETUP -#line 182 "obj/src/GrammarLexer.l" +#line 183 "obj/src/GrammarLexer.l" YY_BREAK -case 79: -/* rule 79 can match eol */ +case 80: +/* rule 80 can match eol */ YY_RULE_SETUP -#line 183 "obj/src/GrammarLexer.l" +#line 184 "obj/src/GrammarLexer.l" { BEGIN( INITIAL ); loc.lines( 1 ); @@ -1241,127 +1248,127 @@ YY_RULE_SETUP } YY_BREAK case YY_STATE_EOF(LCOMMENT): -#line 188 "obj/src/GrammarLexer.l" +#line 189 "obj/src/GrammarLexer.l" { BEGIN( INITIAL ); } YY_BREAK -case 80: +case 81: YY_RULE_SETUP -#line 192 "obj/src/GrammarLexer.l" +#line 193 "obj/src/GrammarLexer.l" { // multi-line comments BEGIN( COMMENT ); } YY_BREAK -case 81: +case 82: YY_RULE_SETUP -#line 195 "obj/src/GrammarLexer.l" +#line 196 "obj/src/GrammarLexer.l" { BEGIN( INITIAL ); } YY_BREAK -case 82: -/* rule 82 can match eol */ +case 83: +/* rule 83 can match eol */ YY_RULE_SETUP -#line 198 "obj/src/GrammarLexer.l" +#line 199 "obj/src/GrammarLexer.l" { loc.lines( 1 ); } YY_BREAK -case 83: +case 84: YY_RULE_SETUP -#line 201 "obj/src/GrammarLexer.l" +#line 202 "obj/src/GrammarLexer.l" YY_BREAK case YY_STATE_EOF(COMMENT): -#line 202 "obj/src/GrammarLexer.l" +#line 203 "obj/src/GrammarLexer.l" { BEGIN( INITIAL ); log.error( {loc}, "multiline comment not terminated", Code::SyntaxErrorUnclosedComment ); yyterminate(); } YY_BREAK -case 84: +case 85: YY_RULE_SETUP -#line 208 "obj/src/GrammarLexer.l" +#line 209 "obj/src/GrammarLexer.l" { // strings BEGIN( STRING ); strbuf.clear(); } YY_BREAK -case 85: +case 86: YY_RULE_SETUP -#line 212 "obj/src/GrammarLexer.l" +#line 213 "obj/src/GrammarLexer.l" { /* eat all tokens */ strbuf.append( yytext ); } YY_BREAK -case 86: -/* rule 86 can match eol */ +case 87: +/* rule 87 can match eol */ YY_RULE_SETUP -#line 215 "obj/src/GrammarLexer.l" +#line 216 "obj/src/GrammarLexer.l" { loc.lines( 1 ); } YY_BREAK -case 87: +case 88: YY_RULE_SETUP -#line 218 "obj/src/GrammarLexer.l" +#line 219 "obj/src/GrammarLexer.l" { strbuf.append( "\n" ); } YY_BREAK -case 88: +case 89: YY_RULE_SETUP -#line 221 "obj/src/GrammarLexer.l" +#line 222 "obj/src/GrammarLexer.l" { strbuf.append( "\t" ); } YY_BREAK -case 89: +case 90: YY_RULE_SETUP -#line 224 "obj/src/GrammarLexer.l" +#line 225 "obj/src/GrammarLexer.l" { strbuf.append( "\"" ); } YY_BREAK -case 90: +case 91: YY_RULE_SETUP -#line 227 "obj/src/GrammarLexer.l" +#line 228 "obj/src/GrammarLexer.l" { strbuf.append( "\'" ); } YY_BREAK case YY_STATE_EOF(STRING): -#line 230 "obj/src/GrammarLexer.l" +#line 231 "obj/src/GrammarLexer.l" { BEGIN( INITIAL ); log.error( {loc}, "string not terminated", Code::SyntaxErrorUnclosedString ); yyterminate(); } YY_BREAK -case 91: +case 92: YY_RULE_SETUP -#line 235 "obj/src/GrammarLexer.l" +#line 236 "obj/src/GrammarLexer.l" { BEGIN( INITIAL ); return Parser::make_STRING( strbuf, loc ); } YY_BREAK -case 92: +case 93: YY_RULE_SETUP -#line 240 "obj/src/GrammarLexer.l" +#line 241 "obj/src/GrammarLexer.l" { log.error( {loc}, "unrecognized character `" + std::string( yytext ) + "`", Code::SyntaxErrorUnrecognizedCharacter ); } YY_BREAK -case 93: +case 94: YY_RULE_SETUP -#line 245 "obj/src/GrammarLexer.l" +#line 246 "obj/src/GrammarLexer.l" YY_FATAL_ERROR( "flex scanner jammed" ); YY_BREAK -#line 1364 "src/various/GrammarLexer.cpp" +#line 1371 "src/various/GrammarLexer.cpp" case YY_STATE_EOF(INITIAL): yyterminate(); @@ -1775,7 +1782,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 >= 244 ) + if ( yy_current_state >= 250 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; @@ -1803,11 +1810,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 >= 244 ) + if ( yy_current_state >= 250 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; - yy_is_jam = (yy_current_state == 243); + yy_is_jam = (yy_current_state == 249); return yy_is_jam ? 0 : yy_current_state; } @@ -2317,7 +2324,7 @@ void yyfree (void * ptr ) #define YYTABLES_NAME "yytables" -#line 245 "obj/src/GrammarLexer.l" +#line 246 "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 0d808ab12..b9e19ce02 100644 --- a/src/various/GrammarParser.cpp +++ b/src/various/GrammarParser.cpp @@ -328,249 +328,259 @@ namespace libcasm_fe { { switch (that.type_get ()) { - case 153: // Attribute + case 158: // Attribute value.move< Attribute::Ptr > (that.value); break; - case 154: // Attributes + case 159: // Attributes value.move< Attributes::Ptr > (that.value); break; - case 155: // BasicAttribute + case 160: // BasicAttribute value.move< BasicAttribute::Ptr > (that.value); break; - case 109: // BasicType + case 114: // BasicType value.move< BasicType::Ptr > (that.value); break; - case 149: // BlockRule + case 154: // BlockRule value.move< BlockRule::Ptr > (that.value); break; - case 152: // CallRule + case 157: // CallRule value.move< CallRule::Ptr > (that.value); break; - case 143: // CaseLabel + case 148: // CaseLabel value.move< Case::Ptr > (that.value); break; - case 142: // CaseRule + case 147: // CaseRule value.move< CaseRule::Ptr > (that.value); break; - case 144: // CaseLabels + case 149: // CaseLabels value.move< Cases::Ptr > (that.value); break; - case 134: // ChooseExpression + case 139: // ChooseExpression value.move< ChooseExpression::Ptr > (that.value); break; - case 147: // ChooseRule + case 152: // ChooseRule value.move< ChooseRule::Ptr > (that.value); break; - case 110: // ComposedType + case 115: // ComposedType value.move< ComposedType::Ptr > (that.value); break; - case 133: // ConditionalExpression + case 138: // ConditionalExpression value.move< ConditionalExpression::Ptr > (that.value); break; - case 141: // ConditionalRule + case 146: // ConditionalRule value.move< ConditionalRule::Ptr > (that.value); break; - case 84: // Definition - case 85: // AttributedDefinition + case 104: // DeclarationDefinition + value.move< DeclarationDefinition::Ptr > (that.value); + break; + + case 85: // Definition + case 86: // AttributedDefinition + case 102: // FeatureDeclarationOrDefinition value.move< Definition::Ptr > (that.value); break; - case 86: // Definitions + case 87: // Definitions + case 103: // FeatureDeclarationsAndDefinitions value.move< Definitions::Ptr > (that.value); break; - case 97: // DerivedDefinition + case 98: // DerivedDefinition value.move< DerivedDefinition::Ptr > (that.value); break; - case 130: // DirectCallExpression + case 135: // DirectCallExpression value.move< DirectCallExpression::Ptr > (that.value); break; - case 98: // EnumerationDefinition + case 99: // EnumerationDefinition value.move< EnumerationDefinition::Ptr > (that.value); break; - case 136: // ExistentialQuantifierExpression + case 141: // ExistentialQuantifierExpression value.move< ExistentialQuantifierExpression::Ptr > (that.value); break; - case 90: // MaybeDefined - case 114: // Atom - case 123: // Term - case 124: // Expression + case 91: // MaybeDefined + case 119: // Atom + case 128: // Term + case 129: // Expression value.move< Expression::Ptr > (that.value); break; - case 156: // ExpressionAttribute + case 161: // ExpressionAttribute value.move< ExpressionAttribute::Ptr > (that.value); break; - case 127: // Terms - case 128: // Arguments - case 129: // TwoOrMoreArguments + case 132: // Terms + case 133: // Arguments + case 134: // TwoOrMoreArguments value.move< Expressions::Ptr > (that.value); break; - case 112: // FixedSizedType + case 101: // FeatureDefinition + value.move< FeatureDefinition::Ptr > (that.value); + break; + + case 117: // FixedSizedType value.move< FixedSizedType::Ptr > (that.value); break; - case 146: // ForallRule + case 151: // ForallRule value.move< ForallRule::Ptr > (that.value); break; - case 87: // FunctionDefinition - case 93: // ProgramFunctionDefinition + case 88: // FunctionDefinition + case 94: // ProgramFunctionDefinition value.move< FunctionDefinition::Ptr > (that.value); break; - case 88: // FunctionDefinitions + case 89: // FunctionDefinitions value.move< FunctionDefinitions::Ptr > (that.value); break; - case 100: // Identifier + case 105: // Identifier value.move< Identifier::Ptr > (that.value); break; - case 103: // IdentifierPath + case 108: // IdentifierPath value.move< IdentifierPath::Ptr > (that.value); break; - case 101: // Identifiers - case 102: // DotSeparatedIdentifiers + case 106: // Identifiers + case 107: // DotSeparatedIdentifiers value.move< Identifiers::Ptr > (that.value); break; - case 131: // IndirectCallExpression + case 136: // IndirectCallExpression value.move< IndirectCallExpression::Ptr > (that.value); break; - case 148: // IterateRule + case 153: // IterateRule value.move< IterateRule::Ptr > (that.value); break; - case 132: // LetExpression + case 137: // LetExpression value.move< LetExpression::Ptr > (that.value); break; - case 145: // LetRule + case 150: // LetRule value.move< LetRule::Ptr > (that.value); break; - case 126: // List + case 131: // List value.move< ListExpression::Ptr > (that.value); break; - case 89: // MaybeInitially - case 95: // Initializers - case 96: // MaybeInitializers + case 90: // MaybeInitially + case 96: // Initializers + case 97: // MaybeInitializers value.move< NodeList< UpdateRule >::Ptr > (that.value); break; - case 106: // Parameters - case 107: // MaybeParameters + case 111: // Parameters + case 112: // MaybeParameters value.move< NodeList< VariableDefinition >::Ptr > (that.value); break; - case 125: // Range + case 130: // Range value.move< RangeExpression::Ptr > (that.value); break; - case 122: // Reference + case 127: // Reference value.move< ReferenceAtom::Ptr > (that.value); break; - case 111: // RelationType + case 116: // RelationType value.move< RelationType::Ptr > (that.value); break; - case 138: // Rule + case 143: // Rule value.move< Rule::Ptr > (that.value); break; - case 137: // RuleDefinition + case 142: // RuleDefinition value.move< RuleDefinition::Ptr > (that.value); break; - case 139: // Rules + case 144: // Rules value.move< Rules::Ptr > (that.value); break; - case 150: // SequenceRule + case 155: // SequenceRule value.move< SequenceRule::Ptr > (that.value); break; - case 140: // SkipRule + case 145: // SkipRule value.move< SkipRule::Ptr > (that.value); break; - case 83: // Specification + case 84: // Specification value.move< Specification::Ptr > (that.value); break; - case 99: // StructureDefinition + case 100: // StructureDefinition value.move< StructureDefinition::Ptr > (that.value); break; - case 108: // Type + case 113: // Type value.move< Type::Ptr > (that.value); break; - case 91: // FunctionParameters - case 92: // MaybeFunctionParameters - case 113: // Types + case 92: // FunctionParameters + case 93: // MaybeFunctionParameters + case 118: // Types value.move< Types::Ptr > (that.value); break; - case 115: // Undefined + case 120: // Undefined value.move< UndefAtom::Ptr > (that.value); break; - case 135: // UniversalQuantifierExpression + case 140: // UniversalQuantifierExpression value.move< UniversalQuantifierExpression::Ptr > (that.value); break; - case 94: // Initializer - case 151: // UpdateRule + case 95: // Initializer + case 156: // UpdateRule value.move< UpdateRule::Ptr > (that.value); break; - case 116: // Boolean - case 117: // String - case 118: // BitNumber - case 119: // IntegerNumber - case 120: // FloatingNumber - case 121: // RationalNumber + case 121: // Boolean + case 122: // String + case 123: // BitNumber + case 124: // IntegerNumber + case 125: // FloatingNumber + case 126: // RationalNumber value.move< ValueAtom::Ptr > (that.value); break; - case 104: // Variable - case 105: // AttributedVariable + case 109: // Variable + case 110: // AttributedVariable value.move< VariableDefinition::Ptr > (that.value); break; - case 71: // "binary" - case 72: // "hexadecimal" - case 73: // "integer" - case 74: // "rational" - case 75: // "floating" - case 76: // "string" - case 77: // "identifier" + case 72: // "binary" + case 73: // "hexadecimal" + case 74: // "integer" + case 75: // "rational" + case 76: // "floating" + case 77: // "string" + case 78: // "identifier" value.move< std::string > (that.value); break; @@ -589,249 +599,259 @@ namespace libcasm_fe { state = that.state; switch (that.type_get ()) { - case 153: // Attribute + case 158: // Attribute value.copy< Attribute::Ptr > (that.value); break; - case 154: // Attributes + case 159: // Attributes value.copy< Attributes::Ptr > (that.value); break; - case 155: // BasicAttribute + case 160: // BasicAttribute value.copy< BasicAttribute::Ptr > (that.value); break; - case 109: // BasicType + case 114: // BasicType value.copy< BasicType::Ptr > (that.value); break; - case 149: // BlockRule + case 154: // BlockRule value.copy< BlockRule::Ptr > (that.value); break; - case 152: // CallRule + case 157: // CallRule value.copy< CallRule::Ptr > (that.value); break; - case 143: // CaseLabel + case 148: // CaseLabel value.copy< Case::Ptr > (that.value); break; - case 142: // CaseRule + case 147: // CaseRule value.copy< CaseRule::Ptr > (that.value); break; - case 144: // CaseLabels + case 149: // CaseLabels value.copy< Cases::Ptr > (that.value); break; - case 134: // ChooseExpression + case 139: // ChooseExpression value.copy< ChooseExpression::Ptr > (that.value); break; - case 147: // ChooseRule + case 152: // ChooseRule value.copy< ChooseRule::Ptr > (that.value); break; - case 110: // ComposedType + case 115: // ComposedType value.copy< ComposedType::Ptr > (that.value); break; - case 133: // ConditionalExpression + case 138: // ConditionalExpression value.copy< ConditionalExpression::Ptr > (that.value); break; - case 141: // ConditionalRule + case 146: // ConditionalRule value.copy< ConditionalRule::Ptr > (that.value); break; - case 84: // Definition - case 85: // AttributedDefinition + case 104: // DeclarationDefinition + value.copy< DeclarationDefinition::Ptr > (that.value); + break; + + case 85: // Definition + case 86: // AttributedDefinition + case 102: // FeatureDeclarationOrDefinition value.copy< Definition::Ptr > (that.value); break; - case 86: // Definitions + case 87: // Definitions + case 103: // FeatureDeclarationsAndDefinitions value.copy< Definitions::Ptr > (that.value); break; - case 97: // DerivedDefinition + case 98: // DerivedDefinition value.copy< DerivedDefinition::Ptr > (that.value); break; - case 130: // DirectCallExpression + case 135: // DirectCallExpression value.copy< DirectCallExpression::Ptr > (that.value); break; - case 98: // EnumerationDefinition + case 99: // EnumerationDefinition value.copy< EnumerationDefinition::Ptr > (that.value); break; - case 136: // ExistentialQuantifierExpression + case 141: // ExistentialQuantifierExpression value.copy< ExistentialQuantifierExpression::Ptr > (that.value); break; - case 90: // MaybeDefined - case 114: // Atom - case 123: // Term - case 124: // Expression + case 91: // MaybeDefined + case 119: // Atom + case 128: // Term + case 129: // Expression value.copy< Expression::Ptr > (that.value); break; - case 156: // ExpressionAttribute + case 161: // ExpressionAttribute value.copy< ExpressionAttribute::Ptr > (that.value); break; - case 127: // Terms - case 128: // Arguments - case 129: // TwoOrMoreArguments + case 132: // Terms + case 133: // Arguments + case 134: // TwoOrMoreArguments value.copy< Expressions::Ptr > (that.value); break; - case 112: // FixedSizedType + case 101: // FeatureDefinition + value.copy< FeatureDefinition::Ptr > (that.value); + break; + + case 117: // FixedSizedType value.copy< FixedSizedType::Ptr > (that.value); break; - case 146: // ForallRule + case 151: // ForallRule value.copy< ForallRule::Ptr > (that.value); break; - case 87: // FunctionDefinition - case 93: // ProgramFunctionDefinition + case 88: // FunctionDefinition + case 94: // ProgramFunctionDefinition value.copy< FunctionDefinition::Ptr > (that.value); break; - case 88: // FunctionDefinitions + case 89: // FunctionDefinitions value.copy< FunctionDefinitions::Ptr > (that.value); break; - case 100: // Identifier + case 105: // Identifier value.copy< Identifier::Ptr > (that.value); break; - case 103: // IdentifierPath + case 108: // IdentifierPath value.copy< IdentifierPath::Ptr > (that.value); break; - case 101: // Identifiers - case 102: // DotSeparatedIdentifiers + case 106: // Identifiers + case 107: // DotSeparatedIdentifiers value.copy< Identifiers::Ptr > (that.value); break; - case 131: // IndirectCallExpression + case 136: // IndirectCallExpression value.copy< IndirectCallExpression::Ptr > (that.value); break; - case 148: // IterateRule + case 153: // IterateRule value.copy< IterateRule::Ptr > (that.value); break; - case 132: // LetExpression + case 137: // LetExpression value.copy< LetExpression::Ptr > (that.value); break; - case 145: // LetRule + case 150: // LetRule value.copy< LetRule::Ptr > (that.value); break; - case 126: // List + case 131: // List value.copy< ListExpression::Ptr > (that.value); break; - case 89: // MaybeInitially - case 95: // Initializers - case 96: // MaybeInitializers + case 90: // MaybeInitially + case 96: // Initializers + case 97: // MaybeInitializers value.copy< NodeList< UpdateRule >::Ptr > (that.value); break; - case 106: // Parameters - case 107: // MaybeParameters + case 111: // Parameters + case 112: // MaybeParameters value.copy< NodeList< VariableDefinition >::Ptr > (that.value); break; - case 125: // Range + case 130: // Range value.copy< RangeExpression::Ptr > (that.value); break; - case 122: // Reference + case 127: // Reference value.copy< ReferenceAtom::Ptr > (that.value); break; - case 111: // RelationType + case 116: // RelationType value.copy< RelationType::Ptr > (that.value); break; - case 138: // Rule + case 143: // Rule value.copy< Rule::Ptr > (that.value); break; - case 137: // RuleDefinition + case 142: // RuleDefinition value.copy< RuleDefinition::Ptr > (that.value); break; - case 139: // Rules + case 144: // Rules value.copy< Rules::Ptr > (that.value); break; - case 150: // SequenceRule + case 155: // SequenceRule value.copy< SequenceRule::Ptr > (that.value); break; - case 140: // SkipRule + case 145: // SkipRule value.copy< SkipRule::Ptr > (that.value); break; - case 83: // Specification + case 84: // Specification value.copy< Specification::Ptr > (that.value); break; - case 99: // StructureDefinition + case 100: // StructureDefinition value.copy< StructureDefinition::Ptr > (that.value); break; - case 108: // Type + case 113: // Type value.copy< Type::Ptr > (that.value); break; - case 91: // FunctionParameters - case 92: // MaybeFunctionParameters - case 113: // Types + case 92: // FunctionParameters + case 93: // MaybeFunctionParameters + case 118: // Types value.copy< Types::Ptr > (that.value); break; - case 115: // Undefined + case 120: // Undefined value.copy< UndefAtom::Ptr > (that.value); break; - case 135: // UniversalQuantifierExpression + case 140: // UniversalQuantifierExpression value.copy< UniversalQuantifierExpression::Ptr > (that.value); break; - case 94: // Initializer - case 151: // UpdateRule + case 95: // Initializer + case 156: // UpdateRule value.copy< UpdateRule::Ptr > (that.value); break; - case 116: // Boolean - case 117: // String - case 118: // BitNumber - case 119: // IntegerNumber - case 120: // FloatingNumber - case 121: // RationalNumber + case 121: // Boolean + case 122: // String + case 123: // BitNumber + case 124: // IntegerNumber + case 125: // FloatingNumber + case 126: // RationalNumber value.copy< ValueAtom::Ptr > (that.value); break; - case 104: // Variable - case 105: // AttributedVariable + case 109: // Variable + case 110: // AttributedVariable value.copy< VariableDefinition::Ptr > (that.value); break; - case 71: // "binary" - case 72: // "hexadecimal" - case 73: // "integer" - case 74: // "rational" - case 75: // "floating" - case 76: // "string" - case 77: // "identifier" + case 72: // "binary" + case 73: // "hexadecimal" + case 74: // "integer" + case 75: // "rational" + case 76: // "floating" + case 77: // "string" + case 78: // "identifier" value.copy< std::string > (that.value); break; @@ -1063,249 +1083,259 @@ namespace libcasm_fe { when using variants. */ switch (yyr1_[yyn]) { - case 153: // Attribute + case 158: // Attribute yylhs.value.build< Attribute::Ptr > (); break; - case 154: // Attributes + case 159: // Attributes yylhs.value.build< Attributes::Ptr > (); break; - case 155: // BasicAttribute + case 160: // BasicAttribute yylhs.value.build< BasicAttribute::Ptr > (); break; - case 109: // BasicType + case 114: // BasicType yylhs.value.build< BasicType::Ptr > (); break; - case 149: // BlockRule + case 154: // BlockRule yylhs.value.build< BlockRule::Ptr > (); break; - case 152: // CallRule + case 157: // CallRule yylhs.value.build< CallRule::Ptr > (); break; - case 143: // CaseLabel + case 148: // CaseLabel yylhs.value.build< Case::Ptr > (); break; - case 142: // CaseRule + case 147: // CaseRule yylhs.value.build< CaseRule::Ptr > (); break; - case 144: // CaseLabels + case 149: // CaseLabels yylhs.value.build< Cases::Ptr > (); break; - case 134: // ChooseExpression + case 139: // ChooseExpression yylhs.value.build< ChooseExpression::Ptr > (); break; - case 147: // ChooseRule + case 152: // ChooseRule yylhs.value.build< ChooseRule::Ptr > (); break; - case 110: // ComposedType + case 115: // ComposedType yylhs.value.build< ComposedType::Ptr > (); break; - case 133: // ConditionalExpression + case 138: // ConditionalExpression yylhs.value.build< ConditionalExpression::Ptr > (); break; - case 141: // ConditionalRule + case 146: // ConditionalRule yylhs.value.build< ConditionalRule::Ptr > (); break; - case 84: // Definition - case 85: // AttributedDefinition + case 104: // DeclarationDefinition + yylhs.value.build< DeclarationDefinition::Ptr > (); + break; + + case 85: // Definition + case 86: // AttributedDefinition + case 102: // FeatureDeclarationOrDefinition yylhs.value.build< Definition::Ptr > (); break; - case 86: // Definitions + case 87: // Definitions + case 103: // FeatureDeclarationsAndDefinitions yylhs.value.build< Definitions::Ptr > (); break; - case 97: // DerivedDefinition + case 98: // DerivedDefinition yylhs.value.build< DerivedDefinition::Ptr > (); break; - case 130: // DirectCallExpression + case 135: // DirectCallExpression yylhs.value.build< DirectCallExpression::Ptr > (); break; - case 98: // EnumerationDefinition + case 99: // EnumerationDefinition yylhs.value.build< EnumerationDefinition::Ptr > (); break; - case 136: // ExistentialQuantifierExpression + case 141: // ExistentialQuantifierExpression yylhs.value.build< ExistentialQuantifierExpression::Ptr > (); break; - case 90: // MaybeDefined - case 114: // Atom - case 123: // Term - case 124: // Expression + case 91: // MaybeDefined + case 119: // Atom + case 128: // Term + case 129: // Expression yylhs.value.build< Expression::Ptr > (); break; - case 156: // ExpressionAttribute + case 161: // ExpressionAttribute yylhs.value.build< ExpressionAttribute::Ptr > (); break; - case 127: // Terms - case 128: // Arguments - case 129: // TwoOrMoreArguments + case 132: // Terms + case 133: // Arguments + case 134: // TwoOrMoreArguments yylhs.value.build< Expressions::Ptr > (); break; - case 112: // FixedSizedType + case 101: // FeatureDefinition + yylhs.value.build< FeatureDefinition::Ptr > (); + break; + + case 117: // FixedSizedType yylhs.value.build< FixedSizedType::Ptr > (); break; - case 146: // ForallRule + case 151: // ForallRule yylhs.value.build< ForallRule::Ptr > (); break; - case 87: // FunctionDefinition - case 93: // ProgramFunctionDefinition + case 88: // FunctionDefinition + case 94: // ProgramFunctionDefinition yylhs.value.build< FunctionDefinition::Ptr > (); break; - case 88: // FunctionDefinitions + case 89: // FunctionDefinitions yylhs.value.build< FunctionDefinitions::Ptr > (); break; - case 100: // Identifier + case 105: // Identifier yylhs.value.build< Identifier::Ptr > (); break; - case 103: // IdentifierPath + case 108: // IdentifierPath yylhs.value.build< IdentifierPath::Ptr > (); break; - case 101: // Identifiers - case 102: // DotSeparatedIdentifiers + case 106: // Identifiers + case 107: // DotSeparatedIdentifiers yylhs.value.build< Identifiers::Ptr > (); break; - case 131: // IndirectCallExpression + case 136: // IndirectCallExpression yylhs.value.build< IndirectCallExpression::Ptr > (); break; - case 148: // IterateRule + case 153: // IterateRule yylhs.value.build< IterateRule::Ptr > (); break; - case 132: // LetExpression + case 137: // LetExpression yylhs.value.build< LetExpression::Ptr > (); break; - case 145: // LetRule + case 150: // LetRule yylhs.value.build< LetRule::Ptr > (); break; - case 126: // List + case 131: // List yylhs.value.build< ListExpression::Ptr > (); break; - case 89: // MaybeInitially - case 95: // Initializers - case 96: // MaybeInitializers + case 90: // MaybeInitially + case 96: // Initializers + case 97: // MaybeInitializers yylhs.value.build< NodeList< UpdateRule >::Ptr > (); break; - case 106: // Parameters - case 107: // MaybeParameters + case 111: // Parameters + case 112: // MaybeParameters yylhs.value.build< NodeList< VariableDefinition >::Ptr > (); break; - case 125: // Range + case 130: // Range yylhs.value.build< RangeExpression::Ptr > (); break; - case 122: // Reference + case 127: // Reference yylhs.value.build< ReferenceAtom::Ptr > (); break; - case 111: // RelationType + case 116: // RelationType yylhs.value.build< RelationType::Ptr > (); break; - case 138: // Rule + case 143: // Rule yylhs.value.build< Rule::Ptr > (); break; - case 137: // RuleDefinition + case 142: // RuleDefinition yylhs.value.build< RuleDefinition::Ptr > (); break; - case 139: // Rules + case 144: // Rules yylhs.value.build< Rules::Ptr > (); break; - case 150: // SequenceRule + case 155: // SequenceRule yylhs.value.build< SequenceRule::Ptr > (); break; - case 140: // SkipRule + case 145: // SkipRule yylhs.value.build< SkipRule::Ptr > (); break; - case 83: // Specification + case 84: // Specification yylhs.value.build< Specification::Ptr > (); break; - case 99: // StructureDefinition + case 100: // StructureDefinition yylhs.value.build< StructureDefinition::Ptr > (); break; - case 108: // Type + case 113: // Type yylhs.value.build< Type::Ptr > (); break; - case 91: // FunctionParameters - case 92: // MaybeFunctionParameters - case 113: // Types + case 92: // FunctionParameters + case 93: // MaybeFunctionParameters + case 118: // Types yylhs.value.build< Types::Ptr > (); break; - case 115: // Undefined + case 120: // Undefined yylhs.value.build< UndefAtom::Ptr > (); break; - case 135: // UniversalQuantifierExpression + case 140: // UniversalQuantifierExpression yylhs.value.build< UniversalQuantifierExpression::Ptr > (); break; - case 94: // Initializer - case 151: // UpdateRule + case 95: // Initializer + case 156: // UpdateRule yylhs.value.build< UpdateRule::Ptr > (); break; - case 116: // Boolean - case 117: // String - case 118: // BitNumber - case 119: // IntegerNumber - case 120: // FloatingNumber - case 121: // RationalNumber + case 121: // Boolean + case 122: // String + case 123: // BitNumber + case 124: // IntegerNumber + case 125: // FloatingNumber + case 126: // RationalNumber yylhs.value.build< ValueAtom::Ptr > (); break; - case 104: // Variable - case 105: // AttributedVariable + case 109: // Variable + case 110: // AttributedVariable yylhs.value.build< VariableDefinition::Ptr > (); break; - case 71: // "binary" - case 72: // "hexadecimal" - case 73: // "integer" - case 74: // "rational" - case 75: // "floating" - case 76: // "string" - case 77: // "identifier" + case 72: // "binary" + case 73: // "hexadecimal" + case 74: // "integer" + case 75: // "rational" + case 76: // "floating" + case 77: // "string" + case 78: // "identifier" yylhs.value.build< std::string > (); break; @@ -1327,7 +1357,7 @@ namespace libcasm_fe { switch (yyn) { case 2: -#line 355 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 +#line 360 "../../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( "." ) ); @@ -1335,97 +1365,105 @@ 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 1339 "GrammarParser.cpp" // lalr1.cc:859 +#line 1369 "GrammarParser.cpp" // lalr1.cc:859 break; case 3: -#line 367 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 +#line 372 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< FunctionDefinition::Ptr > (); } -#line 1347 "GrammarParser.cpp" // lalr1.cc:859 +#line 1377 "GrammarParser.cpp" // lalr1.cc:859 break; case 4: -#line 371 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 +#line 376 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< DerivedDefinition::Ptr > (); } -#line 1355 "GrammarParser.cpp" // lalr1.cc:859 +#line 1385 "GrammarParser.cpp" // lalr1.cc:859 break; case 5: -#line 375 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 +#line 380 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< RuleDefinition::Ptr > (); } -#line 1363 "GrammarParser.cpp" // lalr1.cc:859 +#line 1393 "GrammarParser.cpp" // lalr1.cc:859 break; case 6: -#line 379 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 +#line 384 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< EnumerationDefinition::Ptr > (); } -#line 1371 "GrammarParser.cpp" // lalr1.cc:859 +#line 1401 "GrammarParser.cpp" // lalr1.cc:859 break; case 7: -#line 383 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 +#line 388 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< StructureDefinition::Ptr > (); } -#line 1379 "GrammarParser.cpp" // lalr1.cc:859 +#line 1409 "GrammarParser.cpp" // lalr1.cc:859 break; case 8: -#line 387 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 +#line 392 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { - yylhs.value.as< Definition::Ptr > () = nullptr; + yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< FeatureDefinition::Ptr > (); } -#line 1387 "GrammarParser.cpp" // lalr1.cc:859 +#line 1417 "GrammarParser.cpp" // lalr1.cc:859 break; case 9: -#line 395 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 +#line 396 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + { + yylhs.value.as< Definition::Ptr > () = nullptr; + } +#line 1425 "GrammarParser.cpp" // lalr1.cc:859 + break; + + case 10: +#line 404 "../../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 1397 "GrammarParser.cpp" // lalr1.cc:859 +#line 1435 "GrammarParser.cpp" // lalr1.cc:859 break; - case 10: -#line 401 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 11: +#line 410 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< Definition::Ptr > (); } -#line 1405 "GrammarParser.cpp" // lalr1.cc:859 +#line 1443 "GrammarParser.cpp" // lalr1.cc:859 break; - case 11: -#line 409 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 12: +#line 418 "../../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 1415 "GrammarParser.cpp" // lalr1.cc:859 +#line 1453 "GrammarParser.cpp" // lalr1.cc:859 break; - case 12: -#line 415 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 13: +#line 424 "../../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 1425 "GrammarParser.cpp" // lalr1.cc:859 +#line 1463 "GrammarParser.cpp" // lalr1.cc:859 break; - case 13: -#line 425 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 14: +#line 434 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { const auto identifier = yystack_[6].value.as< Identifier::Ptr > (); @@ -1441,107 +1479,107 @@ namespace libcasm_fe { yylhs.value.as< FunctionDefinition::Ptr > () = function; } -#line 1445 "GrammarParser.cpp" // lalr1.cc:859 +#line 1483 "GrammarParser.cpp" // lalr1.cc:859 break; - case 14: -#line 441 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 15: +#line 450 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< FunctionDefinition::Ptr > () = yystack_[0].value.as< FunctionDefinition::Ptr > (); // `init` special case } -#line 1453 "GrammarParser.cpp" // lalr1.cc:859 +#line 1491 "GrammarParser.cpp" // lalr1.cc:859 break; - case 15: -#line 449 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 16: +#line 458 "../../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 1463 "GrammarParser.cpp" // lalr1.cc:859 +#line 1501 "GrammarParser.cpp" // lalr1.cc:859 break; - case 16: -#line 455 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 17: +#line 464 "../../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 1473 "GrammarParser.cpp" // lalr1.cc:859 +#line 1511 "GrammarParser.cpp" // lalr1.cc:859 break; - case 17: -#line 465 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 18: +#line 474 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< NodeList< UpdateRule >::Ptr > () = yystack_[1].value.as< NodeList< UpdateRule >::Ptr > (); } -#line 1481 "GrammarParser.cpp" // lalr1.cc:859 +#line 1519 "GrammarParser.cpp" // lalr1.cc:859 break; - case 18: -#line 469 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 19: +#line 478 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< NodeList< UpdateRule >::Ptr > () = Ast::make< NodeList< UpdateRule > >( yylhs.location ); } -#line 1489 "GrammarParser.cpp" // lalr1.cc:859 +#line 1527 "GrammarParser.cpp" // lalr1.cc:859 break; - case 19: -#line 477 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 20: +#line 486 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[1].value.as< Expression::Ptr > (); } -#line 1497 "GrammarParser.cpp" // lalr1.cc:859 +#line 1535 "GrammarParser.cpp" // lalr1.cc:859 break; - case 20: -#line 481 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 21: +#line 490 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = Ast::make< UndefAtom >( yylhs.location ); } -#line 1505 "GrammarParser.cpp" // lalr1.cc:859 +#line 1543 "GrammarParser.cpp" // lalr1.cc:859 break; - case 21: -#line 489 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 22: +#line 498 "../../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 1515 "GrammarParser.cpp" // lalr1.cc:859 +#line 1553 "GrammarParser.cpp" // lalr1.cc:859 break; - case 22: -#line 495 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 23: +#line 504 "../../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 1525 "GrammarParser.cpp" // lalr1.cc:859 +#line 1563 "GrammarParser.cpp" // lalr1.cc:859 break; - case 23: -#line 505 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 24: +#line 514 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Types::Ptr > () = yystack_[0].value.as< Types::Ptr > (); } -#line 1533 "GrammarParser.cpp" // lalr1.cc:859 +#line 1571 "GrammarParser.cpp" // lalr1.cc:859 break; - case 24: -#line 509 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 25: +#line 518 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Types::Ptr > () = Ast::make< Types >( yylhs.location ); } -#line 1541 "GrammarParser.cpp" // lalr1.cc:859 +#line 1579 "GrammarParser.cpp" // lalr1.cc:859 break; - case 25: -#line 517 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 26: +#line 526 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { const auto singleAgentIdentifier = Ast::make< Identifier >( yylhs.location, "$" ); auto singleAgentArguments = libcasm_fe::Ast::make< Expressions >( yylhs.location ); @@ -1564,11 +1602,11 @@ namespace libcasm_fe { yylhs.value.as< FunctionDefinition::Ptr > () = programDefinition; } -#line 1568 "GrammarParser.cpp" // lalr1.cc:859 +#line 1606 "GrammarParser.cpp" // lalr1.cc:859 break; - case 26: -#line 540 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 27: +#line 549 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto programDefinition = createProgramFunction( yylhs.location ); @@ -1582,11 +1620,11 @@ namespace libcasm_fe { yylhs.value.as< FunctionDefinition::Ptr > () = programDefinition; } -#line 1586 "GrammarParser.cpp" // lalr1.cc:859 +#line 1624 "GrammarParser.cpp" // lalr1.cc:859 break; - case 27: -#line 558 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 28: +#line 567 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { // the unknown function identifier will be replaced in FunctionDefinition const auto arguments = Ast::make< Expressions >( yylhs.location ); @@ -1594,11 +1632,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 1598 "GrammarParser.cpp" // lalr1.cc:859 +#line 1636 "GrammarParser.cpp" // lalr1.cc:859 break; - case 28: -#line 566 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 29: +#line 575 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto arguments = Ast::make< Expressions >( yylhs.location ); arguments->add( yystack_[2].value.as< Expression::Ptr > () ); @@ -1608,407 +1646,479 @@ 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 1612 "GrammarParser.cpp" // lalr1.cc:859 +#line 1650 "GrammarParser.cpp" // lalr1.cc:859 break; - case 29: -#line 576 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 30: +#line 585 "../../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 1623 "GrammarParser.cpp" // lalr1.cc:859 +#line 1661 "GrammarParser.cpp" // lalr1.cc:859 break; - case 30: -#line 587 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 31: +#line 596 "../../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 1633 "GrammarParser.cpp" // lalr1.cc:859 +#line 1671 "GrammarParser.cpp" // lalr1.cc:859 break; - case 31: -#line 593 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 32: +#line 602 "../../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 1643 "GrammarParser.cpp" // lalr1.cc:859 +#line 1681 "GrammarParser.cpp" // lalr1.cc:859 break; - case 32: -#line 603 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 33: +#line 612 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< NodeList< UpdateRule >::Ptr > () = yystack_[0].value.as< NodeList< UpdateRule >::Ptr > (); } -#line 1651 "GrammarParser.cpp" // lalr1.cc:859 +#line 1689 "GrammarParser.cpp" // lalr1.cc:859 break; - case 33: -#line 607 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 34: +#line 616 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< NodeList< UpdateRule >::Ptr > () = Ast::make< NodeList< UpdateRule > >( yylhs.location ); } -#line 1659 "GrammarParser.cpp" // lalr1.cc:859 +#line 1697 "GrammarParser.cpp" // lalr1.cc:859 break; - case 34: -#line 615 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 35: +#line 624 "../../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 1667 "GrammarParser.cpp" // lalr1.cc:859 +#line 1705 "GrammarParser.cpp" // lalr1.cc:859 break; - case 35: -#line 623 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 36: +#line 632 "../../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 1675 "GrammarParser.cpp" // lalr1.cc:859 +#line 1713 "GrammarParser.cpp" // lalr1.cc:859 break; - case 36: -#line 631 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 37: +#line 640 "../../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 1683 "GrammarParser.cpp" // lalr1.cc:859 +#line 1721 "GrammarParser.cpp" // lalr1.cc:859 break; - case 37: -#line 639 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 38: +#line 648 "../../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 + break; + + case 39: +#line 656 "../../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 + break; + + case 40: +#line 660 "../../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 + break; + + case 41: +#line 664 "../../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 + break; + + case 42: +#line 672 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + { + auto definitions = yystack_[2].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 + break; + + case 43: +#line 678 "../../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 + break; + + case 44: +#line 688 "../../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 + break; + + case 45: +#line 694 "../../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 + break; + + case 46: +#line 704 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Identifier::Ptr > () = Ast::make< Identifier >( yylhs.location, yystack_[0].value.as< std::string > () ); } -#line 1691 "GrammarParser.cpp" // lalr1.cc:859 +#line 1801 "GrammarParser.cpp" // lalr1.cc:859 break; - case 38: -#line 643 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 47: +#line 708 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Identifier::Ptr > () = Ast::make< Identifier >( yylhs.location, "in" ); } -#line 1699 "GrammarParser.cpp" // lalr1.cc:859 +#line 1809 "GrammarParser.cpp" // lalr1.cc:859 break; - case 39: -#line 651 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 48: +#line 716 "../../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 1709 "GrammarParser.cpp" // lalr1.cc:859 +#line 1819 "GrammarParser.cpp" // lalr1.cc:859 break; - case 40: -#line 657 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 49: +#line 722 "../../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 1719 "GrammarParser.cpp" // lalr1.cc:859 +#line 1829 "GrammarParser.cpp" // lalr1.cc:859 break; - case 41: -#line 667 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 50: +#line 732 "../../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 1729 "GrammarParser.cpp" // lalr1.cc:859 +#line 1839 "GrammarParser.cpp" // lalr1.cc:859 break; - case 42: -#line 673 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 51: +#line 738 "../../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 1739 "GrammarParser.cpp" // lalr1.cc:859 +#line 1849 "GrammarParser.cpp" // lalr1.cc:859 break; - case 43: -#line 683 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 52: +#line 748 "../../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 1747 "GrammarParser.cpp" // lalr1.cc:859 +#line 1857 "GrammarParser.cpp" // lalr1.cc:859 break; - case 44: -#line 687 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 53: +#line 752 "../../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 1755 "GrammarParser.cpp" // lalr1.cc:859 +#line 1865 "GrammarParser.cpp" // lalr1.cc:859 break; - case 45: -#line 695 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 54: +#line 760 "../../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 1763 "GrammarParser.cpp" // lalr1.cc:859 +#line 1873 "GrammarParser.cpp" // lalr1.cc:859 break; - case 46: -#line 699 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 55: +#line 764 "../../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 1772 "GrammarParser.cpp" // lalr1.cc:859 +#line 1882 "GrammarParser.cpp" // lalr1.cc:859 break; - case 47: -#line 708 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 56: +#line 773 "../../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 1782 "GrammarParser.cpp" // lalr1.cc:859 +#line 1892 "GrammarParser.cpp" // lalr1.cc:859 break; - case 48: -#line 714 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 57: +#line 779 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< VariableDefinition::Ptr > () = yystack_[0].value.as< VariableDefinition::Ptr > (); } -#line 1790 "GrammarParser.cpp" // lalr1.cc:859 +#line 1900 "GrammarParser.cpp" // lalr1.cc:859 break; - case 49: -#line 722 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 58: +#line 787 "../../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 1800 "GrammarParser.cpp" // lalr1.cc:859 +#line 1910 "GrammarParser.cpp" // lalr1.cc:859 break; - case 50: -#line 728 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 59: +#line 793 "../../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 1810 "GrammarParser.cpp" // lalr1.cc:859 +#line 1920 "GrammarParser.cpp" // lalr1.cc:859 break; - case 51: -#line 738 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 60: +#line 803 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< NodeList< VariableDefinition >::Ptr > () = yystack_[1].value.as< NodeList< VariableDefinition >::Ptr > (); } -#line 1818 "GrammarParser.cpp" // lalr1.cc:859 +#line 1928 "GrammarParser.cpp" // lalr1.cc:859 break; - case 52: -#line 742 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 61: +#line 807 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< NodeList< VariableDefinition >::Ptr > () = nullptr; } -#line 1826 "GrammarParser.cpp" // lalr1.cc:859 +#line 1936 "GrammarParser.cpp" // lalr1.cc:859 break; - case 53: -#line 746 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 62: +#line 811 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< NodeList< VariableDefinition >::Ptr > () = Ast::make< NodeList< VariableDefinition > >( yylhs.location ); } -#line 1834 "GrammarParser.cpp" // lalr1.cc:859 +#line 1944 "GrammarParser.cpp" // lalr1.cc:859 break; - case 54: -#line 754 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 63: +#line 819 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Type::Ptr > () = yystack_[0].value.as< BasicType::Ptr > (); } -#line 1842 "GrammarParser.cpp" // lalr1.cc:859 +#line 1952 "GrammarParser.cpp" // lalr1.cc:859 break; - case 55: -#line 758 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 64: +#line 823 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Type::Ptr > () = yystack_[0].value.as< ComposedType::Ptr > (); } -#line 1850 "GrammarParser.cpp" // lalr1.cc:859 +#line 1960 "GrammarParser.cpp" // lalr1.cc:859 break; - case 56: -#line 762 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 65: +#line 827 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Type::Ptr > () = yystack_[0].value.as< RelationType::Ptr > (); } -#line 1858 "GrammarParser.cpp" // lalr1.cc:859 +#line 1968 "GrammarParser.cpp" // lalr1.cc:859 break; - case 57: -#line 766 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 66: +#line 831 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Type::Ptr > () = yystack_[0].value.as< FixedSizedType::Ptr > (); } -#line 1866 "GrammarParser.cpp" // lalr1.cc:859 +#line 1976 "GrammarParser.cpp" // lalr1.cc:859 break; - case 58: -#line 774 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 67: +#line 839 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< BasicType::Ptr > () = Ast::make< BasicType >( yylhs.location, yystack_[0].value.as< IdentifierPath::Ptr > () ); } -#line 1874 "GrammarParser.cpp" // lalr1.cc:859 +#line 1984 "GrammarParser.cpp" // lalr1.cc:859 break; - case 59: -#line 782 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 68: +#line 847 "../../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 1882 "GrammarParser.cpp" // lalr1.cc:859 +#line 1992 "GrammarParser.cpp" // lalr1.cc:859 break; - case 60: -#line 790 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 69: +#line 855 "../../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 1890 "GrammarParser.cpp" // lalr1.cc:859 +#line 2000 "GrammarParser.cpp" // lalr1.cc:859 break; - case 61: -#line 798 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 70: +#line 863 "../../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 1898 "GrammarParser.cpp" // lalr1.cc:859 +#line 2008 "GrammarParser.cpp" // lalr1.cc:859 break; - case 62: -#line 806 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 71: +#line 871 "../../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 1908 "GrammarParser.cpp" // lalr1.cc:859 +#line 2018 "GrammarParser.cpp" // lalr1.cc:859 break; - case 63: -#line 812 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 72: +#line 877 "../../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 1918 "GrammarParser.cpp" // lalr1.cc:859 +#line 2028 "GrammarParser.cpp" // lalr1.cc:859 break; - case 64: -#line 822 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 73: +#line 887 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ReferenceAtom::Ptr > (); } -#line 1926 "GrammarParser.cpp" // lalr1.cc:859 +#line 2036 "GrammarParser.cpp" // lalr1.cc:859 break; - case 65: -#line 826 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 74: +#line 891 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ValueAtom::Ptr > (); } -#line 1934 "GrammarParser.cpp" // lalr1.cc:859 +#line 2044 "GrammarParser.cpp" // lalr1.cc:859 break; - case 66: -#line 830 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 75: +#line 895 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ValueAtom::Ptr > (); } -#line 1942 "GrammarParser.cpp" // lalr1.cc:859 +#line 2052 "GrammarParser.cpp" // lalr1.cc:859 break; - case 67: -#line 834 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 76: +#line 899 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ValueAtom::Ptr > (); } -#line 1950 "GrammarParser.cpp" // lalr1.cc:859 +#line 2060 "GrammarParser.cpp" // lalr1.cc:859 break; - case 68: -#line 838 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 77: +#line 903 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ValueAtom::Ptr > (); } -#line 1958 "GrammarParser.cpp" // lalr1.cc:859 +#line 2068 "GrammarParser.cpp" // lalr1.cc:859 break; - case 69: -#line 842 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 78: +#line 907 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ValueAtom::Ptr > (); } -#line 1966 "GrammarParser.cpp" // lalr1.cc:859 +#line 2076 "GrammarParser.cpp" // lalr1.cc:859 break; - case 70: -#line 846 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 79: +#line 911 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< UndefAtom::Ptr > (); } -#line 1974 "GrammarParser.cpp" // lalr1.cc:859 +#line 2084 "GrammarParser.cpp" // lalr1.cc:859 break; - case 71: -#line 850 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 80: +#line 915 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ValueAtom::Ptr > (); } -#line 1982 "GrammarParser.cpp" // lalr1.cc:859 +#line 2092 "GrammarParser.cpp" // lalr1.cc:859 break; - case 72: -#line 858 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 81: +#line 923 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< UndefAtom::Ptr > () = Ast::make< UndefAtom >( yylhs.location ); } -#line 1990 "GrammarParser.cpp" // lalr1.cc:859 +#line 2100 "GrammarParser.cpp" // lalr1.cc:859 break; - case 73: -#line 866 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 82: +#line 931 "../../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 1999 "GrammarParser.cpp" // lalr1.cc:859 +#line 2109 "GrammarParser.cpp" // lalr1.cc:859 break; - case 74: -#line 871 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 83: +#line 936 "../../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 2008 "GrammarParser.cpp" // lalr1.cc:859 +#line 2118 "GrammarParser.cpp" // lalr1.cc:859 break; - case 75: -#line 880 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 84: +#line 945 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { try { @@ -2020,11 +2130,11 @@ namespace libcasm_fe { throw syntax_error( yylhs.location, e.what() ); } } -#line 2024 "GrammarParser.cpp" // lalr1.cc:859 +#line 2134 "GrammarParser.cpp" // lalr1.cc:859 break; - case 76: -#line 896 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 85: +#line 961 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { try { @@ -2036,11 +2146,11 @@ namespace libcasm_fe { throw syntax_error( yylhs.location, e.what() ); } } -#line 2040 "GrammarParser.cpp" // lalr1.cc:859 +#line 2150 "GrammarParser.cpp" // lalr1.cc:859 break; - case 77: -#line 908 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 86: +#line 973 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { try { @@ -2052,11 +2162,11 @@ namespace libcasm_fe { throw syntax_error( yylhs.location, e.what() ); } } -#line 2056 "GrammarParser.cpp" // lalr1.cc:859 +#line 2166 "GrammarParser.cpp" // lalr1.cc:859 break; - case 78: -#line 924 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 87: +#line 989 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { try { @@ -2068,11 +2178,11 @@ namespace libcasm_fe { throw syntax_error( yylhs.location, e.what() ); } } -#line 2072 "GrammarParser.cpp" // lalr1.cc:859 +#line 2182 "GrammarParser.cpp" // lalr1.cc:859 break; - case 79: -#line 940 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 88: +#line 1005 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { try { @@ -2084,11 +2194,11 @@ namespace libcasm_fe { throw syntax_error( yylhs.location, e.what() ); } } -#line 2088 "GrammarParser.cpp" // lalr1.cc:859 +#line 2198 "GrammarParser.cpp" // lalr1.cc:859 break; - case 80: -#line 956 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 89: +#line 1021 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { try { @@ -2100,850 +2210,850 @@ namespace libcasm_fe { throw syntax_error( yylhs.location, e.what() ); } } -#line 2104 "GrammarParser.cpp" // lalr1.cc:859 +#line 2214 "GrammarParser.cpp" // lalr1.cc:859 break; - case 81: -#line 972 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 90: +#line 1037 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< ReferenceAtom::Ptr > () = Ast::make< ReferenceAtom >( yylhs.location, yystack_[0].value.as< IdentifierPath::Ptr > () ); } -#line 2112 "GrammarParser.cpp" // lalr1.cc:859 +#line 2222 "GrammarParser.cpp" // lalr1.cc:859 break; - case 82: -#line 980 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 91: +#line 1045 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< DirectCallExpression::Ptr > (); } -#line 2120 "GrammarParser.cpp" // lalr1.cc:859 +#line 2230 "GrammarParser.cpp" // lalr1.cc:859 break; - case 83: -#line 984 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 92: +#line 1049 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< IndirectCallExpression::Ptr > (); } -#line 2128 "GrammarParser.cpp" // lalr1.cc:859 +#line 2238 "GrammarParser.cpp" // lalr1.cc:859 break; - case 84: -#line 988 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 93: +#line 1053 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< LetExpression::Ptr > (); } -#line 2136 "GrammarParser.cpp" // lalr1.cc:859 +#line 2246 "GrammarParser.cpp" // lalr1.cc:859 break; - case 85: -#line 992 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 94: +#line 1057 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ConditionalExpression::Ptr > (); } -#line 2144 "GrammarParser.cpp" // lalr1.cc:859 +#line 2254 "GrammarParser.cpp" // lalr1.cc:859 break; - case 86: -#line 996 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 95: +#line 1061 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ChooseExpression::Ptr > (); } -#line 2152 "GrammarParser.cpp" // lalr1.cc:859 +#line 2262 "GrammarParser.cpp" // lalr1.cc:859 break; - case 87: -#line 1000 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 96: +#line 1065 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< UniversalQuantifierExpression::Ptr > (); } -#line 2160 "GrammarParser.cpp" // lalr1.cc:859 +#line 2270 "GrammarParser.cpp" // lalr1.cc:859 break; - case 88: -#line 1004 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 97: +#line 1069 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ExistentialQuantifierExpression::Ptr > (); } -#line 2168 "GrammarParser.cpp" // lalr1.cc:859 +#line 2278 "GrammarParser.cpp" // lalr1.cc:859 break; - case 89: -#line 1008 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 98: +#line 1073 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< Expression::Ptr > (); } -#line 2176 "GrammarParser.cpp" // lalr1.cc:859 +#line 2286 "GrammarParser.cpp" // lalr1.cc:859 break; - case 90: -#line 1012 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 99: +#line 1077 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ListExpression::Ptr > (); } -#line 2184 "GrammarParser.cpp" // lalr1.cc:859 +#line 2294 "GrammarParser.cpp" // lalr1.cc:859 break; - case 91: -#line 1016 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 100: +#line 1081 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< RangeExpression::Ptr > (); } -#line 2192 "GrammarParser.cpp" // lalr1.cc:859 +#line 2302 "GrammarParser.cpp" // lalr1.cc:859 break; - case 92: -#line 1020 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 101: +#line 1085 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< Expression::Ptr > (); } -#line 2200 "GrammarParser.cpp" // lalr1.cc:859 +#line 2310 "GrammarParser.cpp" // lalr1.cc:859 break; - case 93: -#line 1028 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 102: +#line 1093 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[1].value.as< Expression::Ptr > (); } -#line 2208 "GrammarParser.cpp" // lalr1.cc:859 +#line 2318 "GrammarParser.cpp" // lalr1.cc:859 break; - case 94: -#line 1032 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 103: +#line 1097 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = nullptr; } -#line 2216 "GrammarParser.cpp" // lalr1.cc:859 +#line 2326 "GrammarParser.cpp" // lalr1.cc:859 break; - case 95: -#line 1036 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 104: +#line 1101 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< Expression::Ptr > (); } -#line 2224 "GrammarParser.cpp" // lalr1.cc:859 +#line 2334 "GrammarParser.cpp" // lalr1.cc:859 break; - case 96: -#line 1040 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 105: +#line 1105 "../../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 2232 "GrammarParser.cpp" // lalr1.cc:859 +#line 2342 "GrammarParser.cpp" // lalr1.cc:859 break; - case 97: -#line 1044 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 106: +#line 1109 "../../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 2240 "GrammarParser.cpp" // lalr1.cc:859 +#line 2350 "GrammarParser.cpp" // lalr1.cc:859 break; - case 98: -#line 1048 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 107: +#line 1113 "../../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 2248 "GrammarParser.cpp" // lalr1.cc:859 +#line 2358 "GrammarParser.cpp" // lalr1.cc:859 break; - case 99: -#line 1052 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 108: +#line 1117 "../../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 2256 "GrammarParser.cpp" // lalr1.cc:859 +#line 2366 "GrammarParser.cpp" // lalr1.cc:859 break; - case 100: -#line 1056 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 109: +#line 1121 "../../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 2264 "GrammarParser.cpp" // lalr1.cc:859 +#line 2374 "GrammarParser.cpp" // lalr1.cc:859 break; - case 101: -#line 1060 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 110: +#line 1125 "../../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 2272 "GrammarParser.cpp" // lalr1.cc:859 +#line 2382 "GrammarParser.cpp" // lalr1.cc:859 break; - case 102: -#line 1064 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 111: +#line 1129 "../../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 2280 "GrammarParser.cpp" // lalr1.cc:859 +#line 2390 "GrammarParser.cpp" // lalr1.cc:859 break; - case 103: -#line 1068 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 112: +#line 1133 "../../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 2288 "GrammarParser.cpp" // lalr1.cc:859 +#line 2398 "GrammarParser.cpp" // lalr1.cc:859 break; - case 104: -#line 1072 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 113: +#line 1137 "../../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 2296 "GrammarParser.cpp" // lalr1.cc:859 +#line 2406 "GrammarParser.cpp" // lalr1.cc:859 break; - case 105: -#line 1076 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 114: +#line 1141 "../../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 2304 "GrammarParser.cpp" // lalr1.cc:859 +#line 2414 "GrammarParser.cpp" // lalr1.cc:859 break; - case 106: -#line 1080 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 115: +#line 1145 "../../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 2312 "GrammarParser.cpp" // lalr1.cc:859 +#line 2422 "GrammarParser.cpp" // lalr1.cc:859 break; - case 107: -#line 1084 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 116: +#line 1149 "../../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 2320 "GrammarParser.cpp" // lalr1.cc:859 +#line 2430 "GrammarParser.cpp" // lalr1.cc:859 break; - case 108: -#line 1088 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 117: +#line 1153 "../../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 2328 "GrammarParser.cpp" // lalr1.cc:859 +#line 2438 "GrammarParser.cpp" // lalr1.cc:859 break; - case 109: -#line 1092 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 118: +#line 1157 "../../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 2336 "GrammarParser.cpp" // lalr1.cc:859 +#line 2446 "GrammarParser.cpp" // lalr1.cc:859 break; - case 110: -#line 1096 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 119: +#line 1161 "../../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 2344 "GrammarParser.cpp" // lalr1.cc:859 +#line 2454 "GrammarParser.cpp" // lalr1.cc:859 break; - case 111: -#line 1100 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 120: +#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::AND_INSTRUCTION ); } -#line 2352 "GrammarParser.cpp" // lalr1.cc:859 +#line 2462 "GrammarParser.cpp" // lalr1.cc:859 break; - case 112: -#line 1104 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 121: +#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::IMP_INSTRUCTION ); } -#line 2360 "GrammarParser.cpp" // lalr1.cc:859 +#line 2470 "GrammarParser.cpp" // lalr1.cc:859 break; - case 113: -#line 1108 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 122: +#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::IMP_INSTRUCTION ); } -#line 2368 "GrammarParser.cpp" // lalr1.cc:859 +#line 2478 "GrammarParser.cpp" // lalr1.cc:859 break; - case 114: -#line 1112 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 123: +#line 1177 "../../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 2376 "GrammarParser.cpp" // lalr1.cc:859 +#line 2486 "GrammarParser.cpp" // lalr1.cc:859 break; - case 115: -#line 1120 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 124: +#line 1185 "../../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 2384 "GrammarParser.cpp" // lalr1.cc:859 +#line 2494 "GrammarParser.cpp" // lalr1.cc:859 break; - case 116: -#line 1128 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 125: +#line 1193 "../../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 2393 "GrammarParser.cpp" // lalr1.cc:859 +#line 2503 "GrammarParser.cpp" // lalr1.cc:859 break; - case 117: -#line 1133 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 126: +#line 1198 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< ListExpression::Ptr > () = Ast::make< ListExpression >( yylhs.location, yystack_[1].value.as< Expressions::Ptr > () ); } -#line 2401 "GrammarParser.cpp" // lalr1.cc:859 +#line 2511 "GrammarParser.cpp" // lalr1.cc:859 break; - case 118: -#line 1137 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 127: +#line 1202 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< ListExpression::Ptr > () = nullptr; } -#line 2409 "GrammarParser.cpp" // lalr1.cc:859 +#line 2519 "GrammarParser.cpp" // lalr1.cc:859 break; - case 119: -#line 1145 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 128: +#line 1210 "../../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 2419 "GrammarParser.cpp" // lalr1.cc:859 +#line 2529 "GrammarParser.cpp" // lalr1.cc:859 break; - case 120: -#line 1151 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 129: +#line 1216 "../../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 2429 "GrammarParser.cpp" // lalr1.cc:859 +#line 2539 "GrammarParser.cpp" // lalr1.cc:859 break; - case 121: -#line 1161 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 130: +#line 1226 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expressions::Ptr > () = yystack_[1].value.as< Expressions::Ptr > (); } -#line 2437 "GrammarParser.cpp" // lalr1.cc:859 +#line 2547 "GrammarParser.cpp" // lalr1.cc:859 break; - case 122: -#line 1165 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 131: +#line 1230 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expressions::Ptr > () = nullptr; } -#line 2445 "GrammarParser.cpp" // lalr1.cc:859 +#line 2555 "GrammarParser.cpp" // lalr1.cc:859 break; - case 123: -#line 1169 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 132: +#line 1234 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { const auto expressions = Ast::make< Expressions >( yylhs.location ); yylhs.value.as< Expressions::Ptr > () = expressions; } -#line 2454 "GrammarParser.cpp" // lalr1.cc:859 +#line 2564 "GrammarParser.cpp" // lalr1.cc:859 break; - case 124: -#line 1178 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 133: +#line 1243 "../../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 2464 "GrammarParser.cpp" // lalr1.cc:859 +#line 2574 "GrammarParser.cpp" // lalr1.cc:859 break; - case 125: -#line 1188 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 134: +#line 1253 "../../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 2473 "GrammarParser.cpp" // lalr1.cc:859 +#line 2583 "GrammarParser.cpp" // lalr1.cc:859 break; - case 126: -#line 1193 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 135: +#line 1258 "../../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 2481 "GrammarParser.cpp" // lalr1.cc:859 +#line 2591 "GrammarParser.cpp" // lalr1.cc:859 break; - case 127: -#line 1201 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 136: +#line 1266 "../../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 2489 "GrammarParser.cpp" // lalr1.cc:859 +#line 2599 "GrammarParser.cpp" // lalr1.cc:859 break; - case 128: -#line 1209 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 137: +#line 1274 "../../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 2497 "GrammarParser.cpp" // lalr1.cc:859 +#line 2607 "GrammarParser.cpp" // lalr1.cc:859 break; - case 129: -#line 1217 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 138: +#line 1282 "../../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 2505 "GrammarParser.cpp" // lalr1.cc:859 +#line 2615 "GrammarParser.cpp" // lalr1.cc:859 break; - case 130: -#line 1225 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 139: +#line 1290 "../../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 2513 "GrammarParser.cpp" // lalr1.cc:859 +#line 2623 "GrammarParser.cpp" // lalr1.cc:859 break; - case 131: -#line 1233 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 140: +#line 1298 "../../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 2521 "GrammarParser.cpp" // lalr1.cc:859 +#line 2631 "GrammarParser.cpp" // lalr1.cc:859 break; - case 132: -#line 1241 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 141: +#line 1306 "../../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 2529 "GrammarParser.cpp" // lalr1.cc:859 +#line 2639 "GrammarParser.cpp" // lalr1.cc:859 break; - case 133: -#line 1249 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 142: +#line 1314 "../../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 2538 "GrammarParser.cpp" // lalr1.cc:859 +#line 2648 "GrammarParser.cpp" // lalr1.cc:859 break; - case 134: -#line 1254 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 143: +#line 1319 "../../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 2547 "GrammarParser.cpp" // lalr1.cc:859 +#line 2657 "GrammarParser.cpp" // lalr1.cc:859 break; - case 135: -#line 1263 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 144: +#line 1328 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< SkipRule::Ptr > (); } -#line 2555 "GrammarParser.cpp" // lalr1.cc:859 +#line 2665 "GrammarParser.cpp" // lalr1.cc:859 break; - case 136: -#line 1267 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 145: +#line 1332 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< ConditionalRule::Ptr > (); } -#line 2563 "GrammarParser.cpp" // lalr1.cc:859 +#line 2673 "GrammarParser.cpp" // lalr1.cc:859 break; - case 137: -#line 1271 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 146: +#line 1336 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< CaseRule::Ptr > (); } -#line 2571 "GrammarParser.cpp" // lalr1.cc:859 +#line 2681 "GrammarParser.cpp" // lalr1.cc:859 break; - case 138: -#line 1275 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 147: +#line 1340 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< LetRule::Ptr > (); } -#line 2579 "GrammarParser.cpp" // lalr1.cc:859 +#line 2689 "GrammarParser.cpp" // lalr1.cc:859 break; - case 139: -#line 1279 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 148: +#line 1344 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< ForallRule::Ptr > (); } -#line 2587 "GrammarParser.cpp" // lalr1.cc:859 +#line 2697 "GrammarParser.cpp" // lalr1.cc:859 break; - case 140: -#line 1283 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 149: +#line 1348 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< ChooseRule::Ptr > (); } -#line 2595 "GrammarParser.cpp" // lalr1.cc:859 +#line 2705 "GrammarParser.cpp" // lalr1.cc:859 break; - case 141: -#line 1287 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 150: +#line 1352 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< IterateRule::Ptr > (); } -#line 2603 "GrammarParser.cpp" // lalr1.cc:859 +#line 2713 "GrammarParser.cpp" // lalr1.cc:859 break; - case 142: -#line 1291 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 151: +#line 1356 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< BlockRule::Ptr > (); } -#line 2611 "GrammarParser.cpp" // lalr1.cc:859 +#line 2721 "GrammarParser.cpp" // lalr1.cc:859 break; - case 143: -#line 1295 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 152: +#line 1360 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< SequenceRule::Ptr > (); } -#line 2619 "GrammarParser.cpp" // lalr1.cc:859 +#line 2729 "GrammarParser.cpp" // lalr1.cc:859 break; - case 144: -#line 1299 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 153: +#line 1364 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< UpdateRule::Ptr > (); } -#line 2627 "GrammarParser.cpp" // lalr1.cc:859 +#line 2737 "GrammarParser.cpp" // lalr1.cc:859 break; - case 145: -#line 1303 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 154: +#line 1368 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< CallRule::Ptr > (); } -#line 2635 "GrammarParser.cpp" // lalr1.cc:859 +#line 2745 "GrammarParser.cpp" // lalr1.cc:859 break; - case 146: -#line 1311 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 155: +#line 1376 "../../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 2645 "GrammarParser.cpp" // lalr1.cc:859 +#line 2755 "GrammarParser.cpp" // lalr1.cc:859 break; - case 147: -#line 1317 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 156: +#line 1382 "../../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 2655 "GrammarParser.cpp" // lalr1.cc:859 +#line 2765 "GrammarParser.cpp" // lalr1.cc:859 break; - case 148: -#line 1327 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 157: +#line 1392 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< SkipRule::Ptr > () = Ast::make< SkipRule >( yylhs.location ); } -#line 2663 "GrammarParser.cpp" // lalr1.cc:859 +#line 2773 "GrammarParser.cpp" // lalr1.cc:859 break; - case 149: -#line 1335 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 158: +#line 1400 "../../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 2671 "GrammarParser.cpp" // lalr1.cc:859 +#line 2781 "GrammarParser.cpp" // lalr1.cc:859 break; - case 150: -#line 1339 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 159: +#line 1404 "../../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 2679 "GrammarParser.cpp" // lalr1.cc:859 +#line 2789 "GrammarParser.cpp" // lalr1.cc:859 break; - case 151: -#line 1347 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 160: +#line 1412 "../../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 2687 "GrammarParser.cpp" // lalr1.cc:859 +#line 2797 "GrammarParser.cpp" // lalr1.cc:859 break; - case 152: -#line 1351 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 161: +#line 1416 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< CaseRule::Ptr > () = nullptr; } -#line 2695 "GrammarParser.cpp" // lalr1.cc:859 +#line 2805 "GrammarParser.cpp" // lalr1.cc:859 break; - case 153: -#line 1359 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 162: +#line 1424 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Case::Ptr > () = Ast::make< DefaultCase >( yylhs.location, yystack_[0].value.as< Rule::Ptr > () ); } -#line 2703 "GrammarParser.cpp" // lalr1.cc:859 +#line 2813 "GrammarParser.cpp" // lalr1.cc:859 break; - case 154: -#line 1363 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 163: +#line 1428 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Case::Ptr > () = Ast::make< DefaultCase >( yylhs.location, yystack_[0].value.as< Rule::Ptr > () ); } -#line 2711 "GrammarParser.cpp" // lalr1.cc:859 +#line 2821 "GrammarParser.cpp" // lalr1.cc:859 break; - case 155: -#line 1367 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 164: +#line 1432 "../../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 2719 "GrammarParser.cpp" // lalr1.cc:859 +#line 2829 "GrammarParser.cpp" // lalr1.cc:859 break; - case 156: -#line 1375 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 165: +#line 1440 "../../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 2729 "GrammarParser.cpp" // lalr1.cc:859 +#line 2839 "GrammarParser.cpp" // lalr1.cc:859 break; - case 157: -#line 1381 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 166: +#line 1446 "../../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 2739 "GrammarParser.cpp" // lalr1.cc:859 +#line 2849 "GrammarParser.cpp" // lalr1.cc:859 break; - case 158: -#line 1391 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 167: +#line 1456 "../../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 2747 "GrammarParser.cpp" // lalr1.cc:859 +#line 2857 "GrammarParser.cpp" // lalr1.cc:859 break; - case 159: -#line 1399 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 168: +#line 1464 "../../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 2755 "GrammarParser.cpp" // lalr1.cc:859 +#line 2865 "GrammarParser.cpp" // lalr1.cc:859 break; - case 160: -#line 1407 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 169: +#line 1472 "../../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 2763 "GrammarParser.cpp" // lalr1.cc:859 +#line 2873 "GrammarParser.cpp" // lalr1.cc:859 break; - case 161: -#line 1415 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 170: +#line 1480 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< IterateRule::Ptr > () = Ast::make< IterateRule >( yylhs.location, yystack_[0].value.as< Rule::Ptr > () ); } -#line 2771 "GrammarParser.cpp" // lalr1.cc:859 +#line 2881 "GrammarParser.cpp" // lalr1.cc:859 break; - case 162: -#line 1423 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 171: +#line 1488 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< BlockRule::Ptr > () = Ast::make< BlockRule >( yylhs.location, yystack_[1].value.as< Rules::Ptr > () ); } -#line 2779 "GrammarParser.cpp" // lalr1.cc:859 +#line 2889 "GrammarParser.cpp" // lalr1.cc:859 break; - case 163: -#line 1427 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 172: +#line 1492 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< BlockRule::Ptr > () = Ast::make< BlockRule >( yylhs.location, yystack_[1].value.as< Rules::Ptr > () ); } -#line 2787 "GrammarParser.cpp" // lalr1.cc:859 +#line 2897 "GrammarParser.cpp" // lalr1.cc:859 break; - case 164: -#line 1431 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 173: +#line 1496 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< BlockRule::Ptr > () = nullptr; yyerrok; } -#line 2796 "GrammarParser.cpp" // lalr1.cc:859 +#line 2906 "GrammarParser.cpp" // lalr1.cc:859 break; - case 165: -#line 1436 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 174: +#line 1501 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< BlockRule::Ptr > () = nullptr; yyerrok; } -#line 2805 "GrammarParser.cpp" // lalr1.cc:859 +#line 2915 "GrammarParser.cpp" // lalr1.cc:859 break; - case 166: -#line 1445 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 175: +#line 1510 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< SequenceRule::Ptr > () = Ast::make< SequenceRule >( yylhs.location, yystack_[1].value.as< Rules::Ptr > () ); } -#line 2813 "GrammarParser.cpp" // lalr1.cc:859 +#line 2923 "GrammarParser.cpp" // lalr1.cc:859 break; - case 167: -#line 1449 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 176: +#line 1514 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< SequenceRule::Ptr > () = Ast::make< SequenceRule >( yylhs.location, yystack_[1].value.as< Rules::Ptr > () ); } -#line 2821 "GrammarParser.cpp" // lalr1.cc:859 +#line 2931 "GrammarParser.cpp" // lalr1.cc:859 break; - case 168: -#line 1453 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 177: +#line 1518 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< SequenceRule::Ptr > () = nullptr; yyerrok; } -#line 2830 "GrammarParser.cpp" // lalr1.cc:859 +#line 2940 "GrammarParser.cpp" // lalr1.cc:859 break; - case 169: -#line 1458 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 178: +#line 1523 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< SequenceRule::Ptr > () = nullptr; yyerrok; } -#line 2839 "GrammarParser.cpp" // lalr1.cc:859 +#line 2949 "GrammarParser.cpp" // lalr1.cc:859 break; - case 170: -#line 1467 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 179: +#line 1532 "../../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 2849 "GrammarParser.cpp" // lalr1.cc:859 +#line 2959 "GrammarParser.cpp" // lalr1.cc:859 break; - case 171: -#line 1477 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 180: +#line 1542 "../../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 2859 "GrammarParser.cpp" // lalr1.cc:859 +#line 2969 "GrammarParser.cpp" // lalr1.cc:859 break; - case 172: -#line 1483 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 181: +#line 1548 "../../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 2870 "GrammarParser.cpp" // lalr1.cc:859 +#line 2980 "GrammarParser.cpp" // lalr1.cc:859 break; - case 173: -#line 1490 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 182: +#line 1555 "../../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 2880 "GrammarParser.cpp" // lalr1.cc:859 +#line 2990 "GrammarParser.cpp" // lalr1.cc:859 break; - case 174: -#line 1496 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 183: +#line 1561 "../../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 2891 "GrammarParser.cpp" // lalr1.cc:859 +#line 3001 "GrammarParser.cpp" // lalr1.cc:859 break; - case 175: -#line 1507 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 184: +#line 1572 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Attribute::Ptr > () = yystack_[0].value.as< BasicAttribute::Ptr > (); } -#line 2899 "GrammarParser.cpp" // lalr1.cc:859 +#line 3009 "GrammarParser.cpp" // lalr1.cc:859 break; - case 176: -#line 1511 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 185: +#line 1576 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Attribute::Ptr > () = yystack_[0].value.as< ExpressionAttribute::Ptr > (); } -#line 2907 "GrammarParser.cpp" // lalr1.cc:859 +#line 3017 "GrammarParser.cpp" // lalr1.cc:859 break; - case 177: -#line 1519 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 186: +#line 1584 "../../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 2917 "GrammarParser.cpp" // lalr1.cc:859 +#line 3027 "GrammarParser.cpp" // lalr1.cc:859 break; - case 178: -#line 1525 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 187: +#line 1590 "../../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 2927 "GrammarParser.cpp" // lalr1.cc:859 +#line 3037 "GrammarParser.cpp" // lalr1.cc:859 break; - case 179: -#line 1535 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 188: +#line 1600 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< BasicAttribute::Ptr > () = Ast::make< BasicAttribute >( yylhs.location, yystack_[0].value.as< Identifier::Ptr > () ); } -#line 2935 "GrammarParser.cpp" // lalr1.cc:859 +#line 3045 "GrammarParser.cpp" // lalr1.cc:859 break; - case 180: -#line 1543 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 189: +#line 1608 "../../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 2943 "GrammarParser.cpp" // lalr1.cc:859 +#line 3053 "GrammarParser.cpp" // lalr1.cc:859 break; -#line 2947 "GrammarParser.cpp" // lalr1.cc:859 +#line 3057 "GrammarParser.cpp" // lalr1.cc:859 default: break; } @@ -3198,591 +3308,606 @@ namespace libcasm_fe { } - const short int Parser::yypact_ninf_ = -177; + const short int Parser::yypact_ninf_ = -219; - const signed char Parser::yytable_ninf_ = -64; + const signed char Parser::yytable_ninf_ = -73; const short int Parser::yypact_[] = { - 13, 175, 50, -177, -6, -14, -14, -14, -14, -14, - -14, -177, -177, 409, -177, -177, -177, -177, -177, -177, - -177, -177, 944, -14, -177, -177, 6, -177, 15, 36, - 15, 25, 39, 1005, -177, -36, -177, -177, -177, -3, - -3, -3, 1005, -3, -177, -177, -177, 1005, 1005, 1005, - 388, 450, -5, -177, -177, -177, -177, -177, -177, -177, - 34, 42, 41, -177, -177, -177, -177, -177, -177, -177, - -177, -177, 1415, -177, -177, -177, 57, -177, -177, -177, - -177, -177, -177, -177, -177, -14, 7, 61, 40, -33, - -5, 75, 388, 1679, 441, -14, -14, 78, -177, 82, - 111, 112, 1214, 113, -177, -177, -177, 87, 1005, 1448, - 85, 93, -177, 1481, -9, -177, 944, -177, 512, -177, - 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, - 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, -177, - 99, -177, -27, -5, -14, 851, -5, 94, 88, 0, - -177, -177, -177, -177, -177, 43, 1448, -177, -177, 2, - -5, 1005, 1005, 1005, 1005, 1005, -177, 1514, -177, 1005, - -177, 1005, -177, 1005, -177, 107, -177, 1679, -8, 1783, - 1712, 1764, 281, 60, 60, 1802, 105, 105, 98, 98, - 98, -177, 1679, 281, 1802, 105, 105, 1679, -177, -177, - -3, 110, -177, 9, 549, 589, -177, -3, -3, -3, - 851, -16, 1005, 1005, 102, 626, 663, 100, -177, -177, - -177, -177, -177, -177, -177, -177, -177, -177, -177, -177, - -177, 124, -5, -5, -5, 1005, -177, 24, -14, -177, - 1032, 1349, 1103, 1283, 1382, 41, 1547, 1580, 1679, -177, - -177, -177, 1005, -177, -14, 155, -177, 700, 154, 737, - 128, 160, 169, -177, -177, -177, 1249, 1316, 123, 774, - 118, 814, 1005, 851, -177, 179, 127, 23, 28, 1745, - -177, 43, -177, 1005, 1005, 1005, 1005, 1005, -177, -177, - -177, 1679, -177, -177, -177, -177, -177, -177, 1005, 1005, - 1005, 851, 146, -177, -177, -177, -177, 1679, -177, 147, - 187, -5, -5, -177, -177, 1679, -177, 1679, 1679, -177, - 1065, 1141, 1179, 171, 326, 1005, 150, -177, 144, -177, - 851, 851, 851, 851, 151, 152, 156, 1613, 883, 159, - 1646, 944, -177, -177, -177, -177, -177, -177, 851, 851, - 851, -177, -177, -177, 161, -177, -177, -177, -177 + 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 }; const unsigned char Parser::yydefact_[] = { - 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, - 0, 10, 12, 0, 3, 14, 4, 6, 7, 5, - 1, 38, 33, 0, 37, 42, 43, 25, 53, 0, - 53, 0, 0, 179, 178, 0, 175, 176, 11, 0, - 0, 0, 0, 0, 72, 74, 73, 0, 0, 0, - 0, 0, 0, 76, 77, 78, 80, 79, 75, 31, - 32, 0, 125, 92, 70, 71, 69, 65, 66, 67, - 68, 64, 27, 89, 91, 90, 0, 82, 83, 84, - 85, 86, 87, 88, 44, 0, 0, 0, 0, 0, - 24, 0, 0, 180, 0, 0, 0, 46, 48, 0, - 0, 0, 0, 0, 114, 95, 96, 0, 0, 120, - 0, 0, 116, 120, 0, 81, 0, 26, 0, 126, + 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, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 41, - 0, 50, 0, 0, 0, 0, 0, 23, 0, 58, - 22, 54, 55, 56, 57, 0, 0, 9, 177, 0, - 0, 0, 0, 0, 0, 0, 94, 0, 93, 0, - 118, 0, 117, 0, 30, 0, 123, 120, 0, 111, - 109, 110, 113, 97, 98, 104, 105, 106, 99, 100, - 101, 102, 28, 112, 103, 107, 108, 29, 52, 51, - 0, 0, 40, 0, 0, 0, 148, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 172, 174, 133, - 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, - 145, 0, 0, 0, 24, 0, 16, 0, 0, 45, - 0, 0, 0, 0, 0, 0, 119, 0, 119, 122, - 121, 49, 0, 35, 0, 0, 147, 0, 0, 0, - 0, 0, 0, 161, 171, 173, 0, 0, 0, 0, - 0, 0, 0, 0, 21, 20, 0, 22, 0, 61, - 36, 0, 47, 0, 0, 0, 0, 0, 127, 124, - 115, 34, 39, 169, 167, 146, 165, 163, 0, 0, - 0, 0, 0, 164, 162, 168, 166, 170, 134, 0, - 18, 0, 0, 59, 15, 128, 131, 130, 129, 132, - 0, 0, 0, 149, 0, 0, 0, 13, 0, 62, - 0, 0, 0, 0, 0, 0, 0, 0, 157, 0, - 0, 33, 60, 158, 159, 160, 150, 152, 0, 0, - 0, 156, 151, 19, 0, 153, 154, 155, 17 + 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 }; const short int Parser::yypgoto_[] = { - -177, -177, 115, 191, -177, -154, -177, -177, -177, -177, - -29, -177, 95, -177, -129, -177, -177, -177, 26, -177, - 193, -4, -24, -34, -177, 188, -119, -177, -177, -177, - -177, -177, -177, -177, -177, -177, -177, -177, -177, -177, - -177, -28, -177, -177, -177, -48, -26, -177, -56, 32, - -177, -177, -177, -177, -177, -177, -19, -176, -177, -177, - -177, -177, -118, -177, -177, -177, -177, -177, -177, -177, - -177, 130, 126, -177, -177 + -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 }; const short int Parser::yydefgoto_[] = { - -1, 2, 11, 12, 13, 14, 237, 327, 310, 147, - 148, 15, 59, 60, 61, 16, 17, 18, 25, 203, - 26, 62, 98, 99, 142, 87, 150, 151, 152, 153, - 154, 278, 63, 64, 65, 66, 67, 68, 69, 70, - 71, 72, 73, 74, 75, 110, 119, 76, 77, 78, - 79, 80, 81, 82, 83, 19, 256, 257, 220, 221, - 222, 338, 339, 223, 224, 225, 226, 227, 228, 229, - 230, 34, 35, 36, 37 + -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 }; const short int Parser::yytable_[] = { - 27, 236, 21, 114, 21, 93, 100, 101, 140, 103, - 145, 94, 21, 21, 102, 21, 1, 95, 199, 104, - 105, 106, 109, 113, 201, 21, 200, 231, 214, 259, - 146, 28, 29, 30, 31, 32, 33, 250, 172, 269, - 271, 239, 22, 96, 173, 173, 23, 4, 115, 238, - 20, 8, 141, 96, 234, 95, 23, 23, 253, 86, - 235, 24, 254, 24, 156, 97, 97, 97, 85, 97, - 178, 24, 24, 280, 24, 90, -63, 281, -63, 88, - 167, 312, 91, 313, 24, 118, 149, 116, 144, 217, - 177, 117, 179, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 139, 97, 274, 275, 277, 129, 130, 131, 132, - 138, 33, 33, 155, 143, 161, 219, 314, 160, 162, - 163, 165, 166, 240, 241, 242, 243, 244, 169, 149, - 170, 246, 149, 247, 198, 248, 124, 125, 217, 217, - 232, 233, 249, 252, 217, 264, 149, 132, 108, 217, - 217, 129, 130, 131, 132, 272, 251, 273, 293, 296, - 202, 298, 303, 260, 261, 262, 3, 218, 299, 4, - 5, 6, 7, 8, 266, 267, 9, 300, 305, 309, - 311, 263, 328, 329, 324, 325, 326, 333, 341, 342, - 347, 217, 348, 217, 38, 276, 349, 279, 352, 157, - 358, 174, 354, 217, 282, 217, 84, 217, 89, 288, - 351, 10, 159, 0, 291, 158, 97, 0, 149, 149, - 149, 0, 0, 97, 97, 97, 218, 218, 295, 0, - 295, 0, 218, 265, 307, 217, 0, 218, 218, 0, - 295, 0, 295, 0, 308, 315, 316, 317, 318, 319, - 0, 0, 0, 0, 97, 0, 0, 0, 0, 0, - 320, 321, 322, 0, 217, 217, 217, 217, 0, 0, - 292, 0, 323, 0, 0, 0, 0, 0, 0, 218, - 0, 218, 217, 217, 217, 0, 337, 340, 0, 0, - 0, 218, 0, 218, 0, 218, 0, 149, 149, 0, - 337, 343, 344, 345, 346, 0, 0, 120, 121, 122, - 0, 0, 124, 125, 126, 0, 0, 334, 0, 355, - 356, 357, 0, 218, 0, 127, 128, 129, 130, 131, - 132, 0, 0, 39, 21, 40, 41, 135, 136, 137, - 42, 0, 0, 0, 0, 335, 0, 43, 0, 44, - 45, 46, 218, 218, 218, 218, 47, 48, 49, 0, - 92, 0, 51, 0, 0, 0, 0, 336, 52, 0, - 218, 218, 218, 0, 0, 0, 0, 0, 23, 107, - 0, 0, 0, 0, 0, 0, 0, 53, 54, 55, - 56, 57, 58, 24, 0, 39, 21, 40, 41, -2, - 3, 0, 42, 4, 5, 6, 7, 8, 0, 43, - 9, 44, 45, 46, 0, 0, 0, 0, 47, 48, - 49, 0, 92, 0, 51, 0, 0, 0, 0, 0, - 52, 0, 3, 0, 108, 4, 5, 6, 7, 8, - 23, 111, 9, 0, 0, 10, 0, 0, 0, 53, - 54, 55, 56, 57, 58, 24, 0, 39, 21, 40, - 41, 0, 0, 0, 42, 0, 0, 0, 0, 0, - 0, 43, 0, 44, 45, 46, 0, 0, 0, 0, - 47, 48, 49, 0, 92, 0, 51, 112, 0, 0, - 0, 0, 52, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 23, 175, 0, 0, 0, 0, 0, 0, - 0, 53, 54, 55, 56, 57, 58, 24, 0, 39, - 21, 40, 41, 0, 0, 0, 42, 0, 0, 0, - 0, 0, 0, 43, 0, 44, 45, 46, 0, 0, - 255, 0, 47, 48, 49, 0, 92, 176, 51, 0, - 0, 204, 0, 205, 52, 206, 207, 21, 208, 209, - 210, 0, 211, 212, 23, 0, 213, 0, 0, 0, - 0, 0, 0, 53, 54, 55, 56, 57, 58, 24, - 258, 0, 0, 214, 0, 0, 0, 215, 0, 0, - 0, 204, 0, 205, 0, 206, 207, 21, 208, 209, - 210, 23, 211, 212, 0, 0, 213, 0, 216, 0, - 0, 0, 0, 0, 0, 0, 24, 268, 0, 0, - 0, 0, 0, 214, 0, 0, 0, 215, 204, 0, - 205, 0, 206, 207, 21, 208, 209, 210, 0, 211, - 212, 23, 0, 213, 0, 0, 0, 0, 216, 0, - 0, 0, 0, 0, 270, 0, 24, 0, 0, 0, - 214, 0, 0, 0, 215, 204, 0, 205, 0, 206, - 207, 21, 208, 209, 210, 0, 211, 212, 23, 0, - 213, 0, 0, 0, 0, 216, 0, 0, 0, 0, - 0, 0, 0, 24, 0, 0, 0, 214, 0, 0, - 0, 215, 204, 294, 205, 0, 206, 207, 21, 208, - 209, 210, 0, 211, 212, 23, 0, 213, 0, 0, - 0, 0, 216, 0, 0, 0, 0, 0, 0, 0, - 24, 0, 0, 0, 214, 0, 0, 0, 215, 204, - 0, 205, 297, 206, 207, 21, 208, 209, 210, 0, - 211, 212, 23, 0, 213, 0, 0, 0, 0, 216, - 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, - 0, 214, 0, 0, 0, 215, 204, 0, 205, 0, - 206, 207, 21, 208, 209, 210, 0, 211, 212, 23, - 0, 213, 0, 0, 0, 0, 216, 0, 0, 0, - 0, 0, 0, 0, 24, 0, 0, 0, 214, 0, - 0, 0, 215, 304, 0, 0, 204, 0, 205, 0, - 206, 207, 21, 208, 209, 210, 23, 211, 212, 0, - 0, 213, 0, 216, 0, 0, 0, 0, 0, 0, - 0, 24, 0, 0, 0, 0, 0, 0, 214, 0, - 0, 0, 215, 204, 0, 205, 0, 206, 207, 21, - 208, 209, 210, 0, 211, 212, 23, 0, 213, 0, - 0, 0, 0, 216, 306, 0, 0, 0, 0, 0, - 0, 24, 0, 0, 0, 214, 0, 0, 0, 215, - 39, 21, 40, 41, 0, 0, 0, 42, 0, 0, - 0, 0, 335, 23, 43, 0, 44, 45, 46, 0, - 216, 0, 0, 47, 48, 49, 0, 92, 24, 51, - 0, 0, 0, 0, 336, 52, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 23, 0, 0, 0, 0, - 0, 0, 0, 0, 53, 54, 55, 56, 57, 58, - 24, 39, 21, 40, 41, 0, 0, 0, 42, 0, - 0, 0, 0, 0, 0, 43, 0, 44, 45, 46, - 0, 0, 0, 0, 47, 48, 49, 0, 50, 0, - 51, 0, 0, 0, 0, 0, 52, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 23, 0, 0, 0, - 0, 0, 0, 0, 0, 53, 54, 55, 56, 57, - 58, 24, 39, 21, 40, 41, 0, 0, 0, 42, - 0, 0, 0, 0, 0, 0, 43, 0, 44, 45, - 46, 0, 0, 0, 0, 47, 48, 49, 0, 92, - 283, 51, 0, 0, 0, 0, 0, 52, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 23, 120, 121, - 122, 123, 0, 124, 125, 126, 53, 54, 55, 56, - 57, 58, 24, 330, 0, 0, 127, 128, 129, 130, - 131, 132, 0, 0, 0, 0, 134, 0, 135, 136, - 137, 120, 121, 122, 123, 0, 124, 125, 126, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 127, - 128, 129, 130, 131, 132, 285, 0, 0, 0, 134, - 0, 135, 136, 137, 0, 0, 0, 0, 0, 120, - 121, 122, 123, 0, 124, 125, 126, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 127, 128, 129, - 130, 131, 132, 331, 0, 0, 0, 134, 0, 135, - 136, 137, 0, 0, 0, 0, 0, 120, 121, 122, - 123, 0, 124, 125, 126, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 127, 128, 129, 130, 131, - 132, 332, 0, 0, 0, 134, 0, 135, 136, 137, - 0, 0, 0, 0, 0, 120, 121, 122, 123, 0, - 124, 125, 126, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 127, 128, 129, 130, 131, 132, 164, - 0, 0, 0, 134, 0, 135, 136, 137, 0, 0, - 120, 121, 122, 123, 0, 124, 125, 126, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 127, 128, - 129, 130, 131, 132, 301, 0, 0, 0, 134, 0, - 135, 136, 137, 0, 0, 120, 121, 122, 123, 0, - 124, 125, 126, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 127, 128, 129, 130, 131, 132, 286, - 0, 0, 0, 134, 0, 135, 136, 137, 0, 120, - 121, 122, 123, 0, 124, 125, 126, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 127, 128, 129, - 130, 131, 132, 0, 302, 0, 0, 134, 0, 135, - 136, 137, 120, 121, 122, 123, 0, 124, 125, 126, + 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 127, 128, 129, 130, 131, 132, 0, 0, 0, 284, - 134, 0, 135, 136, 137, 120, 121, 122, 123, 0, - 124, 125, 126, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 127, 128, 129, 130, 131, 132, 0, - 0, 0, 0, 134, 287, 135, 136, 137, 120, 121, - 122, 123, 0, 124, 125, 126, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 127, 128, 129, 130, - 131, 132, 0, 0, 0, 0, 134, 0, 135, 136, - 137, 120, 121, 122, 123, 0, 124, 125, 126, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 127, - 128, 129, 130, 131, 132, 0, 0, 0, 133, 134, - 0, 135, 136, 137, 120, 121, 122, 123, 0, 124, - 125, 126, 0, 168, 0, 0, 0, 0, 0, 0, - 0, 0, 127, 128, 129, 130, 131, 132, 0, 0, - 0, 0, 134, 0, 135, 136, 137, 120, 121, 122, - 123, 0, 124, 125, 126, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 127, 128, 129, 130, 131, - 132, 0, 171, 0, 0, 134, 0, 135, 136, 137, - 120, 121, 122, 123, 0, 124, 125, 126, 0, 245, - 0, 0, 0, 0, 0, 0, 0, 0, 127, 128, - 129, 130, 131, 132, 0, 0, 0, 0, 134, 0, - 135, 136, 137, 120, 121, 122, 123, 0, 124, 125, - 126, 0, 289, 0, 0, 0, 0, 0, 0, 0, - 0, 127, 128, 129, 130, 131, 132, 0, 0, 0, - 0, 134, 0, 135, 136, 137, 120, 121, 122, 123, - 0, 124, 125, 126, 0, 0, 0, 290, 0, 0, - 0, 0, 0, 0, 127, 128, 129, 130, 131, 132, - 0, 0, 0, 0, 134, 0, 135, 136, 137, 120, - 121, 122, 123, 0, 124, 125, 126, 0, 0, 0, - 0, 0, 0, 350, 0, 0, 0, 127, 128, 129, - 130, 131, 132, 0, 0, 0, 0, 134, 0, 135, - 136, 137, 120, 121, 122, 123, 0, 124, 125, 126, - 0, 0, 0, 0, 0, 353, 0, 0, 0, 0, - 127, 128, 129, 130, 131, 132, 0, 0, 0, 0, - 134, 0, 135, 136, 137, 120, 121, 122, 123, 0, - 124, 125, 126, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 127, 128, 129, 130, 131, 132, 0, - 0, 0, 0, 134, 0, 135, 136, 137, 120, 0, - 122, 0, 0, 124, 125, 126, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 127, 128, 129, 130, - 131, 132, 0, 0, 0, 0, 0, 0, 135, 136, - 137, 120, 121, 122, 123, 0, 124, 125, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 127, - 120, 0, 130, 131, 132, 124, 125, 126, 0, 134, - 0, 135, 136, 137, 0, 0, 0, 0, 127, 128, - 129, 130, 131, 132, 124, 125, 126, 0, 0, 0, - 135, 136, 137, 0, 0, 0, 0, 127, 128, 129, - 130, 131, 132, 124, 125, 0, 0, 0, 0, 135, - 136, 137, 0, 0, 0, 0, 127, 128, 129, 130, - 131, 132, 0, 0, 0, 0, 0, 0, 0, 136, - 137 + 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 }; const short int Parser::yycheck_[] = { - 4, 155, 18, 51, 18, 33, 40, 41, 1, 43, - 43, 47, 18, 18, 42, 18, 3, 53, 45, 47, - 48, 49, 50, 51, 143, 18, 53, 146, 44, 205, - 63, 5, 6, 7, 8, 9, 10, 45, 47, 215, - 216, 160, 48, 46, 53, 53, 62, 4, 52, 47, - 0, 8, 86, 46, 54, 53, 62, 62, 49, 44, - 60, 77, 53, 77, 92, 39, 40, 41, 62, 43, - 118, 77, 77, 49, 77, 50, 53, 53, 55, 43, - 108, 53, 43, 55, 77, 44, 90, 53, 48, 145, - 118, 49, 120, 121, 122, 123, 124, 125, 126, 127, - 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, - 138, 85, 86, 232, 233, 234, 56, 57, 58, 59, - 63, 95, 96, 48, 63, 43, 145, 281, 50, 18, - 18, 18, 45, 161, 162, 163, 164, 165, 53, 143, - 47, 169, 146, 171, 45, 173, 41, 42, 204, 205, - 56, 63, 45, 43, 210, 211, 160, 59, 56, 215, - 216, 56, 57, 58, 59, 65, 200, 43, 13, 15, - 144, 43, 49, 207, 208, 209, 1, 145, 18, 4, - 5, 6, 7, 8, 212, 213, 11, 18, 70, 10, - 63, 210, 311, 312, 48, 48, 9, 26, 48, 55, - 49, 257, 50, 259, 13, 234, 50, 235, 49, 94, - 49, 116, 341, 269, 238, 271, 23, 273, 30, 245, - 338, 46, 96, -1, 252, 95, 200, -1, 232, 233, - 234, -1, -1, 207, 208, 209, 204, 205, 257, -1, - 259, -1, 210, 211, 272, 301, -1, 215, 216, -1, - 269, -1, 271, -1, 273, 283, 284, 285, 286, 287, - -1, -1, -1, -1, 238, -1, -1, -1, -1, -1, - 298, 299, 300, -1, 330, 331, 332, 333, -1, -1, - 254, -1, 301, -1, -1, -1, -1, -1, -1, 257, - -1, 259, 348, 349, 350, -1, 324, 325, -1, -1, - -1, 269, -1, 271, -1, 273, -1, 311, 312, -1, - 338, 330, 331, 332, 333, -1, -1, 36, 37, 38, - -1, -1, 41, 42, 43, -1, -1, 1, -1, 348, - 349, 350, -1, 301, -1, 54, 55, 56, 57, 58, - 59, -1, -1, 17, 18, 19, 20, 66, 67, 68, - 24, -1, -1, -1, -1, 29, -1, 31, -1, 33, - 34, 35, 330, 331, 332, 333, 40, 41, 42, -1, - 44, -1, 46, -1, -1, -1, -1, 51, 52, -1, - 348, 349, 350, -1, -1, -1, -1, -1, 62, 1, - -1, -1, -1, -1, -1, -1, -1, 71, 72, 73, - 74, 75, 76, 77, -1, 17, 18, 19, 20, 0, - 1, -1, 24, 4, 5, 6, 7, 8, -1, 31, - 11, 33, 34, 35, -1, -1, -1, -1, 40, 41, - 42, -1, 44, -1, 46, -1, -1, -1, -1, -1, - 52, -1, 1, -1, 56, 4, 5, 6, 7, 8, - 62, 1, 11, -1, -1, 46, -1, -1, -1, 71, - 72, 73, 74, 75, 76, 77, -1, 17, 18, 19, - 20, -1, -1, -1, 24, -1, -1, -1, -1, -1, - -1, 31, -1, 33, 34, 35, -1, -1, -1, -1, - 40, 41, 42, -1, 44, -1, 46, 47, -1, -1, - -1, -1, 52, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 62, 1, -1, -1, -1, -1, -1, -1, - -1, 71, 72, 73, 74, 75, 76, 77, -1, 17, - 18, 19, 20, -1, -1, -1, 24, -1, -1, -1, - -1, -1, -1, 31, -1, 33, 34, 35, -1, -1, - 1, -1, 40, 41, 42, -1, 44, 45, 46, -1, - -1, 12, -1, 14, 52, 16, 17, 18, 19, 20, - 21, -1, 23, 24, 62, -1, 27, -1, -1, -1, - -1, -1, -1, 71, 72, 73, 74, 75, 76, 77, - 1, -1, -1, 44, -1, -1, -1, 48, -1, -1, - -1, 12, -1, 14, -1, 16, 17, 18, 19, 20, - 21, 62, 23, 24, -1, -1, 27, -1, 69, -1, - -1, -1, -1, -1, -1, -1, 77, 1, -1, -1, - -1, -1, -1, 44, -1, -1, -1, 48, 12, -1, - 14, -1, 16, 17, 18, 19, 20, 21, -1, 23, - 24, 62, -1, 27, -1, -1, -1, -1, 69, -1, - -1, -1, -1, -1, 1, -1, 77, -1, -1, -1, - 44, -1, -1, -1, 48, 12, -1, 14, -1, 16, - 17, 18, 19, 20, 21, -1, 23, 24, 62, -1, - 27, -1, -1, -1, -1, 69, -1, -1, -1, -1, - -1, -1, -1, 77, -1, -1, -1, 44, -1, -1, - -1, 48, 12, 13, 14, -1, 16, 17, 18, 19, - 20, 21, -1, 23, 24, 62, -1, 27, -1, -1, - -1, -1, 69, -1, -1, -1, -1, -1, -1, -1, - 77, -1, -1, -1, 44, -1, -1, -1, 48, 12, - -1, 14, 15, 16, 17, 18, 19, 20, 21, -1, - 23, 24, 62, -1, 27, -1, -1, -1, -1, 69, - -1, -1, -1, -1, -1, -1, -1, 77, -1, -1, - -1, 44, -1, -1, -1, 48, 12, -1, 14, -1, - 16, 17, 18, 19, 20, 21, -1, 23, 24, 62, - -1, 27, -1, -1, -1, -1, 69, -1, -1, -1, - -1, -1, -1, -1, 77, -1, -1, -1, 44, -1, - -1, -1, 48, 49, -1, -1, 12, -1, 14, -1, - 16, 17, 18, 19, 20, 21, 62, 23, 24, -1, - -1, 27, -1, 69, -1, -1, -1, -1, -1, -1, - -1, 77, -1, -1, -1, -1, -1, -1, 44, -1, - -1, -1, 48, 12, -1, 14, -1, 16, 17, 18, - 19, 20, 21, -1, 23, 24, 62, -1, 27, -1, - -1, -1, -1, 69, 70, -1, -1, -1, -1, -1, - -1, 77, -1, -1, -1, 44, -1, -1, -1, 48, - 17, 18, 19, 20, -1, -1, -1, 24, -1, -1, - -1, -1, 29, 62, 31, -1, 33, 34, 35, -1, - 69, -1, -1, 40, 41, 42, -1, 44, 77, 46, - -1, -1, -1, -1, 51, 52, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 62, -1, -1, -1, -1, - -1, -1, -1, -1, 71, 72, 73, 74, 75, 76, - 77, 17, 18, 19, 20, -1, -1, -1, 24, -1, - -1, -1, -1, -1, -1, 31, -1, 33, 34, 35, - -1, -1, -1, -1, 40, 41, 42, -1, 44, -1, - 46, -1, -1, -1, -1, -1, 52, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, - -1, -1, -1, -1, -1, 71, 72, 73, 74, 75, - 76, 77, 17, 18, 19, 20, -1, -1, -1, 24, - -1, -1, -1, -1, -1, -1, 31, -1, 33, 34, - 35, -1, -1, -1, -1, 40, 41, 42, -1, 44, - 18, 46, -1, -1, -1, -1, -1, 52, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 62, 36, 37, - 38, 39, -1, 41, 42, 43, 71, 72, 73, 74, - 75, 76, 77, 18, -1, -1, 54, 55, 56, 57, - 58, 59, -1, -1, -1, -1, 64, -1, 66, 67, - 68, 36, 37, 38, 39, -1, 41, 42, 43, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 54, - 55, 56, 57, 58, 59, 22, -1, -1, -1, 64, - -1, 66, 67, 68, -1, -1, -1, -1, -1, 36, - 37, 38, 39, -1, 41, 42, 43, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 54, 55, 56, - 57, 58, 59, 22, -1, -1, -1, 64, -1, 66, - 67, 68, -1, -1, -1, -1, -1, 36, 37, 38, - 39, -1, 41, 42, 43, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 54, 55, 56, 57, 58, - 59, 22, -1, -1, -1, 64, -1, 66, 67, 68, - -1, -1, -1, -1, -1, 36, 37, 38, 39, -1, - 41, 42, 43, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 54, 55, 56, 57, 58, 59, 25, - -1, -1, -1, 64, -1, 66, 67, 68, -1, -1, - 36, 37, 38, 39, -1, 41, 42, 43, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 54, 55, - 56, 57, 58, 59, 25, -1, -1, -1, 64, -1, - 66, 67, 68, -1, -1, 36, 37, 38, 39, -1, - 41, 42, 43, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 54, 55, 56, 57, 58, 59, 26, - -1, -1, -1, 64, -1, 66, 67, 68, -1, 36, - 37, 38, 39, -1, 41, 42, 43, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 54, 55, 56, - 57, 58, 59, -1, 28, -1, -1, 64, -1, 66, - 67, 68, 36, 37, 38, 39, -1, 41, 42, 43, + 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, + -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, - 54, 55, 56, 57, 58, 59, -1, -1, -1, 30, - 64, -1, 66, 67, 68, 36, 37, 38, 39, -1, - 41, 42, 43, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 54, 55, 56, 57, 58, 59, -1, - -1, -1, -1, 64, 32, 66, 67, 68, 36, 37, - 38, 39, -1, 41, 42, 43, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 54, 55, 56, 57, - 58, 59, -1, -1, -1, -1, 64, -1, 66, 67, - 68, 36, 37, 38, 39, -1, 41, 42, 43, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 54, - 55, 56, 57, 58, 59, -1, -1, -1, 63, 64, - -1, 66, 67, 68, 36, 37, 38, 39, -1, 41, - 42, 43, -1, 45, -1, -1, -1, -1, -1, -1, - -1, -1, 54, 55, 56, 57, 58, 59, -1, -1, - -1, -1, 64, -1, 66, 67, 68, 36, 37, 38, - 39, -1, 41, 42, 43, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 54, 55, 56, 57, 58, - 59, -1, 61, -1, -1, 64, -1, 66, 67, 68, - 36, 37, 38, 39, -1, 41, 42, 43, -1, 45, - -1, -1, -1, -1, -1, -1, -1, -1, 54, 55, - 56, 57, 58, 59, -1, -1, -1, -1, 64, -1, - 66, 67, 68, 36, 37, 38, 39, -1, 41, 42, - 43, -1, 45, -1, -1, -1, -1, -1, -1, -1, - -1, 54, 55, 56, 57, 58, 59, -1, -1, -1, - -1, 64, -1, 66, 67, 68, 36, 37, 38, 39, - -1, 41, 42, 43, -1, -1, -1, 47, -1, -1, - -1, -1, -1, -1, 54, 55, 56, 57, 58, 59, - -1, -1, -1, -1, 64, -1, 66, 67, 68, 36, - 37, 38, 39, -1, 41, 42, 43, -1, -1, -1, - -1, -1, -1, 50, -1, -1, -1, 54, 55, 56, - 57, 58, 59, -1, -1, -1, -1, 64, -1, 66, - 67, 68, 36, 37, 38, 39, -1, 41, 42, 43, - -1, -1, -1, -1, -1, 49, -1, -1, -1, -1, - 54, 55, 56, 57, 58, 59, -1, -1, -1, -1, - 64, -1, 66, 67, 68, 36, 37, 38, 39, -1, - 41, 42, 43, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 54, 55, 56, 57, 58, 59, -1, - -1, -1, -1, 64, -1, 66, 67, 68, 36, -1, - 38, -1, -1, 41, 42, 43, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 54, 55, 56, 57, - 58, 59, -1, -1, -1, -1, -1, -1, 66, 67, - 68, 36, 37, 38, 39, -1, 41, 42, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 54, - 36, -1, 57, 58, 59, 41, 42, 43, -1, 64, - -1, 66, 67, 68, -1, -1, -1, -1, 54, 55, - 56, 57, 58, 59, 41, 42, 43, -1, -1, -1, - 66, 67, 68, -1, -1, -1, -1, 54, 55, 56, - 57, 58, 59, 41, 42, -1, -1, -1, -1, 66, - 67, 68, -1, -1, -1, -1, 54, 55, 56, 57, - 58, 59, -1, -1, -1, -1, -1, -1, -1, 67, - 68 + 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 }; const unsigned char Parser::yystos_[] = { - 0, 3, 83, 1, 4, 5, 6, 7, 8, 11, - 46, 84, 85, 86, 87, 93, 97, 98, 99, 137, - 0, 18, 48, 62, 77, 100, 102, 103, 100, 100, - 100, 100, 100, 100, 153, 154, 155, 156, 85, 17, - 19, 20, 24, 31, 33, 34, 35, 40, 41, 42, - 44, 46, 52, 71, 72, 73, 74, 75, 76, 94, - 95, 96, 103, 114, 115, 116, 117, 118, 119, 120, - 121, 122, 123, 124, 125, 126, 129, 130, 131, 132, - 133, 134, 135, 136, 102, 62, 44, 107, 43, 107, - 50, 43, 44, 123, 47, 53, 46, 100, 104, 105, - 105, 105, 123, 105, 123, 123, 123, 1, 56, 123, - 127, 1, 47, 123, 127, 103, 53, 49, 44, 128, - 36, 37, 38, 39, 41, 42, 43, 54, 55, 56, - 57, 58, 59, 63, 64, 66, 67, 68, 63, 100, - 1, 105, 106, 63, 48, 43, 63, 91, 92, 103, - 108, 109, 110, 111, 112, 48, 123, 84, 153, 154, - 50, 43, 18, 18, 25, 18, 45, 123, 45, 53, - 47, 61, 47, 53, 94, 1, 45, 123, 127, 123, - 123, 123, 123, 123, 123, 123, 123, 123, 123, 123, - 123, 123, 123, 123, 123, 123, 123, 123, 45, 45, - 53, 108, 100, 101, 12, 14, 16, 17, 19, 20, - 21, 23, 24, 27, 44, 48, 69, 130, 131, 138, - 140, 141, 142, 145, 146, 147, 148, 149, 150, 151, - 152, 108, 56, 63, 54, 60, 87, 88, 47, 108, - 123, 123, 123, 123, 123, 45, 123, 123, 123, 45, - 45, 105, 43, 49, 53, 1, 138, 139, 1, 139, - 105, 105, 105, 138, 130, 131, 123, 123, 1, 139, - 1, 139, 65, 43, 108, 108, 92, 108, 113, 123, - 49, 53, 104, 18, 30, 22, 26, 32, 128, 45, - 47, 123, 100, 13, 13, 138, 15, 15, 43, 18, - 18, 25, 28, 49, 49, 70, 70, 123, 138, 10, - 90, 63, 53, 55, 87, 123, 123, 123, 123, 123, - 123, 123, 123, 138, 48, 48, 9, 89, 108, 108, - 18, 22, 22, 26, 1, 29, 51, 123, 143, 144, - 123, 48, 55, 138, 138, 138, 138, 49, 50, 50, - 50, 144, 49, 49, 96, 138, 138, 138, 49 + 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 }; const unsigned char Parser::yyr1_[] = { - 0, 82, 83, 84, 84, 84, 84, 84, 84, 85, - 85, 86, 86, 87, 87, 88, 88, 89, 89, 90, - 90, 91, 91, 92, 92, 93, 93, 94, 94, 94, - 95, 95, 96, 96, 97, 98, 99, 100, 100, 101, - 101, 102, 102, 103, 103, 104, 104, 105, 105, 106, - 106, 107, 107, 107, 108, 108, 108, 108, 109, 110, - 111, 112, 113, 113, 114, 114, 114, 114, 114, 114, - 114, 114, 115, 116, 116, 117, 118, 118, 119, 120, - 121, 122, 123, 123, 123, 123, 123, 123, 123, 123, - 123, 123, 123, 124, 124, 124, 124, 124, 124, 124, - 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, - 124, 124, 124, 124, 124, 125, 126, 126, 126, 127, - 127, 128, 128, 128, 129, 130, 130, 131, 132, 133, - 134, 135, 136, 137, 137, 138, 138, 138, 138, 138, - 138, 138, 138, 138, 138, 138, 139, 139, 140, 141, - 141, 142, 142, 143, 143, 143, 144, 144, 145, 146, - 147, 148, 149, 149, 149, 149, 150, 150, 150, 150, - 151, 152, 152, 152, 152, 153, 153, 154, 154, 155, - 156 + 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 }; const unsigned char Parser::yyr2_[] = { - 0, 2, 2, 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, 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, + 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, 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, + 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 3, 3, 2, 2, 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, 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 }; @@ -3794,8 +3919,8 @@ namespace libcasm_fe { { "\"end of file\"", "error", "$undefined", "\"CASM\"", "\"init\"", "\"derived\"", "\"enum\"", "\"rule\"", "\"function\"", "\"initially\"", - "\"defined\"", "\"structure\"", "\"seq\"", "\"endseq\"", "\"par\"", - "\"endpar\"", "\"skip\"", "\"let\"", "\"in\"", "\"forall\"", + "\"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\"", @@ -3812,7 +3937,9 @@ namespace libcasm_fe { "FunctionParameters", "MaybeFunctionParameters", "ProgramFunctionDefinition", "Initializer", "Initializers", "MaybeInitializers", "DerivedDefinition", "EnumerationDefinition", - "StructureDefinition", "Identifier", "Identifiers", + "StructureDefinition", "FeatureDefinition", + "FeatureDeclarationOrDefinition", "FeatureDeclarationsAndDefinitions", + "DeclarationDefinition", "Identifier", "Identifiers", "DotSeparatedIdentifiers", "IdentifierPath", "Variable", "AttributedVariable", "Parameters", "MaybeParameters", "Type", "BasicType", "ComposedType", "RelationType", "FixedSizedType", "Types", @@ -3833,25 +3960,25 @@ namespace libcasm_fe { const unsigned short int Parser::yyrline_[] = { - 0, 354, 354, 366, 370, 374, 378, 382, 386, 394, - 400, 408, 414, 424, 440, 448, 454, 464, 468, 476, - 480, 488, 494, 504, 508, 516, 539, 557, 565, 575, - 586, 592, 602, 606, 614, 622, 630, 638, 642, 650, - 656, 666, 672, 682, 686, 694, 698, 707, 713, 721, - 727, 737, 741, 745, 753, 757, 761, 765, 773, 781, - 789, 797, 805, 811, 821, 825, 829, 833, 837, 841, - 845, 849, 857, 865, 870, 879, 895, 907, 923, 939, - 955, 971, 979, 983, 987, 991, 995, 999, 1003, 1007, - 1011, 1015, 1019, 1027, 1031, 1035, 1039, 1043, 1047, 1051, - 1055, 1059, 1063, 1067, 1071, 1075, 1079, 1083, 1087, 1091, - 1095, 1099, 1103, 1107, 1111, 1119, 1127, 1132, 1136, 1144, - 1150, 1160, 1164, 1168, 1177, 1187, 1192, 1200, 1208, 1216, - 1224, 1232, 1240, 1248, 1253, 1262, 1266, 1270, 1274, 1278, - 1282, 1286, 1290, 1294, 1298, 1302, 1310, 1316, 1326, 1334, - 1338, 1346, 1350, 1358, 1362, 1366, 1374, 1380, 1390, 1398, - 1406, 1414, 1422, 1426, 1430, 1435, 1444, 1448, 1452, 1457, - 1466, 1476, 1482, 1489, 1495, 1506, 1510, 1518, 1524, 1534, - 1542 + 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 }; // Print the state stack on the debug stream. @@ -3886,8 +4013,8 @@ namespace libcasm_fe { #line 31 "../../obj/src/GrammarParser.yy" // lalr1.cc:1167 } // libcasm_fe -#line 3890 "GrammarParser.cpp" // lalr1.cc:1167 -#line 1548 "../../obj/src/GrammarParser.yy" // lalr1.cc:1168 +#line 4017 "GrammarParser.cpp" // lalr1.cc:1167 +#line 1613 "../../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 577f2b9f0..73b69d2e6 100644 --- a/src/various/GrammarParser.output +++ b/src/various/GrammarParser.output @@ -9,496 +9,518 @@ Grammar 4 | RuleDefinition 5 | EnumerationDefinition 6 | StructureDefinition - 7 | error + 7 | FeatureDefinition + 8 | error - 8 AttributedDefinition: "[" Attributes "]" Definition - 9 | Definition + 9 AttributedDefinition: "[" Attributes "]" Definition + 10 | Definition - 10 Definitions: Definitions AttributedDefinition - 11 | AttributedDefinition + 11 Definitions: Definitions AttributedDefinition + 12 | AttributedDefinition - 12 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially - 13 | ProgramFunctionDefinition + 13 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially + 14 | ProgramFunctionDefinition - 14 FunctionDefinitions: FunctionDefinitions "," FunctionDefinition - 15 | FunctionDefinition + 15 FunctionDefinitions: FunctionDefinitions "," FunctionDefinition + 16 | FunctionDefinition - 16 MaybeInitially: "initially" "{" MaybeInitializers "}" - 17 | %empty + 17 MaybeInitially: "initially" "{" MaybeInitializers "}" + 18 | %empty - 18 MaybeDefined: "defined" "{" Term "}" - 19 | %empty + 19 MaybeDefined: "defined" "{" Term "}" + 20 | %empty - 20 FunctionParameters: FunctionParameters "*" Type - 21 | Type + 21 FunctionParameters: FunctionParameters "*" Type + 22 | Type - 22 MaybeFunctionParameters: FunctionParameters - 23 | %empty + 23 MaybeFunctionParameters: FunctionParameters + 24 | %empty - 24 ProgramFunctionDefinition: "init" IdentifierPath - 25 | "init" "{" MaybeInitializers "}" + 25 ProgramFunctionDefinition: "init" IdentifierPath + 26 | "init" "{" MaybeInitializers "}" - 26 Initializer: Term - 27 | Term "->" Term - 28 | TwoOrMoreArguments "->" Term + 27 Initializer: Term + 28 | Term "->" Term + 29 | TwoOrMoreArguments "->" Term - 29 Initializers: Initializers "," Initializer - 30 | Initializer + 30 Initializers: Initializers "," Initializer + 31 | Initializer - 31 MaybeInitializers: Initializers - 32 | %empty + 32 MaybeInitializers: Initializers + 33 | %empty - 33 DerivedDefinition: "derived" Identifier MaybeParameters "->" Type "=" Term + 34 DerivedDefinition: "derived" Identifier MaybeParameters "->" Type "=" Term - 34 EnumerationDefinition: "enum" Identifier "=" "{" Identifiers "}" + 35 EnumerationDefinition: "enum" Identifier "=" "{" Identifiers "}" - 35 StructureDefinition: "structure" Identifier "=" "{" FunctionDefinitions "}" + 36 StructureDefinition: "structure" Identifier "=" "{" FunctionDefinitions "}" - 36 Identifier: "identifier" - 37 | "in" + 37 FeatureDefinition: "feature" Identifier "=" "{" FeatureDeclarationsAndDefinitions "}" - 38 Identifiers: Identifiers "," Identifier - 39 | Identifier + 38 FeatureDeclarationOrDefinition: DeclarationDefinition + 39 | DerivedDefinition + 40 | RuleDefinition - 40 DotSeparatedIdentifiers: DotSeparatedIdentifiers "." Identifier - 41 | Identifier + 41 FeatureDeclarationsAndDefinitions: FeatureDeclarationsAndDefinitions "," FeatureDeclarationOrDefinition + 42 | FeatureDeclarationOrDefinition - 42 IdentifierPath: DotSeparatedIdentifiers - 43 | "." DotSeparatedIdentifiers + 43 DeclarationDefinition: "derived" Identifier ":" MaybeFunctionParameters "->" Type + 44 | "rule" Identifier ":" MaybeFunctionParameters "->" Type - 44 Variable: Identifier ":" Type - 45 | Identifier + 45 Identifier: "identifier" + 46 | "in" - 46 AttributedVariable: "[" Attributes "]" Variable - 47 | Variable + 47 Identifiers: Identifiers "," Identifier + 48 | Identifier - 48 Parameters: Parameters "," AttributedVariable - 49 | AttributedVariable + 49 DotSeparatedIdentifiers: DotSeparatedIdentifiers "." Identifier + 50 | Identifier - 50 MaybeParameters: "(" Parameters ")" - 51 | "(" error ")" - 52 | %empty + 51 IdentifierPath: DotSeparatedIdentifiers + 52 | "." DotSeparatedIdentifiers - 53 Type: BasicType - 54 | ComposedType - 55 | RelationType - 56 | FixedSizedType + 53 Variable: Identifier ":" Type + 54 | Identifier - 57 BasicType: IdentifierPath + 55 AttributedVariable: "[" Attributes "]" Variable + 56 | Variable - 58 ComposedType: IdentifierPath "<" Types ">" + 57 Parameters: Parameters "," AttributedVariable + 58 | AttributedVariable - 59 RelationType: IdentifierPath "<" MaybeFunctionParameters "->" Type ">" + 59 MaybeParameters: "(" Parameters ")" + 60 | "(" error ")" + 61 | %empty - 60 FixedSizedType: IdentifierPath "'" Term + 62 Type: BasicType + 63 | ComposedType + 64 | RelationType + 65 | FixedSizedType - 61 Types: Types "," Type - 62 | Type + 66 BasicType: IdentifierPath - 63 Atom: Reference - 64 | BitNumber - 65 | IntegerNumber - 66 | FloatingNumber - 67 | RationalNumber - 68 | String - 69 | Undefined - 70 | Boolean + 67 ComposedType: IdentifierPath "<" Types ">" - 71 Undefined: "undef" + 68 RelationType: IdentifierPath "<" MaybeFunctionParameters "->" Type ">" - 72 Boolean: "true" - 73 | "false" + 69 FixedSizedType: IdentifierPath "'" Term - 74 String: "string" + 70 Types: Types "," Type + 71 | Type - 75 BitNumber: "binary" - 76 | "hexadecimal" + 72 Atom: Reference + 73 | BitNumber + 74 | IntegerNumber + 75 | FloatingNumber + 76 | RationalNumber + 77 | String + 78 | Undefined + 79 | Boolean - 77 IntegerNumber: "integer" + 80 Undefined: "undef" - 78 FloatingNumber: "floating" + 81 Boolean: "true" + 82 | "false" - 79 RationalNumber: "rational" + 83 String: "string" - 80 Reference: "@" IdentifierPath + 84 BitNumber: "binary" + 85 | "hexadecimal" - 81 Term: DirectCallExpression - 82 | IndirectCallExpression - 83 | LetExpression - 84 | ConditionalExpression - 85 | ChooseExpression - 86 | UniversalQuantifierExpression - 87 | ExistentialQuantifierExpression - 88 | Expression - 89 | List - 90 | Range - 91 | Atom + 86 IntegerNumber: "integer" - 92 Expression: "(" Term ")" - 93 | "(" error ")" - 94 | "+" Term - 95 | "-" Term - 96 | Term "+" Term - 97 | Term "-" Term - 98 | Term "*" Term - 99 | Term "/" Term - 100 | Term "%" Term - 101 | Term "^" Term - 102 | Term "!=" Term - 103 | Term "=" Term - 104 | Term "<" Term - 105 | Term ">" Term - 106 | Term "<=" Term - 107 | Term ">=" Term - 108 | Term "or" Term - 109 | Term "xor" Term - 110 | Term "and" Term - 111 | Term "=>" Term - 112 | Term "implies" Term - 113 | "not" Term + 87 FloatingNumber: "floating" - 114 Range: "[" Term ".." Term "]" + 88 RationalNumber: "rational" - 115 List: "[" "]" - 116 | "[" Terms "]" - 117 | "[" error "]" + 89 Reference: "@" IdentifierPath - 118 Terms: Terms "," Term - 119 | Term + 90 Term: DirectCallExpression + 91 | IndirectCallExpression + 92 | LetExpression + 93 | ConditionalExpression + 94 | ChooseExpression + 95 | UniversalQuantifierExpression + 96 | ExistentialQuantifierExpression + 97 | Expression + 98 | List + 99 | Range + 100 | Atom - 120 Arguments: "(" Terms ")" - 121 | "(" error ")" - 122 | "(" ")" + 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 - 123 TwoOrMoreArguments: "(" Terms "," Term ")" + 123 Range: "[" Term ".." Term "]" - 124 DirectCallExpression: IdentifierPath - 125 | IdentifierPath Arguments + 124 List: "[" "]" + 125 | "[" Terms "]" + 126 | "[" error "]" - 126 IndirectCallExpression: "(" "*" Term ")" Arguments + 127 Terms: Terms "," Term + 128 | Term - 127 LetExpression: "let" AttributedVariable "=" Term "in" Term + 129 Arguments: "(" Terms ")" + 130 | "(" error ")" + 131 | "(" ")" - 128 ConditionalExpression: "if" Term "then" Term "else" Term + 132 TwoOrMoreArguments: "(" Terms "," Term ")" - 129 ChooseExpression: "choose" AttributedVariable "in" Term "do" Term + 133 DirectCallExpression: IdentifierPath + 134 | IdentifierPath Arguments - 130 UniversalQuantifierExpression: "forall" AttributedVariable "in" Term "holds" Term + 135 IndirectCallExpression: "(" "*" Term ")" Arguments - 131 ExistentialQuantifierExpression: "exists" AttributedVariable "in" Term "with" Term + 136 LetExpression: "let" AttributedVariable "=" Term "in" Term - 132 RuleDefinition: "rule" Identifier MaybeParameters "=" Rule - 133 | "rule" Identifier MaybeParameters "->" Type "=" Rule + 137 ConditionalExpression: "if" Term "then" Term "else" Term - 134 Rule: SkipRule - 135 | ConditionalRule - 136 | CaseRule - 137 | LetRule - 138 | ForallRule - 139 | ChooseRule - 140 | IterateRule - 141 | BlockRule - 142 | SequenceRule - 143 | UpdateRule - 144 | CallRule + 138 ChooseExpression: "choose" AttributedVariable "in" Term "do" Term - 145 Rules: Rules Rule - 146 | Rule + 139 UniversalQuantifierExpression: "forall" AttributedVariable "in" Term "holds" Term - 147 SkipRule: "skip" + 140 ExistentialQuantifierExpression: "exists" AttributedVariable "in" Term "with" Term - 148 ConditionalRule: "if" Term "then" Rule - 149 | "if" Term "then" Rule "else" Rule + 141 RuleDefinition: "rule" Identifier MaybeParameters "=" Rule + 142 | "rule" Identifier MaybeParameters "->" Type "=" Rule - 150 CaseRule: "case" Term "of" "{" CaseLabels "}" - 151 | "case" Term "of" "{" error "}" + 143 Rule: SkipRule + 144 | ConditionalRule + 145 | CaseRule + 146 | LetRule + 147 | ForallRule + 148 | ChooseRule + 149 | IterateRule + 150 | BlockRule + 151 | SequenceRule + 152 | UpdateRule + 153 | CallRule - 152 CaseLabel: "default" ":" Rule - 153 | "_" ":" Rule - 154 | Term ":" Rule + 154 Rules: Rules Rule + 155 | Rule - 155 CaseLabels: CaseLabel CaseLabels - 156 | CaseLabel + 156 SkipRule: "skip" - 157 LetRule: "let" AttributedVariable "=" Term "in" Rule + 157 ConditionalRule: "if" Term "then" Rule + 158 | "if" Term "then" Rule "else" Rule - 158 ForallRule: "forall" AttributedVariable "in" Term "do" Rule + 159 CaseRule: "case" Term "of" "{" CaseLabels "}" + 160 | "case" Term "of" "{" error "}" - 159 ChooseRule: "choose" AttributedVariable "in" Term "do" Rule + 161 CaseLabel: "default" ":" Rule + 162 | "_" ":" Rule + 163 | Term ":" Rule - 160 IterateRule: "iterate" Rule + 164 CaseLabels: CaseLabel CaseLabels + 165 | CaseLabel - 161 BlockRule: "{" Rules "}" - 162 | "par" Rules "endpar" - 163 | "{" error "}" - 164 | "par" error "endpar" + 166 LetRule: "let" AttributedVariable "=" Term "in" Rule - 165 SequenceRule: "{|" Rules "|}" - 166 | "seq" Rules "endseq" - 167 | "{|" error "|}" - 168 | "seq" error "endseq" + 167 ForallRule: "forall" AttributedVariable "in" Term "do" Rule - 169 UpdateRule: DirectCallExpression ":=" Term + 168 ChooseRule: "choose" AttributedVariable "in" Term "do" Rule - 170 CallRule: "call" DirectCallExpression - 171 | DirectCallExpression - 172 | "call" IndirectCallExpression - 173 | IndirectCallExpression + 169 IterateRule: "iterate" Rule - 174 Attribute: BasicAttribute - 175 | ExpressionAttribute + 170 BlockRule: "{" Rules "}" + 171 | "par" Rules "endpar" + 172 | "{" error "}" + 173 | "par" error "endpar" - 176 Attributes: Attributes "," Attribute - 177 | Attribute + 174 SequenceRule: "{|" Rules "|}" + 175 | "seq" Rules "endseq" + 176 | "{|" error "|}" + 177 | "seq" error "endseq" - 178 BasicAttribute: Identifier + 178 UpdateRule: DirectCallExpression ":=" Term - 179 ExpressionAttribute: Identifier Term + 179 CallRule: "call" DirectCallExpression + 180 | DirectCallExpression + 181 | "call" IndirectCallExpression + 182 | IndirectCallExpression + + 183 Attribute: BasicAttribute + 184 | ExpressionAttribute + + 185 Attributes: Attributes "," Attribute + 186 | Attribute + + 187 BasicAttribute: Identifier + + 188 ExpressionAttribute: Identifier Term Terminals, with rules where they appear "end of file" (0) 0 -error (256) 7 51 93 117 121 151 163 164 167 168 +error (256) 8 60 102 126 130 160 172 173 176 177 "CASM" (258) 1 -"init" (259) 24 25 -"derived" (260) 33 -"enum" (261) 34 -"rule" (262) 132 133 -"function" (263) 12 -"initially" (264) 16 -"defined" (265) 18 -"structure" (266) 35 -"seq" (267) 166 168 -"endseq" (268) 166 168 -"par" (269) 162 164 -"endpar" (270) 162 164 -"skip" (271) 147 -"let" (272) 127 157 -"in" (273) 37 127 129 130 131 157 158 159 -"forall" (274) 130 158 -"choose" (275) 129 159 -"iterate" (276) 160 -"do" (277) 129 158 159 -"call" (278) 170 172 -"if" (279) 128 148 149 -"then" (280) 128 148 149 -"else" (281) 128 149 -"case" (282) 150 151 -"of" (283) 150 151 -"default" (284) 152 -"holds" (285) 130 -"exists" (286) 131 -"with" (287) 131 -"undef" (288) 71 -"false" (289) 73 -"true" (290) 72 -"and" (291) 110 -"or" (292) 108 -"xor" (293) 109 -"implies" (294) 112 -"not" (295) 113 -"+" (296) 94 96 -"-" (297) 95 97 -"=" (298) 33 34 35 103 127 132 133 157 -"(" (299) 50 51 92 93 120 121 122 123 126 -")" (300) 50 51 92 93 120 121 122 123 126 -"[" (301) 8 46 114 115 116 117 -"]" (302) 8 46 114 115 116 117 -"{" (303) 16 18 25 34 35 150 151 161 163 -"}" (304) 16 18 25 34 35 150 151 161 163 -":" (305) 12 44 152 153 154 -"_" (306) 153 -"@" (307) 80 -"," (308) 14 29 38 48 61 118 123 176 -"<" (309) 58 59 104 -">" (310) 58 59 105 -"*" (311) 20 98 126 -"/" (312) 99 -"%" (313) 100 -"^" (314) 101 -"'" (315) 60 -".." (316) 114 -"." (317) 40 43 -"->" (318) 12 27 28 33 59 133 -"=>" (319) 111 -":=" (320) 169 -"!=" (321) 102 -"<=" (322) 106 -">=" (323) 107 -"{|" (324) 165 167 -"|}" (325) 165 167 -"binary" (326) 75 -"hexadecimal" (327) 76 -"integer" (328) 77 -"rational" (329) 79 -"floating" (330) 78 -"string" (331) 74 -"identifier" (332) 36 -ABSOLUTE_PATH (333) -UPLUS (334) -UMINUS (335) -CALL_WITHOUT_ARGS (336) +"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) Nonterminals, with rules where they appear -$accept (82) +$accept (83) on left: 0 -Specification (83) +Specification (84) on left: 1, on right: 0 -Definition (84) - on left: 2 3 4 5 6 7, on right: 8 9 -AttributedDefinition (85) - on left: 8 9, on right: 10 11 -Definitions (86) - on left: 10 11, on right: 1 10 -FunctionDefinition (87) - on left: 12 13, on right: 2 14 15 -FunctionDefinitions (88) - on left: 14 15, on right: 14 35 -MaybeInitially (89) - on left: 16 17, on right: 12 -MaybeDefined (90) - on left: 18 19, on right: 12 -FunctionParameters (91) - on left: 20 21, on right: 20 22 -MaybeFunctionParameters (92) - on left: 22 23, on right: 12 59 -ProgramFunctionDefinition (93) - on left: 24 25, on right: 13 -Initializer (94) - on left: 26 27 28, on right: 29 30 -Initializers (95) - on left: 29 30, on right: 29 31 -MaybeInitializers (96) - on left: 31 32, on right: 16 25 -DerivedDefinition (97) - on left: 33, on right: 3 -EnumerationDefinition (98) - on left: 34, on right: 5 -StructureDefinition (99) - on left: 35, on right: 6 -Identifier (100) - on left: 36 37, on right: 12 33 34 35 38 39 40 41 44 45 132 133 - 178 179 -Identifiers (101) - on left: 38 39, on right: 34 38 -DotSeparatedIdentifiers (102) - on left: 40 41, on right: 40 42 43 -IdentifierPath (103) - on left: 42 43, on right: 24 57 58 59 60 80 124 125 -Variable (104) - on left: 44 45, on right: 46 47 -AttributedVariable (105) - on left: 46 47, on right: 48 49 127 129 130 131 157 158 159 -Parameters (106) - on left: 48 49, on right: 48 50 -MaybeParameters (107) - on left: 50 51 52, on right: 33 132 133 -Type (108) - on left: 53 54 55 56, on right: 12 20 21 33 44 59 61 62 133 -BasicType (109) - on left: 57, on right: 53 -ComposedType (110) - on left: 58, on right: 54 -RelationType (111) - on left: 59, on right: 55 -FixedSizedType (112) - on left: 60, on right: 56 -Types (113) - on left: 61 62, on right: 58 61 -Atom (114) - on left: 63 64 65 66 67 68 69 70, on right: 91 -Undefined (115) - on left: 71, on right: 69 -Boolean (116) - on left: 72 73, on right: 70 -String (117) - on left: 74, on right: 68 -BitNumber (118) - on left: 75 76, on right: 64 -IntegerNumber (119) - on left: 77, on right: 65 -FloatingNumber (120) - on left: 78, on right: 66 -RationalNumber (121) - on left: 79, on right: 67 -Reference (122) - on left: 80, on right: 63 -Term (123) - on left: 81 82 83 84 85 86 87 88 89 90 91, on right: 18 26 27 28 - 33 60 92 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 - 109 110 111 112 113 114 118 119 123 126 127 128 129 130 131 148 - 149 150 151 154 157 158 159 169 179 -Expression (124) - on left: 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 - 108 109 110 111 112 113, on right: 88 -Range (125) - on left: 114, on right: 90 -List (126) - on left: 115 116 117, on right: 89 -Terms (127) - on left: 118 119, on right: 116 118 120 123 -Arguments (128) - on left: 120 121 122, on right: 125 126 -TwoOrMoreArguments (129) - on left: 123, on right: 28 -DirectCallExpression (130) - on left: 124 125, on right: 81 169 170 171 -IndirectCallExpression (131) - on left: 126, on right: 82 172 173 -LetExpression (132) - on left: 127, on right: 83 -ConditionalExpression (133) - on left: 128, on right: 84 -ChooseExpression (134) - on left: 129, on right: 85 -UniversalQuantifierExpression (135) - on left: 130, on right: 86 -ExistentialQuantifierExpression (136) - on left: 131, on right: 87 -RuleDefinition (137) - on left: 132 133, on right: 4 -Rule (138) - on left: 134 135 136 137 138 139 140 141 142 143 144, on right: - 132 133 145 146 148 149 152 153 154 157 158 159 160 -Rules (139) - on left: 145 146, on right: 145 161 162 165 166 -SkipRule (140) - on left: 147, on right: 134 -ConditionalRule (141) - on left: 148 149, on right: 135 -CaseRule (142) - on left: 150 151, on right: 136 -CaseLabel (143) - on left: 152 153 154, on right: 155 156 -CaseLabels (144) - on left: 155 156, on right: 150 155 -LetRule (145) - on left: 157, on right: 137 -ForallRule (146) - on left: 158, on right: 138 -ChooseRule (147) - on left: 159, on right: 139 -IterateRule (148) - on left: 160, on right: 140 -BlockRule (149) - on left: 161 162 163 164, on right: 141 -SequenceRule (150) - on left: 165 166 167 168, on right: 142 -UpdateRule (151) - on left: 169, on right: 143 -CallRule (152) - on left: 170 171 172 173, on right: 144 -Attribute (153) - on left: 174 175, on right: 176 177 -Attributes (154) - on left: 176 177, on right: 8 46 176 -BasicAttribute (155) - on left: 178, on right: 174 -ExpressionAttribute (156) - on left: 179, on right: 175 +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 State 0 @@ -521,131 +543,143 @@ State 1 "rule" shift, and go to state 7 "function" shift, and go to state 8 "structure" shift, and go to state 9 - "[" shift, and go to state 10 + "feature" shift, and go to state 10 + "[" shift, and go to state 11 - Definition go to state 11 - AttributedDefinition go to state 12 - Definitions go to state 13 - FunctionDefinition go to state 14 - ProgramFunctionDefinition go to state 15 - DerivedDefinition go to state 16 - EnumerationDefinition go to state 17 - StructureDefinition go to state 18 - RuleDefinition go to state 19 + 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 State 2 0 $accept: Specification . "end of file" - "end of file" shift, and go to state 20 + "end of file" shift, and go to state 22 State 3 - 7 Definition: error . + 8 Definition: error . - $default reduce using rule 7 (Definition) + $default reduce using rule 8 (Definition) State 4 - 24 ProgramFunctionDefinition: "init" . IdentifierPath - 25 | "init" . "{" MaybeInitializers "}" + 25 ProgramFunctionDefinition: "init" . IdentifierPath + 26 | "init" . "{" MaybeInitializers "}" - "in" shift, and go to state 21 - "{" shift, and go to state 22 - "." shift, and go to state 23 - "identifier" shift, and go to state 24 + "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 - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 27 + Identifier go to state 27 + DotSeparatedIdentifiers go to state 28 + IdentifierPath go to state 29 State 5 - 33 DerivedDefinition: "derived" . Identifier MaybeParameters "->" Type "=" Term + 34 DerivedDefinition: "derived" . Identifier MaybeParameters "->" Type "=" Term - "in" shift, and go to state 21 - "identifier" shift, and go to state 24 + "in" shift, and go to state 23 + "identifier" shift, and go to state 26 - Identifier go to state 28 + Identifier go to state 30 State 6 - 34 EnumerationDefinition: "enum" . Identifier "=" "{" Identifiers "}" + 35 EnumerationDefinition: "enum" . Identifier "=" "{" Identifiers "}" - "in" shift, and go to state 21 - "identifier" shift, and go to state 24 + "in" shift, and go to state 23 + "identifier" shift, and go to state 26 - Identifier go to state 29 + Identifier go to state 31 State 7 - 132 RuleDefinition: "rule" . Identifier MaybeParameters "=" Rule - 133 | "rule" . Identifier MaybeParameters "->" Type "=" Rule + 141 RuleDefinition: "rule" . Identifier MaybeParameters "=" Rule + 142 | "rule" . Identifier MaybeParameters "->" Type "=" Rule - "in" shift, and go to state 21 - "identifier" shift, and go to state 24 + "in" shift, and go to state 23 + "identifier" shift, and go to state 26 - Identifier go to state 30 + Identifier go to state 32 State 8 - 12 FunctionDefinition: "function" . Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially + 13 FunctionDefinition: "function" . Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially - "in" shift, and go to state 21 - "identifier" shift, and go to state 24 + "in" shift, and go to state 23 + "identifier" shift, and go to state 26 - Identifier go to state 31 + Identifier go to state 33 State 9 - 35 StructureDefinition: "structure" . Identifier "=" "{" FunctionDefinitions "}" + 36 StructureDefinition: "structure" . Identifier "=" "{" FunctionDefinitions "}" - "in" shift, and go to state 21 - "identifier" shift, and go to state 24 + "in" shift, and go to state 23 + "identifier" shift, and go to state 26 - Identifier go to state 32 + Identifier go to state 34 State 10 - 8 AttributedDefinition: "[" . Attributes "]" Definition + 37 FeatureDefinition: "feature" . Identifier "=" "{" FeatureDeclarationsAndDefinitions "}" - "in" shift, and go to state 21 - "identifier" shift, and go to state 24 + "in" shift, and go to state 23 + "identifier" shift, and go to state 26 - Identifier go to state 33 - Attribute go to state 34 - Attributes go to state 35 - BasicAttribute go to state 36 - ExpressionAttribute go to state 37 + Identifier go to state 35 State 11 - 9 AttributedDefinition: Definition . + 9 AttributedDefinition: "[" . Attributes "]" Definition - $default reduce using rule 9 (AttributedDefinition) + "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 38 + BasicAttribute go to state 39 + ExpressionAttribute go to state 40 State 12 - 11 Definitions: AttributedDefinition . + 10 AttributedDefinition: Definition . - $default reduce using rule 11 (Definitions) + $default reduce using rule 10 (AttributedDefinition) State 13 + 12 Definitions: AttributedDefinition . + + $default reduce using rule 12 (Definitions) + + +State 14 + 1 Specification: "CASM" Definitions . - 10 Definitions: Definitions . AttributedDefinition + 11 Definitions: Definitions . AttributedDefinition error shift, and go to state 3 "init" shift, and go to state 4 @@ -654,7606 +688,7867 @@ State 13 "rule" shift, and go to state 7 "function" shift, and go to state 8 "structure" shift, and go to state 9 - "[" shift, and go to state 10 + "feature" shift, and go to state 10 + "[" shift, and go to state 11 "end of file" reduce using rule 1 (Specification) - Definition go to state 11 - AttributedDefinition go to state 38 - FunctionDefinition go to state 14 - ProgramFunctionDefinition go to state 15 - DerivedDefinition go to state 16 - EnumerationDefinition go to state 17 - StructureDefinition go to state 18 - RuleDefinition go to state 19 + 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 -State 14 +State 15 2 Definition: FunctionDefinition . $default reduce using rule 2 (Definition) -State 15 +State 16 - 13 FunctionDefinition: ProgramFunctionDefinition . + 14 FunctionDefinition: ProgramFunctionDefinition . - $default reduce using rule 13 (FunctionDefinition) + $default reduce using rule 14 (FunctionDefinition) -State 16 +State 17 3 Definition: DerivedDefinition . $default reduce using rule 3 (Definition) -State 17 +State 18 5 Definition: EnumerationDefinition . $default reduce using rule 5 (Definition) -State 18 +State 19 6 Definition: StructureDefinition . $default reduce using rule 6 (Definition) -State 19 - - 4 Definition: RuleDefinition . - - $default reduce using rule 4 (Definition) - - State 20 - 0 $accept: Specification "end of file" . + 7 Definition: FeatureDefinition . - $default accept + $default reduce using rule 7 (Definition) State 21 - 37 Identifier: "in" . + 4 Definition: RuleDefinition . - $default reduce using rule 37 (Identifier) + $default reduce using rule 4 (Definition) State 22 - 25 ProgramFunctionDefinition: "init" "{" . MaybeInitializers "}" - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 50 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - $default reduce using rule 32 (MaybeInitializers) + 0 $accept: Specification "end of file" . - Initializer go to state 59 - Initializers go to state 60 - MaybeInitializers go to state 61 - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 72 - Expression go to state 73 - Range go to state 74 - List go to state 75 - TwoOrMoreArguments go to state 76 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + $default accept State 23 - 43 IdentifierPath: "." . DotSeparatedIdentifiers + 46 Identifier: "in" . - "in" shift, and go to state 21 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 84 + $default reduce using rule 46 (Identifier) State 24 - 36 Identifier: "identifier" . - - $default reduce using rule 36 (Identifier) + 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) + + 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 State 25 - 41 DotSeparatedIdentifiers: Identifier . + 52 IdentifierPath: "." . DotSeparatedIdentifiers - $default reduce using rule 41 (DotSeparatedIdentifiers) + "in" shift, and go to state 23 + "identifier" shift, and go to state 26 + Identifier go to state 27 + DotSeparatedIdentifiers go to state 87 -State 26 - 40 DotSeparatedIdentifiers: DotSeparatedIdentifiers . "." Identifier - 42 IdentifierPath: DotSeparatedIdentifiers . +State 26 - "." shift, and go to state 85 + 45 Identifier: "identifier" . - $default reduce using rule 42 (IdentifierPath) + $default reduce using rule 45 (Identifier) State 27 - 24 ProgramFunctionDefinition: "init" IdentifierPath . + 50 DotSeparatedIdentifiers: Identifier . - $default reduce using rule 24 (ProgramFunctionDefinition) + $default reduce using rule 50 (DotSeparatedIdentifiers) State 28 - 33 DerivedDefinition: "derived" Identifier . MaybeParameters "->" Type "=" Term - - "(" shift, and go to state 86 + 49 DotSeparatedIdentifiers: DotSeparatedIdentifiers . "." Identifier + 51 IdentifierPath: DotSeparatedIdentifiers . - $default reduce using rule 52 (MaybeParameters) + "." shift, and go to state 88 - MaybeParameters go to state 87 + $default reduce using rule 51 (IdentifierPath) State 29 - 34 EnumerationDefinition: "enum" Identifier . "=" "{" Identifiers "}" + 25 ProgramFunctionDefinition: "init" IdentifierPath . - "=" shift, and go to state 88 + $default reduce using rule 25 (ProgramFunctionDefinition) State 30 - 132 RuleDefinition: "rule" Identifier . MaybeParameters "=" Rule - 133 | "rule" Identifier . MaybeParameters "->" Type "=" Rule + 34 DerivedDefinition: "derived" Identifier . MaybeParameters "->" Type "=" Term - "(" shift, and go to state 86 + "(" shift, and go to state 89 - $default reduce using rule 52 (MaybeParameters) + $default reduce using rule 61 (MaybeParameters) - MaybeParameters go to state 89 + MaybeParameters go to state 90 State 31 - 12 FunctionDefinition: "function" Identifier . ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially + 35 EnumerationDefinition: "enum" Identifier . "=" "{" Identifiers "}" - ":" shift, and go to state 90 + "=" shift, and go to state 91 State 32 - 35 StructureDefinition: "structure" Identifier . "=" "{" FunctionDefinitions "}" + 141 RuleDefinition: "rule" Identifier . MaybeParameters "=" Rule + 142 | "rule" Identifier . MaybeParameters "->" Type "=" Rule - "=" shift, and go to state 91 + "(" shift, and go to state 89 + + $default reduce using rule 61 (MaybeParameters) + + MaybeParameters go to state 92 State 33 - 178 BasicAttribute: Identifier . - 179 ExpressionAttribute: Identifier . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - $default reduce using rule 178 (BasicAttribute) - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 93 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 13 FunctionDefinition: "function" Identifier . ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially + + ":" shift, and go to state 93 State 34 - 177 Attributes: Attribute . + 36 StructureDefinition: "structure" Identifier . "=" "{" FunctionDefinitions "}" - $default reduce using rule 177 (Attributes) + "=" shift, and go to state 94 State 35 - 8 AttributedDefinition: "[" Attributes . "]" Definition - 176 Attributes: Attributes . "," Attribute + 37 FeatureDefinition: "feature" Identifier . "=" "{" FeatureDeclarationsAndDefinitions "}" - "]" shift, and go to state 94 - "," shift, and go to state 95 + "=" shift, and go to state 95 State 36 - 174 Attribute: BasicAttribute . - - $default reduce using rule 174 (Attribute) + 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 State 37 - 175 Attribute: ExpressionAttribute . + 186 Attributes: Attribute . - $default reduce using rule 175 (Attribute) + $default reduce using rule 186 (Attributes) State 38 - 10 Definitions: Definitions AttributedDefinition . + 9 AttributedDefinition: "[" Attributes . "]" Definition + 185 Attributes: Attributes . "," Attribute - $default reduce using rule 10 (Definitions) + "]" shift, and go to state 98 + "," shift, and go to state 99 State 39 - 127 LetExpression: "let" . AttributedVariable "=" Term "in" Term + 183 Attribute: BasicAttribute . - "in" shift, and go to state 21 - "[" shift, and go to state 96 - "identifier" shift, and go to state 24 - - Identifier go to state 97 - Variable go to state 98 - AttributedVariable go to state 99 + $default reduce using rule 183 (Attribute) State 40 - 130 UniversalQuantifierExpression: "forall" . AttributedVariable "in" Term "holds" Term - - "in" shift, and go to state 21 - "[" shift, and go to state 96 - "identifier" shift, and go to state 24 + 184 Attribute: ExpressionAttribute . - Identifier go to state 97 - Variable go to state 98 - AttributedVariable go to state 100 + $default reduce using rule 184 (Attribute) State 41 - 129 ChooseExpression: "choose" . AttributedVariable "in" Term "do" Term + 11 Definitions: Definitions AttributedDefinition . - "in" shift, and go to state 21 - "[" shift, and go to state 96 - "identifier" shift, and go to state 24 - - Identifier go to state 97 - Variable go to state 98 - AttributedVariable go to state 101 + $default reduce using rule 11 (Definitions) State 42 - 128 ConditionalExpression: "if" . Term "then" Term "else" Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 102 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 136 LetExpression: "let" . AttributedVariable "=" Term "in" Term + + "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 State 43 - 131 ExistentialQuantifierExpression: "exists" . AttributedVariable "in" Term "with" Term + 139 UniversalQuantifierExpression: "forall" . AttributedVariable "in" Term "holds" Term - "in" shift, and go to state 21 - "[" shift, and go to state 96 - "identifier" shift, and go to state 24 + "in" shift, and go to state 23 + "[" shift, and go to state 100 + "identifier" shift, and go to state 26 - Identifier go to state 97 - Variable go to state 98 - AttributedVariable go to state 103 + Identifier go to state 101 + Variable go to state 102 + AttributedVariable go to state 104 State 44 - 71 Undefined: "undef" . + 138 ChooseExpression: "choose" . AttributedVariable "in" Term "do" Term - $default reduce using rule 71 (Undefined) + "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 105 -State 45 - 73 Boolean: "false" . +State 45 - $default reduce using rule 73 (Boolean) + 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 State 46 - 72 Boolean: "true" . + 140 ExistentialQuantifierExpression: "exists" . AttributedVariable "in" Term "with" Term + + "in" shift, and go to state 23 + "[" shift, and go to state 100 + "identifier" shift, and go to state 26 - $default reduce using rule 72 (Boolean) + Identifier go to state 101 + Variable go to state 102 + AttributedVariable go to state 107 State 47 - 113 Expression: "not" . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 104 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 80 Undefined: "undef" . + + $default reduce using rule 80 (Undefined) State 48 - 94 Expression: "+" . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 105 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 82 Boolean: "false" . + + $default reduce using rule 82 (Boolean) State 49 - 95 Expression: "-" . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 106 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 81 Boolean: "true" . + + $default reduce using rule 81 (Boolean) State 50 - 92 Expression: "(" . Term ")" - 93 | "(" . error ")" - 123 TwoOrMoreArguments: "(" . Terms "," Term ")" - 126 IndirectCallExpression: "(" . "*" Term ")" Arguments - - error shift, and go to state 107 - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "*" shift, and go to state 108 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 109 - Expression go to state 73 - Range go to state 74 - List go to state 75 - Terms go to state 110 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 State 51 - 114 Range: "[" . Term ".." Term "]" - 115 List: "[" . "]" - 116 | "[" . Terms "]" - 117 | "[" . error "]" - - error shift, and go to state 111 - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "]" shift, and go to state 112 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 113 - Expression go to state 73 - Range go to state 74 - List go to state 75 - Terms go to state 114 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 State 52 - 80 Reference: "@" . IdentifierPath - - "in" shift, and go to state 21 - "." shift, and go to state 23 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 115 + 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 State 53 - 75 BitNumber: "binary" . + 101 Expression: "(" . Term ")" + 102 | "(" . error ")" + 132 TwoOrMoreArguments: "(" . Terms "," Term ")" + 135 IndirectCallExpression: "(" . "*" Term ")" Arguments - $default reduce using rule 75 (BitNumber) + 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 State 54 - 76 BitNumber: "hexadecimal" . - - $default reduce using rule 76 (BitNumber) + 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 State 55 - 77 IntegerNumber: "integer" . + 89 Reference: "@" . IdentifierPath - $default reduce using rule 77 (IntegerNumber) + "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 119 State 56 - 79 RationalNumber: "rational" . + 84 BitNumber: "binary" . - $default reduce using rule 79 (RationalNumber) + $default reduce using rule 84 (BitNumber) State 57 - 78 FloatingNumber: "floating" . + 85 BitNumber: "hexadecimal" . - $default reduce using rule 78 (FloatingNumber) + $default reduce using rule 85 (BitNumber) State 58 - 74 String: "string" . + 86 IntegerNumber: "integer" . - $default reduce using rule 74 (String) + $default reduce using rule 86 (IntegerNumber) State 59 - 30 Initializers: Initializer . + 88 RationalNumber: "rational" . - $default reduce using rule 30 (Initializers) + $default reduce using rule 88 (RationalNumber) State 60 - 29 Initializers: Initializers . "," Initializer - 31 MaybeInitializers: Initializers . + 87 FloatingNumber: "floating" . - "," shift, and go to state 116 - - $default reduce using rule 31 (MaybeInitializers) + $default reduce using rule 87 (FloatingNumber) State 61 - 25 ProgramFunctionDefinition: "init" "{" MaybeInitializers . "}" + 83 String: "string" . - "}" shift, and go to state 117 + $default reduce using rule 83 (String) State 62 - 124 DirectCallExpression: IdentifierPath . - 125 | IdentifierPath . Arguments - - "(" shift, and go to state 118 - - $default reduce using rule 124 (DirectCallExpression) + 31 Initializers: Initializer . - Arguments go to state 119 + $default reduce using rule 31 (Initializers) State 63 - 91 Term: Atom . + 30 Initializers: Initializers . "," Initializer + 32 MaybeInitializers: Initializers . - $default reduce using rule 91 (Term) + "," shift, and go to state 120 + + $default reduce using rule 32 (MaybeInitializers) State 64 - 69 Atom: Undefined . + 26 ProgramFunctionDefinition: "init" "{" MaybeInitializers . "}" - $default reduce using rule 69 (Atom) + "}" shift, and go to state 121 State 65 - 70 Atom: Boolean . + 133 DirectCallExpression: IdentifierPath . + 134 | IdentifierPath . Arguments + + "(" shift, and go to state 122 - $default reduce using rule 70 (Atom) + $default reduce using rule 133 (DirectCallExpression) + + Arguments go to state 123 State 66 - 68 Atom: String . + 100 Term: Atom . - $default reduce using rule 68 (Atom) + $default reduce using rule 100 (Term) State 67 - 64 Atom: BitNumber . + 78 Atom: Undefined . - $default reduce using rule 64 (Atom) + $default reduce using rule 78 (Atom) State 68 - 65 Atom: IntegerNumber . + 79 Atom: Boolean . - $default reduce using rule 65 (Atom) + $default reduce using rule 79 (Atom) State 69 - 66 Atom: FloatingNumber . + 77 Atom: String . - $default reduce using rule 66 (Atom) + $default reduce using rule 77 (Atom) State 70 - 67 Atom: RationalNumber . + 73 Atom: BitNumber . - $default reduce using rule 67 (Atom) + $default reduce using rule 73 (Atom) State 71 - 63 Atom: Reference . + 74 Atom: IntegerNumber . - $default reduce using rule 63 (Atom) + $default reduce using rule 74 (Atom) State 72 - 26 Initializer: Term . - 27 | Term . "->" Term - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "implies" shift, and go to state 123 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - "<" 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 - - $default reduce using rule 26 (Initializer) + 75 Atom: FloatingNumber . + + $default reduce using rule 75 (Atom) State 73 - 88 Term: Expression . + 76 Atom: RationalNumber . - $default reduce using rule 88 (Term) + $default reduce using rule 76 (Atom) State 74 - 90 Term: Range . + 72 Atom: Reference . - $default reduce using rule 90 (Term) + $default reduce using rule 72 (Atom) State 75 - 89 Term: List . + 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 89 (Term) + $default reduce using rule 27 (Initializer) State 76 - 28 Initializer: TwoOrMoreArguments . "->" Term + 97 Term: Expression . - "->" shift, and go to state 138 + $default reduce using rule 97 (Term) State 77 - 81 Term: DirectCallExpression . + 99 Term: Range . - $default reduce using rule 81 (Term) + $default reduce using rule 99 (Term) State 78 - 82 Term: IndirectCallExpression . + 98 Term: List . - $default reduce using rule 82 (Term) + $default reduce using rule 98 (Term) State 79 - 83 Term: LetExpression . + 29 Initializer: TwoOrMoreArguments . "->" Term - $default reduce using rule 83 (Term) + "->" shift, and go to state 142 State 80 - 84 Term: ConditionalExpression . + 90 Term: DirectCallExpression . - $default reduce using rule 84 (Term) + $default reduce using rule 90 (Term) State 81 - 85 Term: ChooseExpression . + 91 Term: IndirectCallExpression . - $default reduce using rule 85 (Term) + $default reduce using rule 91 (Term) State 82 - 86 Term: UniversalQuantifierExpression . + 92 Term: LetExpression . - $default reduce using rule 86 (Term) + $default reduce using rule 92 (Term) State 83 - 87 Term: ExistentialQuantifierExpression . + 93 Term: ConditionalExpression . - $default reduce using rule 87 (Term) + $default reduce using rule 93 (Term) State 84 - 40 DotSeparatedIdentifiers: DotSeparatedIdentifiers . "." Identifier - 43 IdentifierPath: "." DotSeparatedIdentifiers . + 94 Term: ChooseExpression . - $default reduce using rule 43 (IdentifierPath) + $default reduce using rule 94 (Term) State 85 - 40 DotSeparatedIdentifiers: DotSeparatedIdentifiers "." . Identifier - - "in" shift, and go to state 21 - "identifier" shift, and go to state 24 + 95 Term: UniversalQuantifierExpression . - Identifier go to state 139 + $default reduce using rule 95 (Term) State 86 - 50 MaybeParameters: "(" . Parameters ")" - 51 | "(" . error ")" + 96 Term: ExistentialQuantifierExpression . - error shift, and go to state 140 - "in" shift, and go to state 21 - "[" shift, and go to state 96 - "identifier" shift, and go to state 24 - - Identifier go to state 97 - Variable go to state 98 - AttributedVariable go to state 141 - Parameters go to state 142 + $default reduce using rule 96 (Term) State 87 - 33 DerivedDefinition: "derived" Identifier MaybeParameters . "->" Type "=" Term + 49 DotSeparatedIdentifiers: DotSeparatedIdentifiers . "." Identifier + 52 IdentifierPath: "." DotSeparatedIdentifiers . - "->" shift, and go to state 143 + $default reduce using rule 52 (IdentifierPath) State 88 - 34 EnumerationDefinition: "enum" Identifier "=" . "{" Identifiers "}" + 49 DotSeparatedIdentifiers: DotSeparatedIdentifiers "." . Identifier - "{" shift, and go to state 144 + "in" shift, and go to state 23 + "identifier" shift, and go to state 26 + Identifier go to state 143 -State 89 - 132 RuleDefinition: "rule" Identifier MaybeParameters . "=" Rule - 133 | "rule" Identifier MaybeParameters . "->" Type "=" Rule +State 89 - "=" shift, and go to state 145 - "->" shift, and go to state 146 + 59 MaybeParameters: "(" . Parameters ")" + 60 | "(" . error ")" + 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 -State 90 + Identifier go to state 101 + Variable go to state 102 + AttributedVariable go to state 145 + Parameters go to state 146 - 12 FunctionDefinition: "function" Identifier ":" . MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially - "in" shift, and go to state 21 - "." shift, and go to state 23 - "identifier" shift, and go to state 24 +State 90 - $default reduce using rule 23 (MaybeFunctionParameters) + 34 DerivedDefinition: "derived" Identifier MaybeParameters . "->" Type "=" Term - FunctionParameters go to state 147 - MaybeFunctionParameters go to state 148 - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 149 - Type go to state 150 - BasicType go to state 151 - ComposedType go to state 152 - RelationType go to state 153 - FixedSizedType go to state 154 + "->" shift, and go to state 147 State 91 - 35 StructureDefinition: "structure" Identifier "=" . "{" FunctionDefinitions "}" + 35 EnumerationDefinition: "enum" Identifier "=" . "{" Identifiers "}" - "{" shift, and go to state 155 + "{" shift, and go to state 148 State 92 - 92 Expression: "(" . Term ")" - 93 | "(" . error ")" - 126 IndirectCallExpression: "(" . "*" Term ")" Arguments - - error shift, and go to state 107 - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "*" shift, and go to state 108 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 156 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 141 RuleDefinition: "rule" Identifier MaybeParameters . "=" Rule + 142 | "rule" Identifier MaybeParameters . "->" Type "=" Rule + + "=" shift, and go to state 149 + "->" shift, and go to state 150 State 93 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - 179 ExpressionAttribute: Identifier Term . - - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "implies" shift, and go to state 123 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - "<" 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 134 - "!=" shift, and go to state 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 - - $default reduce using rule 179 (ExpressionAttribute) + 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 -State 94 + $default reduce using rule 24 (MaybeFunctionParameters) - 8 AttributedDefinition: "[" Attributes "]" . Definition + 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 - 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 - Definition go to state 157 - FunctionDefinition go to state 14 - ProgramFunctionDefinition go to state 15 - DerivedDefinition go to state 16 - EnumerationDefinition go to state 17 - StructureDefinition go to state 18 - RuleDefinition go to state 19 +State 94 + 36 StructureDefinition: "structure" Identifier "=" . "{" FunctionDefinitions "}" -State 95 + "{" shift, and go to state 159 - 176 Attributes: Attributes "," . Attribute - "in" shift, and go to state 21 - "identifier" shift, and go to state 24 +State 95 - Identifier go to state 33 - Attribute go to state 158 - BasicAttribute go to state 36 - ExpressionAttribute go to state 37 + 37 FeatureDefinition: "feature" Identifier "=" . "{" FeatureDeclarationsAndDefinitions "}" + "{" shift, and go to state 160 -State 96 - 46 AttributedVariable: "[" . Attributes "]" Variable +State 96 - "in" shift, and go to state 21 - "identifier" shift, and go to state 24 + 101 Expression: "(" . Term ")" + 102 | "(" . error ")" + 135 IndirectCallExpression: "(" . "*" Term ")" Arguments - Identifier go to state 33 - Attribute go to state 34 - Attributes go to state 159 - BasicAttribute go to state 36 - ExpressionAttribute go to state 37 + 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 State 97 - 44 Variable: Identifier . ":" Type - 45 | Identifier . - - ":" shift, and go to state 160 - - $default reduce using rule 45 (Variable) + 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) State 98 - 47 AttributedVariable: Variable . + 9 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 - $default reduce using rule 47 (AttributedVariable) + 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 State 99 - 127 LetExpression: "let" AttributedVariable . "=" Term "in" Term + 185 Attributes: Attributes "," . Attribute - "=" shift, and go to state 161 + "in" shift, and go to state 23 + "identifier" shift, and go to state 26 + + Identifier go to state 36 + Attribute go to state 163 + BasicAttribute go to state 39 + ExpressionAttribute go to state 40 State 100 - 130 UniversalQuantifierExpression: "forall" AttributedVariable . "in" Term "holds" Term + 55 AttributedVariable: "[" . Attributes "]" Variable + + "in" shift, and go to state 23 + "identifier" shift, and go to state 26 - "in" shift, and go to state 162 + 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 State 101 - 129 ChooseExpression: "choose" AttributedVariable . "in" Term "do" Term + 53 Variable: Identifier . ":" Type + 54 | Identifier . - "in" shift, and go to state 163 + ":" shift, and go to state 165 + + $default reduce using rule 54 (Variable) State 102 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - 128 ConditionalExpression: "if" Term . "then" Term "else" Term - - "then" shift, and go to state 164 - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "implies" shift, and go to state 123 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - "<" 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 134 - "!=" shift, and go to state 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 + 56 AttributedVariable: Variable . + + $default reduce using rule 56 (AttributedVariable) State 103 - 131 ExistentialQuantifierExpression: "exists" AttributedVariable . "in" Term "with" Term + 136 LetExpression: "let" AttributedVariable . "=" Term "in" Term - "in" shift, and go to state 165 + "=" shift, and go to state 166 State 104 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - 113 | "not" Term . + 139 UniversalQuantifierExpression: "forall" AttributedVariable . "in" Term "holds" Term - $default reduce using rule 113 (Expression) + "in" shift, and go to state 167 State 105 - 94 Expression: "+" Term . - 96 | Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - - $default reduce using rule 94 (Expression) + 138 ChooseExpression: "choose" AttributedVariable . "in" Term "do" Term + + "in" shift, and go to state 168 State 106 - 95 Expression: "-" Term . - 96 | Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - - $default reduce using rule 95 (Expression) + 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 State 107 - 93 Expression: "(" error . ")" + 140 ExistentialQuantifierExpression: "exists" AttributedVariable . "in" Term "with" Term - ")" shift, and go to state 166 + "in" shift, and go to state 170 State 108 - 126 IndirectCallExpression: "(" "*" . Term ")" Arguments - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 167 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 109 - 92 Expression: "(" Term . ")" - 96 | Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - 119 Terms: Term . - - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "implies" shift, and go to state 123 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - ")" shift, and go to state 168 - "<" 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 134 - "!=" shift, and go to state 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 - - $default reduce using rule 119 (Terms) + 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) State 110 - 118 Terms: Terms . "," Term - 123 TwoOrMoreArguments: "(" Terms . "," Term ")" + 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 - "," shift, and go to state 169 + $default reduce using rule 104 (Expression) State 111 - 117 List: "[" error . "]" + 102 Expression: "(" error . ")" - "]" shift, and go to state 170 + ")" shift, and go to state 171 State 112 - 115 List: "[" "]" . - - $default reduce using rule 115 (List) + 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 State 113 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - 114 Range: "[" Term . ".." Term "]" - 119 Terms: Term . - - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "implies" shift, and go to state 123 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - "<" 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 171 - "=>" shift, and go to state 134 - "!=" shift, and go to state 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 - - $default reduce using rule 119 (Terms) + 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) State 114 - 116 List: "[" Terms . "]" - 118 Terms: Terms . "," Term + 127 Terms: Terms . "," Term + 132 TwoOrMoreArguments: "(" Terms . "," Term ")" - "]" shift, and go to state 172 - "," shift, and go to state 173 + "," shift, and go to state 174 State 115 - 80 Reference: "@" IdentifierPath . + 126 List: "[" error . "]" - $default reduce using rule 80 (Reference) + "]" shift, and go to state 175 State 116 - 29 Initializers: Initializers "," . Initializer - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 50 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Initializer go to state 174 - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 72 - Expression go to state 73 - Range go to state 74 - List go to state 75 - TwoOrMoreArguments go to state 76 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 124 List: "[" "]" . + $default reduce using rule 124 (List) -State 117 - 25 ProgramFunctionDefinition: "init" "{" MaybeInitializers "}" . +State 117 - $default reduce using rule 25 (ProgramFunctionDefinition) + 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) State 118 - 120 Arguments: "(" . Terms ")" - 121 | "(" . error ")" - 122 | "(" . ")" - - error shift, and go to state 175 - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - ")" shift, and go to state 176 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 177 - Expression go to state 73 - Range go to state 74 - List go to state 75 - Terms go to state 178 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 125 List: "[" Terms . "]" + 127 Terms: Terms . "," Term + + "]" shift, and go to state 177 + "," shift, and go to state 178 State 119 - 125 DirectCallExpression: IdentifierPath Arguments . + 89 Reference: "@" IdentifierPath . - $default reduce using rule 125 (DirectCallExpression) + $default reduce using rule 89 (Reference) State 120 - 110 Expression: Term "and" . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 179 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 State 121 - 108 Expression: Term "or" . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 180 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 26 ProgramFunctionDefinition: "init" "{" MaybeInitializers "}" . + + $default reduce using rule 26 (ProgramFunctionDefinition) State 122 - 109 Expression: Term "xor" . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 181 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 State 123 - 112 Expression: Term "implies" . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 182 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 134 DirectCallExpression: IdentifierPath Arguments . + + $default reduce using rule 134 (DirectCallExpression) State 124 - 96 Expression: Term "+" . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 183 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 State 125 - 97 Expression: Term "-" . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 184 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 State 126 - 103 Expression: Term "=" . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 185 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 State 127 - 104 Expression: Term "<" . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 186 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 State 128 - 105 Expression: Term ">" . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 187 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 State 129 - 98 Expression: Term "*" . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 188 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 State 130 - 99 Expression: Term "/" . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 189 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 State 131 - 100 Expression: Term "%" . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 190 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 State 132 - 101 Expression: Term "^" . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 191 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 State 133 - 27 Initializer: Term "->" . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 192 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 State 134 - 111 Expression: Term "=>" . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 193 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 State 135 - 102 Expression: Term "!=" . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 194 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 State 136 - 106 Expression: Term "<=" . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 195 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 State 137 - 107 Expression: Term ">=" . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 196 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 State 138 - 28 Initializer: TwoOrMoreArguments "->" . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 197 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 State 139 - 40 DotSeparatedIdentifiers: DotSeparatedIdentifiers "." Identifier . - - $default reduce using rule 40 (DotSeparatedIdentifiers) + 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 State 140 - 51 MaybeParameters: "(" error . ")" - - ")" shift, and go to state 198 + 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 State 141 - 49 Parameters: AttributedVariable . - - $default reduce using rule 49 (Parameters) + 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 State 142 - 48 Parameters: Parameters . "," AttributedVariable - 50 MaybeParameters: "(" Parameters . ")" - - ")" shift, and go to state 199 - "," shift, and go to state 200 + 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 State 143 - 33 DerivedDefinition: "derived" Identifier MaybeParameters "->" . Type "=" Term - - "in" shift, and go to state 21 - "." shift, and go to state 23 - "identifier" shift, and go to state 24 + 49 DotSeparatedIdentifiers: DotSeparatedIdentifiers "." Identifier . - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 149 - Type go to state 201 - BasicType go to state 151 - ComposedType go to state 152 - RelationType go to state 153 - FixedSizedType go to state 154 + $default reduce using rule 49 (DotSeparatedIdentifiers) State 144 - 34 EnumerationDefinition: "enum" Identifier "=" "{" . Identifiers "}" + 60 MaybeParameters: "(" error . ")" - "in" shift, and go to state 21 - "identifier" shift, and go to state 24 - - Identifier go to state 202 - Identifiers go to state 203 + ")" shift, and go to state 203 State 145 - 132 RuleDefinition: "rule" Identifier MaybeParameters "=" . Rule - - "seq" shift, and go to state 204 - "par" shift, and go to state 205 - "skip" shift, and go to state 206 - "let" shift, and go to state 207 - "in" shift, and go to state 21 - "forall" shift, and go to state 208 - "choose" shift, and go to state 209 - "iterate" shift, and go to state 210 - "call" shift, and go to state 211 - "if" shift, and go to state 212 - "case" shift, and go to state 213 - "(" shift, and go to state 214 - "{" shift, and go to state 215 - "." shift, and go to state 23 - "{|" shift, and go to state 216 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - DirectCallExpression go to state 217 - IndirectCallExpression go to state 218 - Rule go to state 219 - SkipRule go to state 220 - ConditionalRule go to state 221 - CaseRule go to state 222 - LetRule go to state 223 - ForallRule go to state 224 - ChooseRule go to state 225 - IterateRule go to state 226 - BlockRule go to state 227 - SequenceRule go to state 228 - UpdateRule go to state 229 - CallRule go to state 230 + 58 Parameters: AttributedVariable . + $default reduce using rule 58 (Parameters) -State 146 - 133 RuleDefinition: "rule" Identifier MaybeParameters "->" . Type "=" Rule +State 146 - "in" shift, and go to state 21 - "." shift, and go to state 23 - "identifier" shift, and go to state 24 + 57 Parameters: Parameters . "," AttributedVariable + 59 MaybeParameters: "(" Parameters . ")" - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 149 - Type go to state 231 - BasicType go to state 151 - ComposedType go to state 152 - RelationType go to state 153 - FixedSizedType go to state 154 + ")" shift, and go to state 204 + "," shift, and go to state 205 State 147 - 20 FunctionParameters: FunctionParameters . "*" Type - 22 MaybeFunctionParameters: FunctionParameters . + 34 DerivedDefinition: "derived" Identifier MaybeParameters "->" . Type "=" Term - "*" shift, and go to state 232 + "in" shift, and go to state 23 + "." shift, and go to state 25 + "identifier" shift, and go to state 26 - $default reduce using rule 22 (MaybeFunctionParameters) + 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 State 148 - 12 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters . "->" Type MaybeDefined MaybeInitially - - "->" shift, and go to state 233 + 35 EnumerationDefinition: "enum" Identifier "=" "{" . Identifiers "}" + "in" shift, and go to state 23 + "identifier" shift, and go to state 26 -State 149 + Identifier go to state 207 + Identifiers go to state 208 - 57 BasicType: IdentifierPath . - 58 ComposedType: IdentifierPath . "<" Types ">" - 59 RelationType: IdentifierPath . "<" MaybeFunctionParameters "->" Type ">" - 60 FixedSizedType: IdentifierPath . "'" Term - "<" shift, and go to state 234 - "'" shift, and go to state 235 +State 149 - $default reduce using rule 57 (BasicType) + 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 State 150 - 21 FunctionParameters: Type . + 142 RuleDefinition: "rule" Identifier MaybeParameters "->" . Type "=" Rule - $default reduce using rule 21 (FunctionParameters) + "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 State 151 - 53 Type: BasicType . + 21 FunctionParameters: FunctionParameters . "*" Type + 23 MaybeFunctionParameters: FunctionParameters . - $default reduce using rule 53 (Type) + "*" shift, and go to state 237 + + $default reduce using rule 23 (MaybeFunctionParameters) State 152 - 54 Type: ComposedType . + 13 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters . "->" Type MaybeDefined MaybeInitially - $default reduce using rule 54 (Type) + "->" shift, and go to state 238 State 153 - 55 Type: RelationType . + 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 55 (Type) + $default reduce using rule 66 (BasicType) State 154 - 56 Type: FixedSizedType . + 22 FunctionParameters: Type . - $default reduce using rule 56 (Type) + $default reduce using rule 22 (FunctionParameters) State 155 - 35 StructureDefinition: "structure" Identifier "=" "{" . FunctionDefinitions "}" + 62 Type: BasicType . - "init" shift, and go to state 4 - "function" shift, and go to state 8 - - FunctionDefinition go to state 236 - FunctionDefinitions go to state 237 - ProgramFunctionDefinition go to state 15 + $default reduce using rule 62 (Type) State 156 - 92 Expression: "(" Term . ")" - 96 | Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "implies" shift, and go to state 123 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - ")" shift, and go to state 168 - "<" 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 134 - "!=" shift, and go to state 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 + 63 Type: ComposedType . + + $default reduce using rule 63 (Type) State 157 - 8 AttributedDefinition: "[" Attributes "]" Definition . + 64 Type: RelationType . - $default reduce using rule 8 (AttributedDefinition) + $default reduce using rule 64 (Type) State 158 - 176 Attributes: Attributes "," Attribute . + 65 Type: FixedSizedType . - $default reduce using rule 176 (Attributes) + $default reduce using rule 65 (Type) State 159 - 46 AttributedVariable: "[" Attributes . "]" Variable - 176 Attributes: Attributes . "," Attribute + 36 StructureDefinition: "structure" Identifier "=" "{" . FunctionDefinitions "}" - "]" shift, and go to state 238 - "," shift, and go to state 95 + "init" shift, and go to state 4 + "function" shift, and go to state 8 + + FunctionDefinition go to state 241 + FunctionDefinitions go to state 242 + ProgramFunctionDefinition go to state 16 State 160 - 44 Variable: Identifier ":" . Type + 37 FeatureDefinition: "feature" Identifier "=" "{" . FeatureDeclarationsAndDefinitions "}" - "in" shift, and go to state 21 - "." shift, and go to state 23 - "identifier" shift, and go to state 24 + "derived" shift, and go to state 243 + "rule" shift, and go to state 244 - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 149 - Type go to state 239 - BasicType go to state 151 - ComposedType go to state 152 - RelationType go to state 153 - FixedSizedType go to state 154 + 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 State 161 - 127 LetExpression: "let" AttributedVariable "=" . Term "in" Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 240 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 State 162 - 130 UniversalQuantifierExpression: "forall" AttributedVariable "in" . Term "holds" Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 241 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 9 AttributedDefinition: "[" Attributes "]" Definition . + + $default reduce using rule 9 (AttributedDefinition) State 163 - 129 ChooseExpression: "choose" AttributedVariable "in" . Term "do" Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 242 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 185 Attributes: Attributes "," Attribute . + + $default reduce using rule 185 (Attributes) State 164 - 128 ConditionalExpression: "if" Term "then" . Term "else" Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 243 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 55 AttributedVariable: "[" Attributes . "]" Variable + 185 Attributes: Attributes . "," Attribute + + "]" shift, and go to state 250 + "," shift, and go to state 99 State 165 - 131 ExistentialQuantifierExpression: "exists" AttributedVariable "in" . Term "with" Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 244 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 53 Variable: Identifier ":" . Type + "in" shift, and go to state 23 + "." shift, and go to state 25 + "identifier" shift, and go to state 26 -State 166 + 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 - 93 Expression: "(" error ")" . - $default reduce using rule 93 (Expression) +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 State 167 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - 126 IndirectCallExpression: "(" "*" Term . ")" Arguments - - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "implies" shift, and go to state 123 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - ")" shift, and go to state 245 - "<" 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 134 - "!=" shift, and go to state 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 + 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 State 168 - 92 Expression: "(" Term ")" . - - $default reduce using rule 92 (Expression) + 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 State 169 - 118 Terms: Terms "," . Term - 123 TwoOrMoreArguments: "(" Terms "," . Term ")" - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 246 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 State 170 - 117 List: "[" error "]" . - - $default reduce using rule 117 (List) + 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 State 171 - 114 Range: "[" Term ".." . Term "]" - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 247 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 102 Expression: "(" error ")" . + + $default reduce using rule 102 (Expression) State 172 - 116 List: "[" Terms "]" . - - $default reduce using rule 116 (List) + 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 State 173 - 118 Terms: Terms "," . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 248 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 101 Expression: "(" Term ")" . + $default reduce using rule 101 (Expression) -State 174 - 29 Initializers: Initializers "," Initializer . +State 174 - $default reduce using rule 29 (Initializers) + 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 State 175 - 121 Arguments: "(" error . ")" + 126 List: "[" error "]" . - ")" shift, and go to state 249 + $default reduce using rule 126 (List) State 176 - 122 Arguments: "(" ")" . - - $default reduce using rule 122 (Arguments) + 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 State 177 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - 119 Terms: Term . - - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "implies" shift, and go to state 123 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - "<" 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 134 - "!=" shift, and go to state 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 - - $default reduce using rule 119 (Terms) + 125 List: "[" Terms "]" . + $default reduce using rule 125 (List) -State 178 - 118 Terms: Terms . "," Term - 120 Arguments: "(" Terms . ")" +State 178 - ")" shift, and go to state 250 - "," shift, and go to state 173 + 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 State 179 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 110 | Term "and" Term . - 111 | Term . "=>" Term - 112 | Term . "implies" Term - - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - "<" 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 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 + 30 Initializers: Initializers "," Initializer . - $default reduce using rule 110 (Expression) + $default reduce using rule 30 (Initializers) State 180 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 108 | Term "or" Term . - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - - "and" shift, and go to state 120 - "xor" shift, and go to state 122 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - "<" 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 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 + 130 Arguments: "(" error . ")" - $default reduce using rule 108 (Expression) + ")" shift, and go to state 261 State 181 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 109 | Term "xor" Term . - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - - "and" shift, and go to state 120 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - "<" 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 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 + 131 Arguments: "(" ")" . - $default reduce using rule 109 (Expression) + $default reduce using rule 131 (Arguments) State 182 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - 112 | Term "implies" Term . - - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - "<" 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 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 - - $default reduce using rule 112 (Expression) + 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) State 183 - 96 Expression: Term . "+" Term - 96 | Term "+" Term . - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - - "*" shift, and go to state 129 - "/" shift, and go to state 130 - "%" shift, and go to state 131 - "^" shift, and go to state 132 - - $default reduce using rule 96 (Expression) + 127 Terms: Terms . "," Term + 129 Arguments: "(" Terms . ")" + + ")" shift, and go to state 262 + "," shift, and go to state 178 State 184 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 97 | Term "-" Term . - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - - "*" shift, and go to state 129 - "/" shift, and go to state 130 - "%" shift, and go to state 131 - "^" shift, and go to state 132 - - $default reduce using rule 97 (Expression) + 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 + + $default reduce using rule 119 (Expression) State 185 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 103 | Term "=" Term . - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "<" 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 136 - ">=" shift, and go to state 137 - - $default reduce using rule 103 (Expression) + 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) State 186 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 104 | Term "<" Term . - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "*" shift, and go to state 129 - "/" shift, and go to state 130 - "%" shift, and go to state 131 - "^" shift, and go to state 132 - - $default reduce using rule 104 (Expression) + 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) State 187 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 105 | Term ">" Term . - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "*" shift, and go to state 129 - "/" shift, and go to state 130 - "%" shift, and go to state 131 - "^" shift, and go to state 132 - - $default reduce using rule 105 (Expression) + 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) State 188 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 98 | Term "*" Term . - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - - "^" shift, and go to state 132 - - $default reduce using rule 98 (Expression) + 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) State 189 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 99 | Term "/" Term . - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - - "^" shift, and go to state 132 - - $default reduce using rule 99 (Expression) + 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) State 190 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 100 | Term "%" Term . - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - - "^" shift, and go to state 132 - - $default reduce using rule 100 (Expression) + 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 + + $default reduce using rule 112 (Expression) State 191 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 101 | Term "^" Term . - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" 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 + 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 101 (Expression) + $default reduce using rule 113 (Expression) State 192 - 27 Initializer: Term "->" Term . - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "implies" shift, and go to state 123 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - "<" 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 134 - "!=" shift, and go to state 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 - - $default reduce using rule 27 (Initializer) + 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 + + $default reduce using rule 114 (Expression) State 193 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 111 | Term "=>" Term . - 112 | Term . "implies" Term - - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - "<" 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 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 + 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 111 (Expression) + $default reduce using rule 107 (Expression) State 194 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 102 | Term "!=" Term . - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "<" 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 136 - ">=" shift, and go to state 137 + 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 102 (Expression) + $default reduce using rule 108 (Expression) State 195 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 106 | Term "<=" Term . - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "*" shift, and go to state 129 - "/" shift, and go to state 130 - "%" shift, and go to state 131 - "^" shift, and go to state 132 + 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 - $default reduce using rule 106 (Expression) + $default reduce using rule 109 (Expression) State 196 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 107 | Term ">=" Term . - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "*" shift, and go to state 129 - "/" shift, and go to state 130 - "%" shift, and go to state 131 - "^" shift, and go to state 132 + 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 - $default reduce using rule 107 (Expression) + $default reduce using rule 110 (Expression) State 197 - 28 Initializer: TwoOrMoreArguments "->" Term . - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "implies" shift, and go to state 123 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - "<" 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 134 - "!=" shift, and go to state 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 + 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 $default reduce using rule 28 (Initializer) State 198 - 51 MaybeParameters: "(" error ")" . - - $default reduce using rule 51 (MaybeParameters) + 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 + + $default reduce using rule 120 (Expression) State 199 - 50 MaybeParameters: "(" Parameters ")" . + 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 50 (MaybeParameters) + $default reduce using rule 111 (Expression) State 200 - 48 Parameters: Parameters "," . AttributedVariable - - "in" shift, and go to state 21 - "[" shift, and go to state 96 - "identifier" shift, and go to state 24 - - Identifier go to state 97 - Variable go to state 98 - AttributedVariable go to state 251 + 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 + + $default reduce using rule 115 (Expression) State 201 - 33 DerivedDefinition: "derived" Identifier MaybeParameters "->" Type . "=" Term - - "=" shift, and go to 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 + 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) State 202 - 39 Identifiers: Identifier . - - $default reduce using rule 39 (Identifiers) + 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) State 203 - 34 EnumerationDefinition: "enum" Identifier "=" "{" Identifiers . "}" - 38 Identifiers: Identifiers . "," Identifier + 60 MaybeParameters: "(" error ")" . - "}" shift, and go to state 253 - "," shift, and go to state 254 + $default reduce using rule 60 (MaybeParameters) State 204 - 166 SequenceRule: "seq" . Rules "endseq" - 168 | "seq" . error "endseq" - - error shift, and go to state 255 - "seq" shift, and go to state 204 - "par" shift, and go to state 205 - "skip" shift, and go to state 206 - "let" shift, and go to state 207 - "in" shift, and go to state 21 - "forall" shift, and go to state 208 - "choose" shift, and go to state 209 - "iterate" shift, and go to state 210 - "call" shift, and go to state 211 - "if" shift, and go to state 212 - "case" shift, and go to state 213 - "(" shift, and go to state 214 - "{" shift, and go to state 215 - "." shift, and go to state 23 - "{|" shift, and go to state 216 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - DirectCallExpression go to state 217 - IndirectCallExpression go to state 218 - Rule go to state 256 - Rules go to state 257 - SkipRule go to state 220 - ConditionalRule go to state 221 - CaseRule go to state 222 - LetRule go to state 223 - ForallRule go to state 224 - ChooseRule go to state 225 - IterateRule go to state 226 - BlockRule go to state 227 - SequenceRule go to state 228 - UpdateRule go to state 229 - CallRule go to state 230 + 59 MaybeParameters: "(" Parameters ")" . + + $default reduce using rule 59 (MaybeParameters) State 205 - 162 BlockRule: "par" . Rules "endpar" - 164 | "par" . error "endpar" - - error shift, and go to state 258 - "seq" shift, and go to state 204 - "par" shift, and go to state 205 - "skip" shift, and go to state 206 - "let" shift, and go to state 207 - "in" shift, and go to state 21 - "forall" shift, and go to state 208 - "choose" shift, and go to state 209 - "iterate" shift, and go to state 210 - "call" shift, and go to state 211 - "if" shift, and go to state 212 - "case" shift, and go to state 213 - "(" shift, and go to state 214 - "{" shift, and go to state 215 - "." shift, and go to state 23 - "{|" shift, and go to state 216 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - DirectCallExpression go to state 217 - IndirectCallExpression go to state 218 - Rule go to state 256 - Rules go to state 259 - SkipRule go to state 220 - ConditionalRule go to state 221 - CaseRule go to state 222 - LetRule go to state 223 - ForallRule go to state 224 - ChooseRule go to state 225 - IterateRule go to state 226 - BlockRule go to state 227 - SequenceRule go to state 228 - UpdateRule go to state 229 - CallRule go to state 230 + 57 Parameters: Parameters "," . AttributedVariable + + "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 263 State 206 - 147 SkipRule: "skip" . + 34 DerivedDefinition: "derived" Identifier MaybeParameters "->" Type . "=" Term - $default reduce using rule 147 (SkipRule) + "=" shift, and go to state 264 State 207 - 157 LetRule: "let" . AttributedVariable "=" Term "in" Rule + 48 Identifiers: Identifier . - "in" shift, and go to state 21 - "[" shift, and go to state 96 - "identifier" shift, and go to state 24 - - Identifier go to state 97 - Variable go to state 98 - AttributedVariable go to state 260 + $default reduce using rule 48 (Identifiers) State 208 - 158 ForallRule: "forall" . AttributedVariable "in" Term "do" Rule - - "in" shift, and go to state 21 - "[" shift, and go to state 96 - "identifier" shift, and go to state 24 + 35 EnumerationDefinition: "enum" Identifier "=" "{" Identifiers . "}" + 47 Identifiers: Identifiers . "," Identifier - Identifier go to state 97 - Variable go to state 98 - AttributedVariable go to state 261 + "}" shift, and go to state 265 + "," shift, and go to state 266 State 209 - 159 ChooseRule: "choose" . AttributedVariable "in" Term "do" Rule - - "in" shift, and go to state 21 - "[" shift, and go to state 96 - "identifier" shift, and go to state 24 - - Identifier go to state 97 - Variable go to state 98 - AttributedVariable go to state 262 + 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 State 210 - 160 IterateRule: "iterate" . Rule - - "seq" shift, and go to state 204 - "par" shift, and go to state 205 - "skip" shift, and go to state 206 - "let" shift, and go to state 207 - "in" shift, and go to state 21 - "forall" shift, and go to state 208 - "choose" shift, and go to state 209 - "iterate" shift, and go to state 210 - "call" shift, and go to state 211 - "if" shift, and go to state 212 - "case" shift, and go to state 213 - "(" shift, and go to state 214 - "{" shift, and go to state 215 - "." shift, and go to state 23 - "{|" shift, and go to state 216 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - DirectCallExpression go to state 217 - IndirectCallExpression go to state 218 - Rule go to state 263 - SkipRule go to state 220 - ConditionalRule go to state 221 - CaseRule go to state 222 - LetRule go to state 223 - ForallRule go to state 224 - ChooseRule go to state 225 - IterateRule go to state 226 - BlockRule go to state 227 - SequenceRule go to state 228 - UpdateRule go to state 229 - CallRule go to state 230 + 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 -State 211 - 170 CallRule: "call" . DirectCallExpression - 172 | "call" . IndirectCallExpression +State 211 - "in" shift, and go to state 21 - "(" shift, and go to state 214 - "." shift, and go to state 23 - "identifier" shift, and go to state 24 + 156 SkipRule: "skip" . - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - DirectCallExpression go to state 264 - IndirectCallExpression go to state 265 + $default reduce using rule 156 (SkipRule) State 212 - 148 ConditionalRule: "if" . Term "then" Rule - 149 | "if" . Term "then" Rule "else" Rule - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 266 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 + + Identifier go to state 101 + Variable go to state 102 + AttributedVariable go to state 272 State 213 - 150 CaseRule: "case" . Term "of" "{" CaseLabels "}" - 151 | "case" . Term "of" "{" error "}" - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 267 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 + + Identifier go to state 101 + Variable go to state 102 + AttributedVariable go to state 273 State 214 - 126 IndirectCallExpression: "(" . "*" Term ")" Arguments + 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 - "*" shift, and go to state 108 + Identifier go to state 101 + Variable go to state 102 + AttributedVariable go to state 274 State 215 - 161 BlockRule: "{" . Rules "}" - 163 | "{" . error "}" - - error shift, and go to state 268 - "seq" shift, and go to state 204 - "par" shift, and go to state 205 - "skip" shift, and go to state 206 - "let" shift, and go to state 207 - "in" shift, and go to state 21 - "forall" shift, and go to state 208 - "choose" shift, and go to state 209 - "iterate" shift, and go to state 210 - "call" shift, and go to state 211 - "if" shift, and go to state 212 - "case" shift, and go to state 213 - "(" shift, and go to state 214 - "{" shift, and go to state 215 - "." shift, and go to state 23 - "{|" shift, and go to state 216 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - DirectCallExpression go to state 217 - IndirectCallExpression go to state 218 - Rule go to state 256 - Rules go to state 269 - SkipRule go to state 220 - ConditionalRule go to state 221 - CaseRule go to state 222 - LetRule go to state 223 - ForallRule go to state 224 - ChooseRule go to state 225 - IterateRule go to state 226 - BlockRule go to state 227 - SequenceRule go to state 228 - UpdateRule go to state 229 - CallRule go to state 230 + 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 State 216 - 165 SequenceRule: "{|" . Rules "|}" - 167 | "{|" . error "|}" - - error shift, and go to state 270 - "seq" shift, and go to state 204 - "par" shift, and go to state 205 - "skip" shift, and go to state 206 - "let" shift, and go to state 207 - "in" shift, and go to state 21 - "forall" shift, and go to state 208 - "choose" shift, and go to state 209 - "iterate" shift, and go to state 210 - "call" shift, and go to state 211 - "if" shift, and go to state 212 - "case" shift, and go to state 213 - "(" shift, and go to state 214 - "{" shift, and go to state 215 - "." shift, and go to state 23 - "{|" shift, and go to state 216 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - DirectCallExpression go to state 217 - IndirectCallExpression go to state 218 - Rule go to state 256 - Rules go to state 271 - SkipRule go to state 220 - ConditionalRule go to state 221 - CaseRule go to state 222 - LetRule go to state 223 - ForallRule go to state 224 - ChooseRule go to state 225 - IterateRule go to state 226 - BlockRule go to state 227 - SequenceRule go to state 228 - UpdateRule go to state 229 - CallRule go to state 230 + 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 -State 217 + 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 - 169 UpdateRule: DirectCallExpression . ":=" Term - 171 CallRule: DirectCallExpression . - ":=" shift, and go to state 272 +State 217 - $default reduce using rule 171 (CallRule) + 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 State 218 - 173 CallRule: IndirectCallExpression . - - $default reduce using rule 173 (CallRule) + 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 State 219 - 132 RuleDefinition: "rule" Identifier MaybeParameters "=" Rule . + 135 IndirectCallExpression: "(" . "*" Term ")" Arguments - $default reduce using rule 132 (RuleDefinition) + "*" shift, and go to state 112 State 220 - 134 Rule: SkipRule . - - $default reduce using rule 134 (Rule) + 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 State 221 - 135 Rule: ConditionalRule . - - $default reduce using rule 135 (Rule) + 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 State 222 - 136 Rule: CaseRule . + 178 UpdateRule: DirectCallExpression . ":=" Term + 180 CallRule: DirectCallExpression . + + ":=" shift, and go to state 284 - $default reduce using rule 136 (Rule) + $default reduce using rule 180 (CallRule) State 223 - 137 Rule: LetRule . + 182 CallRule: IndirectCallExpression . - $default reduce using rule 137 (Rule) + $default reduce using rule 182 (CallRule) State 224 - 138 Rule: ForallRule . + 141 RuleDefinition: "rule" Identifier MaybeParameters "=" Rule . - $default reduce using rule 138 (Rule) + $default reduce using rule 141 (RuleDefinition) State 225 - 139 Rule: ChooseRule . + 143 Rule: SkipRule . - $default reduce using rule 139 (Rule) + $default reduce using rule 143 (Rule) State 226 - 140 Rule: IterateRule . + 144 Rule: ConditionalRule . - $default reduce using rule 140 (Rule) + $default reduce using rule 144 (Rule) State 227 - 141 Rule: BlockRule . + 145 Rule: CaseRule . - $default reduce using rule 141 (Rule) + $default reduce using rule 145 (Rule) State 228 - 142 Rule: SequenceRule . + 146 Rule: LetRule . - $default reduce using rule 142 (Rule) + $default reduce using rule 146 (Rule) State 229 - 143 Rule: UpdateRule . + 147 Rule: ForallRule . - $default reduce using rule 143 (Rule) + $default reduce using rule 147 (Rule) State 230 - 144 Rule: CallRule . + 148 Rule: ChooseRule . - $default reduce using rule 144 (Rule) + $default reduce using rule 148 (Rule) State 231 - 133 RuleDefinition: "rule" Identifier MaybeParameters "->" Type . "=" Rule + 149 Rule: IterateRule . - "=" shift, and go to state 273 + $default reduce using rule 149 (Rule) State 232 - 20 FunctionParameters: FunctionParameters "*" . Type - - "in" shift, and go to state 21 - "." shift, and go to state 23 - "identifier" shift, and go to state 24 + 150 Rule: BlockRule . - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 149 - Type go to state 274 - BasicType go to state 151 - ComposedType go to state 152 - RelationType go to state 153 - FixedSizedType go to state 154 + $default reduce using rule 150 (Rule) State 233 - 12 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" . Type MaybeDefined MaybeInitially + 151 Rule: SequenceRule . - "in" shift, and go to state 21 - "." shift, and go to state 23 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 149 - Type go to state 275 - BasicType go to state 151 - ComposedType go to state 152 - RelationType go to state 153 - FixedSizedType go to state 154 + $default reduce using rule 151 (Rule) State 234 - 58 ComposedType: IdentifierPath "<" . Types ">" - 59 RelationType: IdentifierPath "<" . MaybeFunctionParameters "->" Type ">" - - "in" shift, and go to state 21 - "." shift, and go to state 23 - "identifier" shift, and go to state 24 - - $default reduce using rule 23 (MaybeFunctionParameters) + 152 Rule: UpdateRule . - FunctionParameters go to state 147 - MaybeFunctionParameters go to state 276 - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 149 - Type go to state 277 - BasicType go to state 151 - ComposedType go to state 152 - RelationType go to state 153 - FixedSizedType go to state 154 - Types go to state 278 + $default reduce using rule 152 (Rule) State 235 - 60 FixedSizedType: IdentifierPath "'" . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 279 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 153 Rule: CallRule . + + $default reduce using rule 153 (Rule) State 236 - 15 FunctionDefinitions: FunctionDefinition . + 142 RuleDefinition: "rule" Identifier MaybeParameters "->" Type . "=" Rule - $default reduce using rule 15 (FunctionDefinitions) + "=" shift, and go to state 285 State 237 - 14 FunctionDefinitions: FunctionDefinitions . "," FunctionDefinition - 35 StructureDefinition: "structure" Identifier "=" "{" FunctionDefinitions . "}" + 21 FunctionParameters: FunctionParameters "*" . Type - "}" shift, and go to state 280 - "," shift, and go to state 281 + "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 State 238 - 46 AttributedVariable: "[" Attributes "]" . Variable + 13 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" . Type MaybeDefined MaybeInitially - "in" shift, and go to state 21 - "identifier" shift, and go to state 24 + "in" shift, and go to state 23 + "." shift, and go to state 25 + "identifier" shift, and go to state 26 - Identifier go to state 97 - Variable go to state 282 + 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 State 239 - 44 Variable: Identifier ":" Type . + 67 ComposedType: IdentifierPath "<" . Types ">" + 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 + + $default reduce using rule 24 (MaybeFunctionParameters) - $default reduce using rule 44 (Variable) + 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 State 240 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - 127 LetExpression: "let" AttributedVariable "=" Term . "in" Term - - "in" shift, and go to state 283 - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "implies" shift, and go to state 123 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - "<" 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 134 - "!=" shift, and go to state 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 + 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 State 241 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - 130 UniversalQuantifierExpression: "forall" AttributedVariable "in" Term . "holds" Term - - "holds" shift, and go to state 284 - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "implies" shift, and go to state 123 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - "<" 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 134 - "!=" shift, and go to state 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 + 16 FunctionDefinitions: FunctionDefinition . + + $default reduce using rule 16 (FunctionDefinitions) State 242 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - 129 ChooseExpression: "choose" AttributedVariable "in" Term . "do" Term - - "do" shift, and go to state 285 - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "implies" shift, and go to state 123 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - "<" 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 134 - "!=" shift, and go to state 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 + 15 FunctionDefinitions: FunctionDefinitions . "," FunctionDefinition + 36 StructureDefinition: "structure" Identifier "=" "{" FunctionDefinitions . "}" + + "}" shift, and go to state 292 + "," shift, and go to state 293 State 243 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - 128 ConditionalExpression: "if" Term "then" Term . "else" Term - - "else" shift, and go to state 286 - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "implies" shift, and go to state 123 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - "<" 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 134 - "!=" shift, and go to state 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 + 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 + + Identifier go to state 294 State 244 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - 131 ExistentialQuantifierExpression: "exists" AttributedVariable "in" Term . "with" Term - - "with" shift, and go to state 287 - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "implies" shift, and go to state 123 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - "<" 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 134 - "!=" shift, and go to state 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 + 44 DeclarationDefinition: "rule" . Identifier ":" MaybeFunctionParameters "->" Type + 141 RuleDefinition: "rule" . Identifier MaybeParameters "=" Rule + 142 | "rule" . Identifier MaybeParameters "->" Type "=" Rule + "in" shift, and go to state 23 + "identifier" shift, and go to state 26 + + Identifier go to state 295 -State 245 - 126 IndirectCallExpression: "(" "*" Term ")" . Arguments +State 245 - "(" shift, and go to state 118 + 39 FeatureDeclarationOrDefinition: DerivedDefinition . - Arguments go to state 288 + $default reduce using rule 39 (FeatureDeclarationOrDefinition) State 246 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - 118 Terms: Terms "," Term . - 123 TwoOrMoreArguments: "(" Terms "," Term . ")" - - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "implies" shift, and go to state 123 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - ")" shift, and go to state 289 - "<" 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 134 - "!=" shift, and go to state 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 - - $default reduce using rule 118 (Terms) + 42 FeatureDeclarationsAndDefinitions: FeatureDeclarationOrDefinition . + + $default reduce using rule 42 (FeatureDeclarationsAndDefinitions) State 247 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - 114 Range: "[" Term ".." Term . "]" - - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "implies" shift, and go to state 123 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - "]" shift, and go to state 290 - "<" 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 134 - "!=" shift, and go to state 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 + 37 FeatureDefinition: "feature" Identifier "=" "{" FeatureDeclarationsAndDefinitions . "}" + 41 FeatureDeclarationsAndDefinitions: FeatureDeclarationsAndDefinitions . "," FeatureDeclarationOrDefinition + + "}" shift, and go to state 296 + "," shift, and go to state 297 State 248 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - 118 Terms: Terms "," Term . - - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "implies" shift, and go to state 123 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - "<" 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 134 - "!=" shift, and go to state 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 - - $default reduce using rule 118 (Terms) + 38 FeatureDeclarationOrDefinition: DeclarationDefinition . + + $default reduce using rule 38 (FeatureDeclarationOrDefinition) State 249 - 121 Arguments: "(" error ")" . + 40 FeatureDeclarationOrDefinition: RuleDefinition . - $default reduce using rule 121 (Arguments) + $default reduce using rule 40 (FeatureDeclarationOrDefinition) State 250 - 120 Arguments: "(" Terms ")" . + 55 AttributedVariable: "[" Attributes "]" . Variable - $default reduce using rule 120 (Arguments) + "in" shift, and go to state 23 + "identifier" shift, and go to state 26 + + Identifier go to state 101 + Variable go to state 298 State 251 - 48 Parameters: Parameters "," AttributedVariable . + 53 Variable: Identifier ":" Type . - $default reduce using rule 48 (Parameters) + $default reduce using rule 53 (Variable) State 252 - 33 DerivedDefinition: "derived" Identifier MaybeParameters "->" Type "=" . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 291 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 State 253 - 34 EnumerationDefinition: "enum" Identifier "=" "{" Identifiers "}" . - - $default reduce using rule 34 (EnumerationDefinition) + 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 State 254 - 38 Identifiers: Identifiers "," . Identifier - - "in" shift, and go to state 21 - "identifier" shift, and go to state 24 - - Identifier go to state 292 + 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 State 255 - 168 SequenceRule: "seq" error . "endseq" - - "endseq" shift, and go to state 293 + 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 State 256 - 146 Rules: Rule . - - $default reduce using rule 146 (Rules) + 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 State 257 - 145 Rules: Rules . Rule - 166 SequenceRule: "seq" Rules . "endseq" - - "seq" shift, and go to state 204 - "endseq" shift, and go to state 294 - "par" shift, and go to state 205 - "skip" shift, and go to state 206 - "let" shift, and go to state 207 - "in" shift, and go to state 21 - "forall" shift, and go to state 208 - "choose" shift, and go to state 209 - "iterate" shift, and go to state 210 - "call" shift, and go to state 211 - "if" shift, and go to state 212 - "case" shift, and go to state 213 - "(" shift, and go to state 214 - "{" shift, and go to state 215 - "." shift, and go to state 23 - "{|" shift, and go to state 216 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - DirectCallExpression go to state 217 - IndirectCallExpression go to state 218 - Rule go to state 295 - SkipRule go to state 220 - ConditionalRule go to state 221 - CaseRule go to state 222 - LetRule go to state 223 - ForallRule go to state 224 - ChooseRule go to state 225 - IterateRule go to state 226 - BlockRule go to state 227 - SequenceRule go to state 228 - UpdateRule go to state 229 - CallRule go to state 230 + 135 IndirectCallExpression: "(" "*" Term ")" . Arguments + "(" shift, and go to state 122 + + Arguments go to state 304 -State 258 - 164 BlockRule: "par" error . "endpar" +State 258 - "endpar" shift, and go to state 296 + 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) State 259 - 145 Rules: Rules . Rule - 162 BlockRule: "par" Rules . "endpar" - - "seq" shift, and go to state 204 - "par" shift, and go to state 205 - "endpar" shift, and go to state 297 - "skip" shift, and go to state 206 - "let" shift, and go to state 207 - "in" shift, and go to state 21 - "forall" shift, and go to state 208 - "choose" shift, and go to state 209 - "iterate" shift, and go to state 210 - "call" shift, and go to state 211 - "if" shift, and go to state 212 - "case" shift, and go to state 213 - "(" shift, and go to state 214 - "{" shift, and go to state 215 - "." shift, and go to state 23 - "{|" shift, and go to state 216 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - DirectCallExpression go to state 217 - IndirectCallExpression go to state 218 - Rule go to state 295 - SkipRule go to state 220 - ConditionalRule go to state 221 - CaseRule go to state 222 - LetRule go to state 223 - ForallRule go to state 224 - ChooseRule go to state 225 - IterateRule go to state 226 - BlockRule go to state 227 - SequenceRule go to state 228 - UpdateRule go to state 229 - CallRule go to state 230 + 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 State 260 - 157 LetRule: "let" AttributedVariable . "=" Term "in" Rule - - "=" shift, and go to state 298 + 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) State 261 - 158 ForallRule: "forall" AttributedVariable . "in" Term "do" Rule + 130 Arguments: "(" error ")" . - "in" shift, and go to state 299 + $default reduce using rule 130 (Arguments) State 262 - 159 ChooseRule: "choose" AttributedVariable . "in" Term "do" Rule + 129 Arguments: "(" Terms ")" . - "in" shift, and go to state 300 + $default reduce using rule 129 (Arguments) State 263 - 160 IterateRule: "iterate" Rule . + 57 Parameters: Parameters "," AttributedVariable . - $default reduce using rule 160 (IterateRule) + $default reduce using rule 57 (Parameters) State 264 - 170 CallRule: "call" DirectCallExpression . - - $default reduce using rule 170 (CallRule) + 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 State 265 - 172 CallRule: "call" IndirectCallExpression . + 35 EnumerationDefinition: "enum" Identifier "=" "{" Identifiers "}" . - $default reduce using rule 172 (CallRule) + $default reduce using rule 35 (EnumerationDefinition) State 266 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - 148 ConditionalRule: "if" Term . "then" Rule - 149 | "if" Term . "then" Rule "else" Rule - - "then" shift, and go to state 301 - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "implies" shift, and go to state 123 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - "<" 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 134 - "!=" shift, and go to state 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 + 47 Identifiers: Identifiers "," . Identifier + + "in" shift, and go to state 23 + "identifier" shift, and go to state 26 + + Identifier go to state 308 State 267 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - 150 CaseRule: "case" Term . "of" "{" CaseLabels "}" - 151 | "case" Term . "of" "{" error "}" - - "of" shift, and go to state 302 - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "implies" shift, and go to state 123 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - "<" 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 134 - "!=" shift, and go to state 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 + 177 SequenceRule: "seq" error . "endseq" + + "endseq" shift, and go to state 309 State 268 - 163 BlockRule: "{" error . "}" + 155 Rules: Rule . - "}" shift, and go to state 303 + $default reduce using rule 155 (Rules) State 269 - 145 Rules: Rules . Rule - 161 BlockRule: "{" Rules . "}" - - "seq" shift, and go to state 204 - "par" shift, and go to state 205 - "skip" shift, and go to state 206 - "let" shift, and go to state 207 - "in" shift, and go to state 21 - "forall" shift, and go to state 208 - "choose" shift, and go to state 209 - "iterate" shift, and go to state 210 - "call" shift, and go to state 211 - "if" shift, and go to state 212 - "case" shift, and go to state 213 - "(" shift, and go to state 214 - "{" shift, and go to state 215 - "}" shift, and go to state 304 - "." shift, and go to state 23 - "{|" shift, and go to state 216 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - DirectCallExpression go to state 217 - IndirectCallExpression go to state 218 - Rule go to state 295 - SkipRule go to state 220 - ConditionalRule go to state 221 - CaseRule go to state 222 - LetRule go to state 223 - ForallRule go to state 224 - ChooseRule go to state 225 - IterateRule go to state 226 - BlockRule go to state 227 - SequenceRule go to state 228 - UpdateRule go to state 229 - CallRule go to state 230 + 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 State 270 - 167 SequenceRule: "{|" error . "|}" + 173 BlockRule: "par" error . "endpar" - "|}" shift, and go to state 305 + "endpar" shift, and go to state 312 State 271 - 145 Rules: Rules . Rule - 165 SequenceRule: "{|" Rules . "|}" - - "seq" shift, and go to state 204 - "par" shift, and go to state 205 - "skip" shift, and go to state 206 - "let" shift, and go to state 207 - "in" shift, and go to state 21 - "forall" shift, and go to state 208 - "choose" shift, and go to state 209 - "iterate" shift, and go to state 210 - "call" shift, and go to state 211 - "if" shift, and go to state 212 - "case" shift, and go to state 213 - "(" shift, and go to state 214 - "{" shift, and go to state 215 - "." shift, and go to state 23 - "{|" shift, and go to state 216 - "|}" shift, and go to state 306 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - DirectCallExpression go to state 217 - IndirectCallExpression go to state 218 - Rule go to state 295 - SkipRule go to state 220 - ConditionalRule go to state 221 - CaseRule go to state 222 - LetRule go to state 223 - ForallRule go to state 224 - ChooseRule go to state 225 - IterateRule go to state 226 - BlockRule go to state 227 - SequenceRule go to state 228 - UpdateRule go to state 229 - CallRule go to state 230 + 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 State 272 - 169 UpdateRule: DirectCallExpression ":=" . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 307 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 166 LetRule: "let" AttributedVariable . "=" Term "in" Rule + + "=" shift, and go to state 314 State 273 - 133 RuleDefinition: "rule" Identifier MaybeParameters "->" Type "=" . Rule - - "seq" shift, and go to state 204 - "par" shift, and go to state 205 - "skip" shift, and go to state 206 - "let" shift, and go to state 207 - "in" shift, and go to state 21 - "forall" shift, and go to state 208 - "choose" shift, and go to state 209 - "iterate" shift, and go to state 210 - "call" shift, and go to state 211 - "if" shift, and go to state 212 - "case" shift, and go to state 213 - "(" shift, and go to state 214 - "{" shift, and go to state 215 - "." shift, and go to state 23 - "{|" shift, and go to state 216 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - DirectCallExpression go to state 217 - IndirectCallExpression go to state 218 - Rule go to state 308 - SkipRule go to state 220 - ConditionalRule go to state 221 - CaseRule go to state 222 - LetRule go to state 223 - ForallRule go to state 224 - ChooseRule go to state 225 - IterateRule go to state 226 - BlockRule go to state 227 - SequenceRule go to state 228 - UpdateRule go to state 229 - CallRule go to state 230 + 167 ForallRule: "forall" AttributedVariable . "in" Term "do" Rule + + "in" shift, and go to state 315 State 274 - 20 FunctionParameters: FunctionParameters "*" Type . + 168 ChooseRule: "choose" AttributedVariable . "in" Term "do" Rule - $default reduce using rule 20 (FunctionParameters) + "in" shift, and go to state 316 State 275 - 12 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" Type . MaybeDefined MaybeInitially + 169 IterateRule: "iterate" Rule . - "defined" shift, and go to state 309 - - $default reduce using rule 19 (MaybeDefined) - - MaybeDefined go to state 310 + $default reduce using rule 169 (IterateRule) State 276 - 59 RelationType: IdentifierPath "<" MaybeFunctionParameters . "->" Type ">" + 179 CallRule: "call" DirectCallExpression . - "->" shift, and go to state 311 + $default reduce using rule 179 (CallRule) State 277 - 21 FunctionParameters: Type . - 62 Types: Type . + 181 CallRule: "call" IndirectCallExpression . - "," reduce using rule 62 (Types) - ">" reduce using rule 62 (Types) - $default reduce using rule 21 (FunctionParameters) + $default reduce using rule 181 (CallRule) State 278 - 58 ComposedType: IdentifierPath "<" Types . ">" - 61 Types: Types . "," Type - - "," shift, and go to state 312 - ">" shift, and go to state 313 + 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 State 279 - 60 FixedSizedType: IdentifierPath "'" Term . - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "implies" shift, and go to state 123 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "<" shift, and go to state 127 - "/" shift, and go to state 130 - "%" shift, and go to state 131 - "^" shift, and go to state 132 - "=>" shift, and go to state 134 - "!=" shift, and go to state 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 - - $default reduce using rule 60 (FixedSizedType) + 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 State 280 - 35 StructureDefinition: "structure" Identifier "=" "{" FunctionDefinitions "}" . + 172 BlockRule: "{" error . "}" - $default reduce using rule 35 (StructureDefinition) + "}" shift, and go to state 319 State 281 - 14 FunctionDefinitions: FunctionDefinitions "," . FunctionDefinition - - "init" shift, and go to state 4 - "function" shift, and go to state 8 - - FunctionDefinition go to state 314 - ProgramFunctionDefinition go to state 15 + 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 State 282 - 46 AttributedVariable: "[" Attributes "]" Variable . + 176 SequenceRule: "{|" error . "|}" - $default reduce using rule 46 (AttributedVariable) + "|}" shift, and go to state 321 State 283 - 127 LetExpression: "let" AttributedVariable "=" Term "in" . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 315 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 State 284 - 130 UniversalQuantifierExpression: "forall" AttributedVariable "in" Term "holds" . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 316 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 State 285 - 129 ChooseExpression: "choose" AttributedVariable "in" Term "do" . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 317 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 State 286 - 128 ConditionalExpression: "if" Term "then" Term "else" . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 318 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 21 FunctionParameters: FunctionParameters "*" Type . + + $default reduce using rule 21 (FunctionParameters) State 287 - 131 ExistentialQuantifierExpression: "exists" AttributedVariable "in" Term "with" . Term - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 319 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 State 288 - 126 IndirectCallExpression: "(" "*" Term ")" Arguments . + 68 RelationType: IdentifierPath "<" MaybeFunctionParameters . "->" Type ">" - $default reduce using rule 126 (IndirectCallExpression) + "->" shift, and go to state 327 State 289 - 123 TwoOrMoreArguments: "(" Terms "," Term ")" . + 22 FunctionParameters: Type . + 71 Types: Type . - $default reduce using rule 123 (TwoOrMoreArguments) + "," reduce using rule 71 (Types) + ">" reduce using rule 71 (Types) + $default reduce using rule 22 (FunctionParameters) State 290 - 114 Range: "[" Term ".." Term "]" . + 67 ComposedType: IdentifierPath "<" Types . ">" + 70 Types: Types . "," Type - $default reduce using rule 114 (Range) + "," shift, and go to state 328 + ">" shift, and go to state 329 State 291 - 33 DerivedDefinition: "derived" Identifier MaybeParameters "->" Type "=" Term . - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "implies" shift, and go to state 123 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - "<" 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 134 - "!=" shift, and go to state 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 - - $default reduce using rule 33 (DerivedDefinition) + 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) State 292 - 38 Identifiers: Identifiers "," Identifier . + 36 StructureDefinition: "structure" Identifier "=" "{" FunctionDefinitions "}" . - $default reduce using rule 38 (Identifiers) + $default reduce using rule 36 (StructureDefinition) State 293 - 168 SequenceRule: "seq" error "endseq" . + 15 FunctionDefinitions: FunctionDefinitions "," . FunctionDefinition - $default reduce using rule 168 (SequenceRule) + "init" shift, and go to state 4 + "function" shift, and go to state 8 + + FunctionDefinition go to state 330 + ProgramFunctionDefinition go to state 16 State 294 - 166 SequenceRule: "seq" Rules "endseq" . + 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) - $default reduce using rule 166 (SequenceRule) + MaybeParameters go to state 90 State 295 - 145 Rules: Rules Rule . + 44 DeclarationDefinition: "rule" Identifier . ":" MaybeFunctionParameters "->" Type + 141 RuleDefinition: "rule" Identifier . MaybeParameters "=" Rule + 142 | "rule" Identifier . MaybeParameters "->" Type "=" Rule - $default reduce using rule 145 (Rules) + "(" shift, and go to state 89 + ":" shift, and go to state 332 + + $default reduce using rule 61 (MaybeParameters) + + MaybeParameters go to state 92 State 296 - 164 BlockRule: "par" error "endpar" . + 37 FeatureDefinition: "feature" Identifier "=" "{" FeatureDeclarationsAndDefinitions "}" . - $default reduce using rule 164 (BlockRule) + $default reduce using rule 37 (FeatureDefinition) State 297 - 162 BlockRule: "par" Rules "endpar" . + 41 FeatureDeclarationsAndDefinitions: FeatureDeclarationsAndDefinitions "," . FeatureDeclarationOrDefinition - $default reduce using rule 162 (BlockRule) + "derived" shift, and go to state 243 + "rule" shift, and go to state 244 + + DerivedDefinition go to state 245 + FeatureDeclarationOrDefinition go to state 333 + DeclarationDefinition go to state 248 + RuleDefinition go to state 249 State 298 - 157 LetRule: "let" AttributedVariable "=" . Term "in" Rule - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 320 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 55 AttributedVariable: "[" Attributes "]" Variable . + + $default reduce using rule 55 (AttributedVariable) State 299 - 158 ForallRule: "forall" AttributedVariable "in" . Term "do" Rule - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 321 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 State 300 - 159 ChooseRule: "choose" AttributedVariable "in" . Term "do" Rule - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 322 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 State 301 - 148 ConditionalRule: "if" Term "then" . Rule - 149 | "if" Term "then" . Rule "else" Rule - - "seq" shift, and go to state 204 - "par" shift, and go to state 205 - "skip" shift, and go to state 206 - "let" shift, and go to state 207 - "in" shift, and go to state 21 - "forall" shift, and go to state 208 - "choose" shift, and go to state 209 - "iterate" shift, and go to state 210 - "call" shift, and go to state 211 - "if" shift, and go to state 212 - "case" shift, and go to state 213 - "(" shift, and go to state 214 - "{" shift, and go to state 215 - "." shift, and go to state 23 - "{|" shift, and go to state 216 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - DirectCallExpression go to state 217 - IndirectCallExpression go to state 218 - Rule go to state 323 - SkipRule go to state 220 - ConditionalRule go to state 221 - CaseRule go to state 222 - LetRule go to state 223 - ForallRule go to state 224 - ChooseRule go to state 225 - IterateRule go to state 226 - BlockRule go to state 227 - SequenceRule go to state 228 - UpdateRule go to state 229 - CallRule go to state 230 + 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 State 302 - 150 CaseRule: "case" Term "of" . "{" CaseLabels "}" - 151 | "case" Term "of" . "{" error "}" - - "{" shift, and go to state 324 + 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 State 303 - 163 BlockRule: "{" error "}" . - - $default reduce using rule 163 (BlockRule) + 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 State 304 - 161 BlockRule: "{" Rules "}" . + 135 IndirectCallExpression: "(" "*" Term ")" Arguments . - $default reduce using rule 161 (BlockRule) + $default reduce using rule 135 (IndirectCallExpression) State 305 - 167 SequenceRule: "{|" error "|}" . + 132 TwoOrMoreArguments: "(" Terms "," Term ")" . - $default reduce using rule 167 (SequenceRule) + $default reduce using rule 132 (TwoOrMoreArguments) State 306 - 165 SequenceRule: "{|" Rules "|}" . + 123 Range: "[" Term ".." Term "]" . - $default reduce using rule 165 (SequenceRule) + $default reduce using rule 123 (Range) State 307 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - 169 UpdateRule: DirectCallExpression ":=" Term . - - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "implies" shift, and go to state 123 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - "<" 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 134 - "!=" shift, and go to state 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 - - $default reduce using rule 169 (UpdateRule) + 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) State 308 - 133 RuleDefinition: "rule" Identifier MaybeParameters "->" Type "=" Rule . + 47 Identifiers: Identifiers "," Identifier . - $default reduce using rule 133 (RuleDefinition) + $default reduce using rule 47 (Identifiers) State 309 - 18 MaybeDefined: "defined" . "{" Term "}" + 177 SequenceRule: "seq" error "endseq" . - "{" shift, and go to state 325 + $default reduce using rule 177 (SequenceRule) State 310 - 12 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined . MaybeInitially + 175 SequenceRule: "seq" Rules "endseq" . - "initially" shift, and go to state 326 - - $default reduce using rule 17 (MaybeInitially) - - MaybeInitially go to state 327 + $default reduce using rule 175 (SequenceRule) State 311 - 59 RelationType: IdentifierPath "<" MaybeFunctionParameters "->" . Type ">" - - "in" shift, and go to state 21 - "." shift, and go to state 23 - "identifier" shift, and go to state 24 + 154 Rules: Rules Rule . - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 149 - Type go to state 328 - BasicType go to state 151 - ComposedType go to state 152 - RelationType go to state 153 - FixedSizedType go to state 154 + $default reduce using rule 154 (Rules) State 312 - 61 Types: Types "," . Type + 173 BlockRule: "par" error "endpar" . - "in" shift, and go to state 21 - "." shift, and go to state 23 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 149 - Type go to state 329 - BasicType go to state 151 - ComposedType go to state 152 - RelationType go to state 153 - FixedSizedType go to state 154 + $default reduce using rule 173 (BlockRule) State 313 - 58 ComposedType: IdentifierPath "<" Types ">" . + 171 BlockRule: "par" Rules "endpar" . - $default reduce using rule 58 (ComposedType) + $default reduce using rule 171 (BlockRule) State 314 - 14 FunctionDefinitions: FunctionDefinitions "," FunctionDefinition . - - $default reduce using rule 14 (FunctionDefinitions) + 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 State 315 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - 127 LetExpression: "let" AttributedVariable "=" Term "in" Term . - - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "implies" shift, and go to state 123 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - "<" 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 134 - "!=" shift, and go to state 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 - - $default reduce using rule 127 (LetExpression) + 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 State 316 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - 130 UniversalQuantifierExpression: "forall" AttributedVariable "in" Term "holds" Term . - - $default reduce using rule 130 (UniversalQuantifierExpression) + 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 State 317 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - 129 ChooseExpression: "choose" AttributedVariable "in" Term "do" Term . - - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "implies" shift, and go to state 123 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - "<" 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 134 - "!=" shift, and go to state 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 - - $default reduce using rule 129 (ChooseExpression) + 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 State 318 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - 128 ConditionalExpression: "if" Term "then" Term "else" Term . - - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "implies" shift, and go to state 123 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - "<" 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 134 - "!=" shift, and go to state 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 - - $default reduce using rule 128 (ConditionalExpression) + 159 CaseRule: "case" Term "of" . "{" CaseLabels "}" + 160 | "case" Term "of" . "{" error "}" + + "{" shift, and go to state 343 State 319 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - 131 ExistentialQuantifierExpression: "exists" AttributedVariable "in" Term "with" Term . - - $default reduce using rule 131 (ExistentialQuantifierExpression) + 172 BlockRule: "{" error "}" . + + $default reduce using rule 172 (BlockRule) State 320 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - 157 LetRule: "let" AttributedVariable "=" Term . "in" Rule - - "in" shift, and go to state 330 - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "implies" shift, and go to state 123 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - "<" 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 134 - "!=" shift, and go to state 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 + 170 BlockRule: "{" Rules "}" . + + $default reduce using rule 170 (BlockRule) State 321 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - 158 ForallRule: "forall" AttributedVariable "in" Term . "do" Rule - - "do" shift, and go to state 331 - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "implies" shift, and go to state 123 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - "<" 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 134 - "!=" shift, and go to state 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 + 176 SequenceRule: "{|" error "|}" . + $default reduce using rule 176 (SequenceRule) -State 322 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - 159 ChooseRule: "choose" AttributedVariable "in" Term . "do" Rule - - "do" shift, and go to state 332 - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "implies" shift, and go to state 123 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - "<" 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 134 - "!=" shift, and go to state 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 +State 322 + 174 SequenceRule: "{|" Rules "|}" . -State 323 + $default reduce using rule 174 (SequenceRule) - 148 ConditionalRule: "if" Term "then" Rule . - 149 | "if" Term "then" Rule . "else" Rule - "else" shift, and go to state 333 +State 323 - $default reduce using rule 148 (ConditionalRule) + 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) State 324 - 150 CaseRule: "case" Term "of" "{" . CaseLabels "}" - 151 | "case" Term "of" "{" . error "}" - - error shift, and go to state 334 - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "default" shift, and go to state 335 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "_" shift, and go to state 336 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 337 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 - CaseLabel go to state 338 - CaseLabels go to state 339 + 142 RuleDefinition: "rule" Identifier MaybeParameters "->" Type "=" Rule . + + $default reduce using rule 142 (RuleDefinition) State 325 - 18 MaybeDefined: "defined" "{" . Term "}" - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 340 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 19 MaybeDefined: "defined" . "{" Term "}" + + "{" shift, and go to state 344 State 326 - 16 MaybeInitially: "initially" . "{" MaybeInitializers "}" + 13 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined . MaybeInitially - "{" shift, and go to state 341 + "initially" shift, and go to state 345 + + $default reduce using rule 18 (MaybeInitially) + + MaybeInitially go to state 346 State 327 - 12 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially . + 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 - $default reduce using rule 12 (FunctionDefinition) + 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 State 328 - 59 RelationType: IdentifierPath "<" MaybeFunctionParameters "->" Type . ">" + 70 Types: Types "," . Type - ">" shift, and go to state 342 + "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 348 + BasicType go to state 155 + ComposedType go to state 156 + RelationType go to state 157 + FixedSizedType go to state 158 State 329 - 61 Types: Types "," Type . + 67 ComposedType: IdentifierPath "<" Types ">" . - $default reduce using rule 61 (Types) + $default reduce using rule 67 (ComposedType) State 330 - 157 LetRule: "let" AttributedVariable "=" Term "in" . Rule - - "seq" shift, and go to state 204 - "par" shift, and go to state 205 - "skip" shift, and go to state 206 - "let" shift, and go to state 207 - "in" shift, and go to state 21 - "forall" shift, and go to state 208 - "choose" shift, and go to state 209 - "iterate" shift, and go to state 210 - "call" shift, and go to state 211 - "if" shift, and go to state 212 - "case" shift, and go to state 213 - "(" shift, and go to state 214 - "{" shift, and go to state 215 - "." shift, and go to state 23 - "{|" shift, and go to state 216 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - DirectCallExpression go to state 217 - IndirectCallExpression go to state 218 - Rule go to state 343 - SkipRule go to state 220 - ConditionalRule go to state 221 - CaseRule go to state 222 - LetRule go to state 223 - ForallRule go to state 224 - ChooseRule go to state 225 - IterateRule go to state 226 - BlockRule go to state 227 - SequenceRule go to state 228 - UpdateRule go to state 229 - CallRule go to state 230 + 15 FunctionDefinitions: FunctionDefinitions "," FunctionDefinition . + + $default reduce using rule 15 (FunctionDefinitions) State 331 - 158 ForallRule: "forall" AttributedVariable "in" Term "do" . Rule - - "seq" shift, and go to state 204 - "par" shift, and go to state 205 - "skip" shift, and go to state 206 - "let" shift, and go to state 207 - "in" shift, and go to state 21 - "forall" shift, and go to state 208 - "choose" shift, and go to state 209 - "iterate" shift, and go to state 210 - "call" shift, and go to state 211 - "if" shift, and go to state 212 - "case" shift, and go to state 213 - "(" shift, and go to state 214 - "{" shift, and go to state 215 - "." shift, and go to state 23 - "{|" shift, and go to state 216 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - DirectCallExpression go to state 217 - IndirectCallExpression go to state 218 - Rule go to state 344 - SkipRule go to state 220 - ConditionalRule go to state 221 - CaseRule go to state 222 - LetRule go to state 223 - ForallRule go to state 224 - ChooseRule go to state 225 - IterateRule go to state 226 - BlockRule go to state 227 - SequenceRule go to state 228 - UpdateRule go to state 229 - CallRule go to state 230 + 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 State 332 - 159 ChooseRule: "choose" AttributedVariable "in" Term "do" . Rule - - "seq" shift, and go to state 204 - "par" shift, and go to state 205 - "skip" shift, and go to state 206 - "let" shift, and go to state 207 - "in" shift, and go to state 21 - "forall" shift, and go to state 208 - "choose" shift, and go to state 209 - "iterate" shift, and go to state 210 - "call" shift, and go to state 211 - "if" shift, and go to state 212 - "case" shift, and go to state 213 - "(" shift, and go to state 214 - "{" shift, and go to state 215 - "." shift, and go to state 23 - "{|" shift, and go to state 216 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - DirectCallExpression go to state 217 - IndirectCallExpression go to state 218 - Rule go to state 345 - SkipRule go to state 220 - ConditionalRule go to state 221 - CaseRule go to state 222 - LetRule go to state 223 - ForallRule go to state 224 - ChooseRule go to state 225 - IterateRule go to state 226 - BlockRule go to state 227 - SequenceRule go to state 228 - UpdateRule go to state 229 - CallRule go to state 230 + 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 + + $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 State 333 - 149 ConditionalRule: "if" Term "then" Rule "else" . Rule - - "seq" shift, and go to state 204 - "par" shift, and go to state 205 - "skip" shift, and go to state 206 - "let" shift, and go to state 207 - "in" shift, and go to state 21 - "forall" shift, and go to state 208 - "choose" shift, and go to state 209 - "iterate" shift, and go to state 210 - "call" shift, and go to state 211 - "if" shift, and go to state 212 - "case" shift, and go to state 213 - "(" shift, and go to state 214 - "{" shift, and go to state 215 - "." shift, and go to state 23 - "{|" shift, and go to state 216 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - DirectCallExpression go to state 217 - IndirectCallExpression go to state 218 - Rule go to state 346 - SkipRule go to state 220 - ConditionalRule go to state 221 - CaseRule go to state 222 - LetRule go to state 223 - ForallRule go to state 224 - ChooseRule go to state 225 - IterateRule go to state 226 - BlockRule go to state 227 - SequenceRule go to state 228 - UpdateRule go to state 229 - CallRule go to state 230 + 41 FeatureDeclarationsAndDefinitions: FeatureDeclarationsAndDefinitions "," FeatureDeclarationOrDefinition . + $default reduce using rule 41 (FeatureDeclarationsAndDefinitions) -State 334 - 151 CaseRule: "case" Term "of" "{" error . "}" +State 334 - "}" shift, and go to state 347 + 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) State 335 - 152 CaseLabel: "default" . ":" Rule - - ":" shift, and go to state 348 + 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) State 336 - 153 CaseLabel: "_" . ":" Rule - - ":" shift, and go to state 349 + 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) State 337 - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - 154 CaseLabel: Term . ":" Rule - - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "implies" shift, and go to state 123 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - ":" shift, and go to state 350 - "<" 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 134 - "!=" shift, and go to state 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 + 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) State 338 - 155 CaseLabels: CaseLabel . CaseLabels - 156 | CaseLabel . - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "default" shift, and go to state 335 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 92 - "[" shift, and go to state 51 - "_" shift, and go to state 336 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - $default reduce using rule 156 (CaseLabels) - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 337 - Expression go to state 73 - Range go to state 74 - List go to state 75 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 - CaseLabel go to state 338 - CaseLabels go to state 351 + 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) State 339 - 150 CaseRule: "case" Term "of" "{" CaseLabels . "}" - - "}" shift, and go to state 352 + 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 State 340 - 18 MaybeDefined: "defined" "{" Term . "}" - 96 Expression: Term . "+" Term - 97 | Term . "-" Term - 98 | Term . "*" Term - 99 | Term . "/" Term - 100 | Term . "%" Term - 101 | Term . "^" Term - 102 | Term . "!=" Term - 103 | Term . "=" Term - 104 | Term . "<" Term - 105 | Term . ">" Term - 106 | Term . "<=" Term - 107 | Term . ">=" Term - 108 | Term . "or" Term - 109 | Term . "xor" Term - 110 | Term . "and" Term - 111 | Term . "=>" Term - 112 | Term . "implies" Term - - "and" shift, and go to state 120 - "or" shift, and go to state 121 - "xor" shift, and go to state 122 - "implies" shift, and go to state 123 - "+" shift, and go to state 124 - "-" shift, and go to state 125 - "=" shift, and go to state 126 - "}" shift, and go to state 353 - "<" 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 134 - "!=" shift, and go to state 135 - "<=" shift, and go to state 136 - ">=" shift, and go to state 137 + 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 State 341 - 16 MaybeInitially: "initially" "{" . MaybeInitializers "}" - - "let" shift, and go to state 39 - "in" shift, and go to state 21 - "forall" shift, and go to state 40 - "choose" shift, and go to state 41 - "if" shift, and go to state 42 - "exists" shift, and go to state 43 - "undef" shift, and go to state 44 - "false" shift, and go to state 45 - "true" shift, and go to state 46 - "not" shift, and go to state 47 - "+" shift, and go to state 48 - "-" shift, and go to state 49 - "(" shift, and go to state 50 - "[" shift, and go to state 51 - "@" shift, and go to state 52 - "." shift, and go to state 23 - "binary" shift, and go to state 53 - "hexadecimal" shift, and go to state 54 - "integer" shift, and go to state 55 - "rational" shift, and go to state 56 - "floating" shift, and go to state 57 - "string" shift, and go to state 58 - "identifier" shift, and go to state 24 - - $default reduce using rule 32 (MaybeInitializers) - - Initializer go to state 59 - Initializers go to state 60 - MaybeInitializers go to state 354 - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - Atom go to state 63 - Undefined go to state 64 - Boolean go to state 65 - String go to state 66 - BitNumber go to state 67 - IntegerNumber go to state 68 - FloatingNumber go to state 69 - RationalNumber go to state 70 - Reference go to state 71 - Term go to state 72 - Expression go to state 73 - Range go to state 74 - List go to state 75 - TwoOrMoreArguments go to state 76 - DirectCallExpression go to state 77 - IndirectCallExpression go to state 78 - LetExpression go to state 79 - ConditionalExpression go to state 80 - ChooseExpression go to state 81 - UniversalQuantifierExpression go to state 82 - ExistentialQuantifierExpression go to state 83 + 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 State 342 - 59 RelationType: IdentifierPath "<" MaybeFunctionParameters "->" Type ">" . + 157 ConditionalRule: "if" Term "then" Rule . + 158 | "if" Term "then" Rule . "else" Rule - $default reduce using rule 59 (RelationType) + "else" shift, and go to state 354 + $default reduce using rule 157 (ConditionalRule) -State 343 - 157 LetRule: "let" AttributedVariable "=" Term "in" Rule . +State 343 - $default reduce using rule 157 (LetRule) + 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 State 344 - 158 ForallRule: "forall" AttributedVariable "in" Term "do" Rule . - - $default reduce using rule 158 (ForallRule) + 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 State 345 - 159 ChooseRule: "choose" AttributedVariable "in" Term "do" Rule . + 17 MaybeInitially: "initially" . "{" MaybeInitializers "}" - $default reduce using rule 159 (ChooseRule) + "{" shift, and go to state 362 State 346 - 149 ConditionalRule: "if" Term "then" Rule "else" Rule . + 13 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially . - $default reduce using rule 149 (ConditionalRule) + $default reduce using rule 13 (FunctionDefinition) State 347 - 151 CaseRule: "case" Term "of" "{" error "}" . + 68 RelationType: IdentifierPath "<" MaybeFunctionParameters "->" Type . ">" - $default reduce using rule 151 (CaseRule) + ">" shift, and go to state 363 State 348 - 152 CaseLabel: "default" ":" . Rule - - "seq" shift, and go to state 204 - "par" shift, and go to state 205 - "skip" shift, and go to state 206 - "let" shift, and go to state 207 - "in" shift, and go to state 21 - "forall" shift, and go to state 208 - "choose" shift, and go to state 209 - "iterate" shift, and go to state 210 - "call" shift, and go to state 211 - "if" shift, and go to state 212 - "case" shift, and go to state 213 - "(" shift, and go to state 214 - "{" shift, and go to state 215 - "." shift, and go to state 23 - "{|" shift, and go to state 216 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - DirectCallExpression go to state 217 - IndirectCallExpression go to state 218 - Rule go to state 355 - SkipRule go to state 220 - ConditionalRule go to state 221 - CaseRule go to state 222 - LetRule go to state 223 - ForallRule go to state 224 - ChooseRule go to state 225 - IterateRule go to state 226 - BlockRule go to state 227 - SequenceRule go to state 228 - UpdateRule go to state 229 - CallRule go to state 230 + 70 Types: Types "," Type . + + $default reduce using rule 70 (Types) State 349 - 153 CaseLabel: "_" ":" . Rule - - "seq" shift, and go to state 204 - "par" shift, and go to state 205 - "skip" shift, and go to state 206 - "let" shift, and go to state 207 - "in" shift, and go to state 21 - "forall" shift, and go to state 208 - "choose" shift, and go to state 209 - "iterate" shift, and go to state 210 - "call" shift, and go to state 211 - "if" shift, and go to state 212 - "case" shift, and go to state 213 - "(" shift, and go to state 214 - "{" shift, and go to state 215 - "." shift, and go to state 23 - "{|" shift, and go to state 216 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - DirectCallExpression go to state 217 - IndirectCallExpression go to state 218 - Rule go to state 356 - SkipRule go to state 220 - ConditionalRule go to state 221 - CaseRule go to state 222 - LetRule go to state 223 - ForallRule go to state 224 - ChooseRule go to state 225 - IterateRule go to state 226 - BlockRule go to state 227 - SequenceRule go to state 228 - UpdateRule go to state 229 - CallRule go to state 230 + 43 DeclarationDefinition: "derived" Identifier ":" MaybeFunctionParameters . "->" Type + + "->" shift, and go to state 364 State 350 - 154 CaseLabel: Term ":" . Rule - - "seq" shift, and go to state 204 - "par" shift, and go to state 205 - "skip" shift, and go to state 206 - "let" shift, and go to state 207 - "in" shift, and go to state 21 - "forall" shift, and go to state 208 - "choose" shift, and go to state 209 - "iterate" shift, and go to state 210 - "call" shift, and go to state 211 - "if" shift, and go to state 212 - "case" shift, and go to state 213 - "(" shift, and go to state 214 - "{" shift, and go to state 215 - "." shift, and go to state 23 - "{|" shift, and go to state 216 - "identifier" shift, and go to state 24 - - Identifier go to state 25 - DotSeparatedIdentifiers go to state 26 - IdentifierPath go to state 62 - DirectCallExpression go to state 217 - IndirectCallExpression go to state 218 - Rule go to state 357 - SkipRule go to state 220 - ConditionalRule go to state 221 - CaseRule go to state 222 - LetRule go to state 223 - ForallRule go to state 224 - ChooseRule go to state 225 - IterateRule go to state 226 - BlockRule go to state 227 - SequenceRule go to state 228 - UpdateRule go to state 229 - CallRule go to state 230 + 44 DeclarationDefinition: "rule" Identifier ":" MaybeFunctionParameters . "->" Type + "->" shift, and go to state 365 -State 351 - 155 CaseLabels: CaseLabel CaseLabels . +State 351 - $default reduce using rule 155 (CaseLabels) + 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 State 352 - 150 CaseRule: "case" Term "of" "{" CaseLabels "}" . - - $default reduce using rule 150 (CaseRule) + 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 State 353 - 18 MaybeDefined: "defined" "{" Term "}" . - - $default reduce using rule 18 (MaybeDefined) + 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 State 354 - 16 MaybeInitially: "initially" "{" MaybeInitializers . "}" - - "}" shift, and go to state 358 + 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 State 355 - 152 CaseLabel: "default" ":" Rule . + 160 CaseRule: "case" Term "of" "{" error . "}" - $default reduce using rule 152 (CaseLabel) + "}" shift, and go to state 370 State 356 - 153 CaseLabel: "_" ":" Rule . + 161 CaseLabel: "default" . ":" Rule - $default reduce using rule 153 (CaseLabel) + ":" shift, and go to state 371 State 357 - 154 CaseLabel: Term ":" Rule . + 162 CaseLabel: "_" . ":" Rule - $default reduce using rule 154 (CaseLabel) + ":" shift, and go to state 372 State 358 - 16 MaybeInitially: "initially" "{" MaybeInitializers "}" . + 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 + + +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 + + +State 360 + + 159 CaseRule: "case" Term "of" "{" CaseLabels . "}" + + "}" shift, and go to state 375 + + +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 + + +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 + + +State 363 + + 68 RelationType: IdentifierPath "<" MaybeFunctionParameters "->" Type ">" . + + $default reduce using rule 68 (RelationType) + + +State 364 + + 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 + + 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 + + +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 + + +State 366 + + 166 LetRule: "let" AttributedVariable "=" Term "in" Rule . + + $default reduce using rule 166 (LetRule) + + +State 367 + + 167 ForallRule: "forall" AttributedVariable "in" Term "do" Rule . + + $default reduce using rule 167 (ForallRule) + + +State 368 + + 168 ChooseRule: "choose" AttributedVariable "in" Term "do" Rule . + + $default reduce using rule 168 (ChooseRule) + + +State 369 + + 158 ConditionalRule: "if" Term "then" Rule "else" Rule . + + $default reduce using rule 158 (ConditionalRule) + + +State 370 + + 160 CaseRule: "case" Term "of" "{" error "}" . + + $default reduce using rule 160 (CaseRule) + + +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 + + +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 + + +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 + + +State 374 + + 164 CaseLabels: CaseLabel CaseLabels . + + $default reduce using rule 164 (CaseLabels) + + +State 375 + + 159 CaseRule: "case" Term "of" "{" CaseLabels "}" . + + $default reduce using rule 159 (CaseRule) + + +State 376 + + 19 MaybeDefined: "defined" "{" Term "}" . + + $default reduce using rule 19 (MaybeDefined) + - $default reduce using rule 16 (MaybeInitially) +State 377 + + 17 MaybeInitially: "initially" "{" MaybeInitializers . "}" + + "}" shift, and go to state 383 + + +State 378 + + 43 DeclarationDefinition: "derived" Identifier ":" MaybeFunctionParameters "->" Type . + + $default reduce using rule 43 (DeclarationDefinition) + + +State 379 + + 44 DeclarationDefinition: "rule" Identifier ":" MaybeFunctionParameters "->" Type . + + $default reduce using rule 44 (DeclarationDefinition) + + +State 380 + + 161 CaseLabel: "default" ":" Rule . + + $default reduce using rule 161 (CaseLabel) + + +State 381 + + 162 CaseLabel: "_" ":" Rule . + + $default reduce using rule 162 (CaseLabel) + + +State 382 + + 163 CaseLabel: Term ":" Rule . + + $default reduce using rule 163 (CaseLabel) + + +State 383 + + 17 MaybeInitially: "initially" "{" MaybeInitializers "}" . + + $default reduce using rule 17 (MaybeInitially) diff --git a/src/various/GrammarParser.tab.h b/src/various/GrammarParser.tab.h index afdc9eb5b..c58b79702 100644 --- a/src/various/GrammarParser.tab.h +++ b/src/various/GrammarParser.tab.h @@ -342,133 +342,141 @@ namespace libcasm_fe { // ConditionalRule char dummy14[sizeof(ConditionalRule::Ptr)]; + // DeclarationDefinition + char dummy15[sizeof(DeclarationDefinition::Ptr)]; + // Definition // AttributedDefinition - char dummy15[sizeof(Definition::Ptr)]; + // FeatureDeclarationOrDefinition + char dummy16[sizeof(Definition::Ptr)]; // Definitions - char dummy16[sizeof(Definitions::Ptr)]; + // FeatureDeclarationsAndDefinitions + char dummy17[sizeof(Definitions::Ptr)]; // DerivedDefinition - char dummy17[sizeof(DerivedDefinition::Ptr)]; + char dummy18[sizeof(DerivedDefinition::Ptr)]; // DirectCallExpression - char dummy18[sizeof(DirectCallExpression::Ptr)]; + char dummy19[sizeof(DirectCallExpression::Ptr)]; // EnumerationDefinition - char dummy19[sizeof(EnumerationDefinition::Ptr)]; + char dummy20[sizeof(EnumerationDefinition::Ptr)]; // ExistentialQuantifierExpression - char dummy20[sizeof(ExistentialQuantifierExpression::Ptr)]; + char dummy21[sizeof(ExistentialQuantifierExpression::Ptr)]; // MaybeDefined // Atom // Term // Expression - char dummy21[sizeof(Expression::Ptr)]; + char dummy22[sizeof(Expression::Ptr)]; // ExpressionAttribute - char dummy22[sizeof(ExpressionAttribute::Ptr)]; + char dummy23[sizeof(ExpressionAttribute::Ptr)]; // Terms // Arguments // TwoOrMoreArguments - char dummy23[sizeof(Expressions::Ptr)]; + char dummy24[sizeof(Expressions::Ptr)]; + + // FeatureDefinition + char dummy25[sizeof(FeatureDefinition::Ptr)]; // FixedSizedType - char dummy24[sizeof(FixedSizedType::Ptr)]; + char dummy26[sizeof(FixedSizedType::Ptr)]; // ForallRule - char dummy25[sizeof(ForallRule::Ptr)]; + char dummy27[sizeof(ForallRule::Ptr)]; // FunctionDefinition // ProgramFunctionDefinition - char dummy26[sizeof(FunctionDefinition::Ptr)]; + char dummy28[sizeof(FunctionDefinition::Ptr)]; // FunctionDefinitions - char dummy27[sizeof(FunctionDefinitions::Ptr)]; + char dummy29[sizeof(FunctionDefinitions::Ptr)]; // Identifier - char dummy28[sizeof(Identifier::Ptr)]; + char dummy30[sizeof(Identifier::Ptr)]; // IdentifierPath - char dummy29[sizeof(IdentifierPath::Ptr)]; + char dummy31[sizeof(IdentifierPath::Ptr)]; // Identifiers // DotSeparatedIdentifiers - char dummy30[sizeof(Identifiers::Ptr)]; + char dummy32[sizeof(Identifiers::Ptr)]; // IndirectCallExpression - char dummy31[sizeof(IndirectCallExpression::Ptr)]; + char dummy33[sizeof(IndirectCallExpression::Ptr)]; // IterateRule - char dummy32[sizeof(IterateRule::Ptr)]; + char dummy34[sizeof(IterateRule::Ptr)]; // LetExpression - char dummy33[sizeof(LetExpression::Ptr)]; + char dummy35[sizeof(LetExpression::Ptr)]; // LetRule - char dummy34[sizeof(LetRule::Ptr)]; + char dummy36[sizeof(LetRule::Ptr)]; // List - char dummy35[sizeof(ListExpression::Ptr)]; + char dummy37[sizeof(ListExpression::Ptr)]; // MaybeInitially // Initializers // MaybeInitializers - char dummy36[sizeof(NodeList< UpdateRule >::Ptr)]; + char dummy38[sizeof(NodeList< UpdateRule >::Ptr)]; // Parameters // MaybeParameters - char dummy37[sizeof(NodeList< VariableDefinition >::Ptr)]; + char dummy39[sizeof(NodeList< VariableDefinition >::Ptr)]; // Range - char dummy38[sizeof(RangeExpression::Ptr)]; + char dummy40[sizeof(RangeExpression::Ptr)]; // Reference - char dummy39[sizeof(ReferenceAtom::Ptr)]; + char dummy41[sizeof(ReferenceAtom::Ptr)]; // RelationType - char dummy40[sizeof(RelationType::Ptr)]; + char dummy42[sizeof(RelationType::Ptr)]; // Rule - char dummy41[sizeof(Rule::Ptr)]; + char dummy43[sizeof(Rule::Ptr)]; // RuleDefinition - char dummy42[sizeof(RuleDefinition::Ptr)]; + char dummy44[sizeof(RuleDefinition::Ptr)]; // Rules - char dummy43[sizeof(Rules::Ptr)]; + char dummy45[sizeof(Rules::Ptr)]; // SequenceRule - char dummy44[sizeof(SequenceRule::Ptr)]; + char dummy46[sizeof(SequenceRule::Ptr)]; // SkipRule - char dummy45[sizeof(SkipRule::Ptr)]; + char dummy47[sizeof(SkipRule::Ptr)]; // Specification - char dummy46[sizeof(Specification::Ptr)]; + char dummy48[sizeof(Specification::Ptr)]; // StructureDefinition - char dummy47[sizeof(StructureDefinition::Ptr)]; + char dummy49[sizeof(StructureDefinition::Ptr)]; // Type - char dummy48[sizeof(Type::Ptr)]; + char dummy50[sizeof(Type::Ptr)]; // FunctionParameters // MaybeFunctionParameters // Types - char dummy49[sizeof(Types::Ptr)]; + char dummy51[sizeof(Types::Ptr)]; // Undefined - char dummy50[sizeof(UndefAtom::Ptr)]; + char dummy52[sizeof(UndefAtom::Ptr)]; // UniversalQuantifierExpression - char dummy51[sizeof(UniversalQuantifierExpression::Ptr)]; + char dummy53[sizeof(UniversalQuantifierExpression::Ptr)]; // Initializer // UpdateRule - char dummy52[sizeof(UpdateRule::Ptr)]; + char dummy54[sizeof(UpdateRule::Ptr)]; // Boolean // String @@ -476,11 +484,11 @@ namespace libcasm_fe { // IntegerNumber // FloatingNumber // RationalNumber - char dummy53[sizeof(ValueAtom::Ptr)]; + char dummy55[sizeof(ValueAtom::Ptr)]; // Variable // AttributedVariable - char dummy54[sizeof(VariableDefinition::Ptr)]; + char dummy56[sizeof(VariableDefinition::Ptr)]; // "binary" // "hexadecimal" @@ -489,7 +497,7 @@ namespace libcasm_fe { // "floating" // "string" // "identifier" - char dummy55[sizeof(std::string)]; + char dummy57[sizeof(std::string)]; }; /// Symbol semantic values. @@ -522,76 +530,77 @@ namespace libcasm_fe { INITIALLY = 264, DEFINED = 265, STRUCTURE = 266, - SEQ = 267, - ENDSEQ = 268, - PAR = 269, - ENDPAR = 270, - SKIP = 271, - LET = 272, - IN = 273, - FORALL = 274, - CHOOSE = 275, - ITERATE = 276, - DO = 277, - CALL = 278, - IF = 279, - THEN = 280, - ELSE = 281, - CASE = 282, - OF = 283, - DEFAULT = 284, - HOLDS = 285, - EXISTS = 286, - WITH = 287, - UNDEF = 288, - FALSE = 289, - TRUE = 290, - AND = 291, - OR = 292, - XOR = 293, - IMPLIES = 294, - NOT = 295, - PLUS = 296, - MINUS = 297, - EQUAL = 298, - LPAREN = 299, - RPAREN = 300, - LSQPAREN = 301, - RSQPAREN = 302, - LCURPAREN = 303, - RCURPAREN = 304, - COLON = 305, - UNDERLINE = 306, - AT = 307, - COMMA = 308, - LESSER = 309, - GREATER = 310, - ASTERIX = 311, - SLASH = 312, - PERCENT = 313, - CARET = 314, - MARK = 315, - DOTDOT = 316, - DOT = 317, - MAPS = 318, - ARROW = 319, - UPDATE = 320, - NEQUAL = 321, - LESSEQ = 322, - GREATEREQ = 323, - SEQ_BRACKET = 324, - ENDSEQ_BRACKET = 325, - BINARY = 326, - HEXADECIMAL = 327, - INTEGER = 328, - RATIONAL = 329, - FLOATING = 330, - STRING = 331, - IDENTIFIER = 332, - ABSOLUTE_PATH = 333, - UPLUS = 334, - UMINUS = 335, - CALL_WITHOUT_ARGS = 336 + 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 }; }; @@ -657,6 +666,8 @@ namespace libcasm_fe { basic_symbol (typename Base::kind_type t, const ConditionalRule::Ptr v, const location_type& l); + basic_symbol (typename Base::kind_type t, const DeclarationDefinition::Ptr v, const location_type& l); + basic_symbol (typename Base::kind_type t, const Definition::Ptr v, const location_type& l); basic_symbol (typename Base::kind_type t, const Definitions::Ptr v, const location_type& l); @@ -675,6 +686,8 @@ namespace libcasm_fe { basic_symbol (typename Base::kind_type t, const Expressions::Ptr v, const location_type& l); + basic_symbol (typename Base::kind_type t, const FeatureDefinition::Ptr v, const location_type& l); + basic_symbol (typename Base::kind_type t, const FixedSizedType::Ptr v, const location_type& l); basic_symbol (typename Base::kind_type t, const ForallRule::Ptr v, const location_type& l); @@ -846,6 +859,10 @@ namespace libcasm_fe { symbol_type make_STRUCTURE (const location_type& l); + static inline + symbol_type + make_FEATURE (const location_type& l); + static inline symbol_type make_SEQ (const location_type& l); @@ -1331,12 +1348,12 @@ namespace libcasm_fe { enum { yyeof_ = 0, - yylast_ = 1870, ///< Last index in yytable_. - yynnts_ = 75, ///< Number of nonterminal symbols. - yyfinal_ = 20, ///< Termination state number. + yylast_ = 1904, ///< Last index in yytable_. + yynnts_ = 79, ///< Number of nonterminal symbols. + yyfinal_ = 22, ///< Termination state number. yyterror_ = 1, yyerrcode_ = 256, - yyntokens_ = 82 ///< Number of tokens. + yyntokens_ = 83 ///< Number of tokens. }; @@ -1389,9 +1406,9 @@ 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 + 75, 76, 77, 78, 79, 80, 81, 82 }; - const unsigned int user_token_number_max_ = 336; + const unsigned int user_token_number_max_ = 337; const token_number_type undef_token_ = 2; if (static_cast(t) <= yyeof_) @@ -1424,249 +1441,259 @@ namespace libcasm_fe { { switch (other.type_get ()) { - case 153: // Attribute + case 158: // Attribute value.copy< Attribute::Ptr > (other.value); break; - case 154: // Attributes + case 159: // Attributes value.copy< Attributes::Ptr > (other.value); break; - case 155: // BasicAttribute + case 160: // BasicAttribute value.copy< BasicAttribute::Ptr > (other.value); break; - case 109: // BasicType + case 114: // BasicType value.copy< BasicType::Ptr > (other.value); break; - case 149: // BlockRule + case 154: // BlockRule value.copy< BlockRule::Ptr > (other.value); break; - case 152: // CallRule + case 157: // CallRule value.copy< CallRule::Ptr > (other.value); break; - case 143: // CaseLabel + case 148: // CaseLabel value.copy< Case::Ptr > (other.value); break; - case 142: // CaseRule + case 147: // CaseRule value.copy< CaseRule::Ptr > (other.value); break; - case 144: // CaseLabels + case 149: // CaseLabels value.copy< Cases::Ptr > (other.value); break; - case 134: // ChooseExpression + case 139: // ChooseExpression value.copy< ChooseExpression::Ptr > (other.value); break; - case 147: // ChooseRule + case 152: // ChooseRule value.copy< ChooseRule::Ptr > (other.value); break; - case 110: // ComposedType + case 115: // ComposedType value.copy< ComposedType::Ptr > (other.value); break; - case 133: // ConditionalExpression + case 138: // ConditionalExpression value.copy< ConditionalExpression::Ptr > (other.value); break; - case 141: // ConditionalRule + case 146: // ConditionalRule value.copy< ConditionalRule::Ptr > (other.value); break; - case 84: // Definition - case 85: // AttributedDefinition + case 104: // DeclarationDefinition + value.copy< DeclarationDefinition::Ptr > (other.value); + break; + + case 85: // Definition + case 86: // AttributedDefinition + case 102: // FeatureDeclarationOrDefinition value.copy< Definition::Ptr > (other.value); break; - case 86: // Definitions + case 87: // Definitions + case 103: // FeatureDeclarationsAndDefinitions value.copy< Definitions::Ptr > (other.value); break; - case 97: // DerivedDefinition + case 98: // DerivedDefinition value.copy< DerivedDefinition::Ptr > (other.value); break; - case 130: // DirectCallExpression + case 135: // DirectCallExpression value.copy< DirectCallExpression::Ptr > (other.value); break; - case 98: // EnumerationDefinition + case 99: // EnumerationDefinition value.copy< EnumerationDefinition::Ptr > (other.value); break; - case 136: // ExistentialQuantifierExpression + case 141: // ExistentialQuantifierExpression value.copy< ExistentialQuantifierExpression::Ptr > (other.value); break; - case 90: // MaybeDefined - case 114: // Atom - case 123: // Term - case 124: // Expression + case 91: // MaybeDefined + case 119: // Atom + case 128: // Term + case 129: // Expression value.copy< Expression::Ptr > (other.value); break; - case 156: // ExpressionAttribute + case 161: // ExpressionAttribute value.copy< ExpressionAttribute::Ptr > (other.value); break; - case 127: // Terms - case 128: // Arguments - case 129: // TwoOrMoreArguments + case 132: // Terms + case 133: // Arguments + case 134: // TwoOrMoreArguments value.copy< Expressions::Ptr > (other.value); break; - case 112: // FixedSizedType + case 101: // FeatureDefinition + value.copy< FeatureDefinition::Ptr > (other.value); + break; + + case 117: // FixedSizedType value.copy< FixedSizedType::Ptr > (other.value); break; - case 146: // ForallRule + case 151: // ForallRule value.copy< ForallRule::Ptr > (other.value); break; - case 87: // FunctionDefinition - case 93: // ProgramFunctionDefinition + case 88: // FunctionDefinition + case 94: // ProgramFunctionDefinition value.copy< FunctionDefinition::Ptr > (other.value); break; - case 88: // FunctionDefinitions + case 89: // FunctionDefinitions value.copy< FunctionDefinitions::Ptr > (other.value); break; - case 100: // Identifier + case 105: // Identifier value.copy< Identifier::Ptr > (other.value); break; - case 103: // IdentifierPath + case 108: // IdentifierPath value.copy< IdentifierPath::Ptr > (other.value); break; - case 101: // Identifiers - case 102: // DotSeparatedIdentifiers + case 106: // Identifiers + case 107: // DotSeparatedIdentifiers value.copy< Identifiers::Ptr > (other.value); break; - case 131: // IndirectCallExpression + case 136: // IndirectCallExpression value.copy< IndirectCallExpression::Ptr > (other.value); break; - case 148: // IterateRule + case 153: // IterateRule value.copy< IterateRule::Ptr > (other.value); break; - case 132: // LetExpression + case 137: // LetExpression value.copy< LetExpression::Ptr > (other.value); break; - case 145: // LetRule + case 150: // LetRule value.copy< LetRule::Ptr > (other.value); break; - case 126: // List + case 131: // List value.copy< ListExpression::Ptr > (other.value); break; - case 89: // MaybeInitially - case 95: // Initializers - case 96: // MaybeInitializers + case 90: // MaybeInitially + case 96: // Initializers + case 97: // MaybeInitializers value.copy< NodeList< UpdateRule >::Ptr > (other.value); break; - case 106: // Parameters - case 107: // MaybeParameters + case 111: // Parameters + case 112: // MaybeParameters value.copy< NodeList< VariableDefinition >::Ptr > (other.value); break; - case 125: // Range + case 130: // Range value.copy< RangeExpression::Ptr > (other.value); break; - case 122: // Reference + case 127: // Reference value.copy< ReferenceAtom::Ptr > (other.value); break; - case 111: // RelationType + case 116: // RelationType value.copy< RelationType::Ptr > (other.value); break; - case 138: // Rule + case 143: // Rule value.copy< Rule::Ptr > (other.value); break; - case 137: // RuleDefinition + case 142: // RuleDefinition value.copy< RuleDefinition::Ptr > (other.value); break; - case 139: // Rules + case 144: // Rules value.copy< Rules::Ptr > (other.value); break; - case 150: // SequenceRule + case 155: // SequenceRule value.copy< SequenceRule::Ptr > (other.value); break; - case 140: // SkipRule + case 145: // SkipRule value.copy< SkipRule::Ptr > (other.value); break; - case 83: // Specification + case 84: // Specification value.copy< Specification::Ptr > (other.value); break; - case 99: // StructureDefinition + case 100: // StructureDefinition value.copy< StructureDefinition::Ptr > (other.value); break; - case 108: // Type + case 113: // Type value.copy< Type::Ptr > (other.value); break; - case 91: // FunctionParameters - case 92: // MaybeFunctionParameters - case 113: // Types + case 92: // FunctionParameters + case 93: // MaybeFunctionParameters + case 118: // Types value.copy< Types::Ptr > (other.value); break; - case 115: // Undefined + case 120: // Undefined value.copy< UndefAtom::Ptr > (other.value); break; - case 135: // UniversalQuantifierExpression + case 140: // UniversalQuantifierExpression value.copy< UniversalQuantifierExpression::Ptr > (other.value); break; - case 94: // Initializer - case 151: // UpdateRule + case 95: // Initializer + case 156: // UpdateRule value.copy< UpdateRule::Ptr > (other.value); break; - case 116: // Boolean - case 117: // String - case 118: // BitNumber - case 119: // IntegerNumber - case 120: // FloatingNumber - case 121: // RationalNumber + case 121: // Boolean + case 122: // String + case 123: // BitNumber + case 124: // IntegerNumber + case 125: // FloatingNumber + case 126: // RationalNumber value.copy< ValueAtom::Ptr > (other.value); break; - case 104: // Variable - case 105: // AttributedVariable + case 109: // Variable + case 110: // AttributedVariable value.copy< VariableDefinition::Ptr > (other.value); break; - case 71: // "binary" - case 72: // "hexadecimal" - case 73: // "integer" - case 74: // "rational" - case 75: // "floating" - case 76: // "string" - case 77: // "identifier" + case 72: // "binary" + case 73: // "hexadecimal" + case 74: // "integer" + case 75: // "rational" + case 76: // "floating" + case 77: // "string" + case 78: // "identifier" value.copy< std::string > (other.value); break; @@ -1687,249 +1714,259 @@ namespace libcasm_fe { (void) v; switch (this->type_get ()) { - case 153: // Attribute + case 158: // Attribute value.copy< Attribute::Ptr > (v); break; - case 154: // Attributes + case 159: // Attributes value.copy< Attributes::Ptr > (v); break; - case 155: // BasicAttribute + case 160: // BasicAttribute value.copy< BasicAttribute::Ptr > (v); break; - case 109: // BasicType + case 114: // BasicType value.copy< BasicType::Ptr > (v); break; - case 149: // BlockRule + case 154: // BlockRule value.copy< BlockRule::Ptr > (v); break; - case 152: // CallRule + case 157: // CallRule value.copy< CallRule::Ptr > (v); break; - case 143: // CaseLabel + case 148: // CaseLabel value.copy< Case::Ptr > (v); break; - case 142: // CaseRule + case 147: // CaseRule value.copy< CaseRule::Ptr > (v); break; - case 144: // CaseLabels + case 149: // CaseLabels value.copy< Cases::Ptr > (v); break; - case 134: // ChooseExpression + case 139: // ChooseExpression value.copy< ChooseExpression::Ptr > (v); break; - case 147: // ChooseRule + case 152: // ChooseRule value.copy< ChooseRule::Ptr > (v); break; - case 110: // ComposedType + case 115: // ComposedType value.copy< ComposedType::Ptr > (v); break; - case 133: // ConditionalExpression + case 138: // ConditionalExpression value.copy< ConditionalExpression::Ptr > (v); break; - case 141: // ConditionalRule + case 146: // ConditionalRule value.copy< ConditionalRule::Ptr > (v); break; - case 84: // Definition - case 85: // AttributedDefinition + case 104: // DeclarationDefinition + value.copy< DeclarationDefinition::Ptr > (v); + break; + + case 85: // Definition + case 86: // AttributedDefinition + case 102: // FeatureDeclarationOrDefinition value.copy< Definition::Ptr > (v); break; - case 86: // Definitions + case 87: // Definitions + case 103: // FeatureDeclarationsAndDefinitions value.copy< Definitions::Ptr > (v); break; - case 97: // DerivedDefinition + case 98: // DerivedDefinition value.copy< DerivedDefinition::Ptr > (v); break; - case 130: // DirectCallExpression + case 135: // DirectCallExpression value.copy< DirectCallExpression::Ptr > (v); break; - case 98: // EnumerationDefinition + case 99: // EnumerationDefinition value.copy< EnumerationDefinition::Ptr > (v); break; - case 136: // ExistentialQuantifierExpression + case 141: // ExistentialQuantifierExpression value.copy< ExistentialQuantifierExpression::Ptr > (v); break; - case 90: // MaybeDefined - case 114: // Atom - case 123: // Term - case 124: // Expression + case 91: // MaybeDefined + case 119: // Atom + case 128: // Term + case 129: // Expression value.copy< Expression::Ptr > (v); break; - case 156: // ExpressionAttribute + case 161: // ExpressionAttribute value.copy< ExpressionAttribute::Ptr > (v); break; - case 127: // Terms - case 128: // Arguments - case 129: // TwoOrMoreArguments + case 132: // Terms + case 133: // Arguments + case 134: // TwoOrMoreArguments value.copy< Expressions::Ptr > (v); break; - case 112: // FixedSizedType + case 101: // FeatureDefinition + value.copy< FeatureDefinition::Ptr > (v); + break; + + case 117: // FixedSizedType value.copy< FixedSizedType::Ptr > (v); break; - case 146: // ForallRule + case 151: // ForallRule value.copy< ForallRule::Ptr > (v); break; - case 87: // FunctionDefinition - case 93: // ProgramFunctionDefinition + case 88: // FunctionDefinition + case 94: // ProgramFunctionDefinition value.copy< FunctionDefinition::Ptr > (v); break; - case 88: // FunctionDefinitions + case 89: // FunctionDefinitions value.copy< FunctionDefinitions::Ptr > (v); break; - case 100: // Identifier + case 105: // Identifier value.copy< Identifier::Ptr > (v); break; - case 103: // IdentifierPath + case 108: // IdentifierPath value.copy< IdentifierPath::Ptr > (v); break; - case 101: // Identifiers - case 102: // DotSeparatedIdentifiers + case 106: // Identifiers + case 107: // DotSeparatedIdentifiers value.copy< Identifiers::Ptr > (v); break; - case 131: // IndirectCallExpression + case 136: // IndirectCallExpression value.copy< IndirectCallExpression::Ptr > (v); break; - case 148: // IterateRule + case 153: // IterateRule value.copy< IterateRule::Ptr > (v); break; - case 132: // LetExpression + case 137: // LetExpression value.copy< LetExpression::Ptr > (v); break; - case 145: // LetRule + case 150: // LetRule value.copy< LetRule::Ptr > (v); break; - case 126: // List + case 131: // List value.copy< ListExpression::Ptr > (v); break; - case 89: // MaybeInitially - case 95: // Initializers - case 96: // MaybeInitializers + case 90: // MaybeInitially + case 96: // Initializers + case 97: // MaybeInitializers value.copy< NodeList< UpdateRule >::Ptr > (v); break; - case 106: // Parameters - case 107: // MaybeParameters + case 111: // Parameters + case 112: // MaybeParameters value.copy< NodeList< VariableDefinition >::Ptr > (v); break; - case 125: // Range + case 130: // Range value.copy< RangeExpression::Ptr > (v); break; - case 122: // Reference + case 127: // Reference value.copy< ReferenceAtom::Ptr > (v); break; - case 111: // RelationType + case 116: // RelationType value.copy< RelationType::Ptr > (v); break; - case 138: // Rule + case 143: // Rule value.copy< Rule::Ptr > (v); break; - case 137: // RuleDefinition + case 142: // RuleDefinition value.copy< RuleDefinition::Ptr > (v); break; - case 139: // Rules + case 144: // Rules value.copy< Rules::Ptr > (v); break; - case 150: // SequenceRule + case 155: // SequenceRule value.copy< SequenceRule::Ptr > (v); break; - case 140: // SkipRule + case 145: // SkipRule value.copy< SkipRule::Ptr > (v); break; - case 83: // Specification + case 84: // Specification value.copy< Specification::Ptr > (v); break; - case 99: // StructureDefinition + case 100: // StructureDefinition value.copy< StructureDefinition::Ptr > (v); break; - case 108: // Type + case 113: // Type value.copy< Type::Ptr > (v); break; - case 91: // FunctionParameters - case 92: // MaybeFunctionParameters - case 113: // Types + case 92: // FunctionParameters + case 93: // MaybeFunctionParameters + case 118: // Types value.copy< Types::Ptr > (v); break; - case 115: // Undefined + case 120: // Undefined value.copy< UndefAtom::Ptr > (v); break; - case 135: // UniversalQuantifierExpression + case 140: // UniversalQuantifierExpression value.copy< UniversalQuantifierExpression::Ptr > (v); break; - case 94: // Initializer - case 151: // UpdateRule + case 95: // Initializer + case 156: // UpdateRule value.copy< UpdateRule::Ptr > (v); break; - case 116: // Boolean - case 117: // String - case 118: // BitNumber - case 119: // IntegerNumber - case 120: // FloatingNumber - case 121: // RationalNumber + case 121: // Boolean + case 122: // String + case 123: // BitNumber + case 124: // IntegerNumber + case 125: // FloatingNumber + case 126: // RationalNumber value.copy< ValueAtom::Ptr > (v); break; - case 104: // Variable - case 105: // AttributedVariable + case 109: // Variable + case 110: // AttributedVariable value.copy< VariableDefinition::Ptr > (v); break; - case 71: // "binary" - case 72: // "hexadecimal" - case 73: // "integer" - case 74: // "rational" - case 75: // "floating" - case 76: // "string" - case 77: // "identifier" + case 72: // "binary" + case 73: // "hexadecimal" + case 74: // "integer" + case 75: // "rational" + case 76: // "floating" + case 77: // "string" + case 78: // "identifier" value.copy< std::string > (v); break; @@ -2046,6 +2083,13 @@ namespace libcasm_fe { , location (l) {} + template + Parser::basic_symbol::basic_symbol (typename Base::kind_type t, const DeclarationDefinition::Ptr v, const location_type& l) + : Base (t) + , value (v) + , location (l) + {} + template Parser::basic_symbol::basic_symbol (typename Base::kind_type t, const Definition::Ptr v, const location_type& l) : Base (t) @@ -2109,6 +2153,13 @@ namespace libcasm_fe { , location (l) {} + template + Parser::basic_symbol::basic_symbol (typename Base::kind_type t, const FeatureDefinition::Ptr v, const location_type& l) + : Base (t) + , value (v) + , location (l) + {} + template Parser::basic_symbol::basic_symbol (typename Base::kind_type t, const FixedSizedType::Ptr v, const location_type& l) : Base (t) @@ -2359,249 +2410,259 @@ namespace libcasm_fe { // Type destructor. switch (yytype) { - case 153: // Attribute + case 158: // Attribute value.template destroy< Attribute::Ptr > (); break; - case 154: // Attributes + case 159: // Attributes value.template destroy< Attributes::Ptr > (); break; - case 155: // BasicAttribute + case 160: // BasicAttribute value.template destroy< BasicAttribute::Ptr > (); break; - case 109: // BasicType + case 114: // BasicType value.template destroy< BasicType::Ptr > (); break; - case 149: // BlockRule + case 154: // BlockRule value.template destroy< BlockRule::Ptr > (); break; - case 152: // CallRule + case 157: // CallRule value.template destroy< CallRule::Ptr > (); break; - case 143: // CaseLabel + case 148: // CaseLabel value.template destroy< Case::Ptr > (); break; - case 142: // CaseRule + case 147: // CaseRule value.template destroy< CaseRule::Ptr > (); break; - case 144: // CaseLabels + case 149: // CaseLabels value.template destroy< Cases::Ptr > (); break; - case 134: // ChooseExpression + case 139: // ChooseExpression value.template destroy< ChooseExpression::Ptr > (); break; - case 147: // ChooseRule + case 152: // ChooseRule value.template destroy< ChooseRule::Ptr > (); break; - case 110: // ComposedType + case 115: // ComposedType value.template destroy< ComposedType::Ptr > (); break; - case 133: // ConditionalExpression + case 138: // ConditionalExpression value.template destroy< ConditionalExpression::Ptr > (); break; - case 141: // ConditionalRule + case 146: // ConditionalRule value.template destroy< ConditionalRule::Ptr > (); break; - case 84: // Definition - case 85: // AttributedDefinition + case 104: // DeclarationDefinition + value.template destroy< DeclarationDefinition::Ptr > (); + break; + + case 85: // Definition + case 86: // AttributedDefinition + case 102: // FeatureDeclarationOrDefinition value.template destroy< Definition::Ptr > (); break; - case 86: // Definitions + case 87: // Definitions + case 103: // FeatureDeclarationsAndDefinitions value.template destroy< Definitions::Ptr > (); break; - case 97: // DerivedDefinition + case 98: // DerivedDefinition value.template destroy< DerivedDefinition::Ptr > (); break; - case 130: // DirectCallExpression + case 135: // DirectCallExpression value.template destroy< DirectCallExpression::Ptr > (); break; - case 98: // EnumerationDefinition + case 99: // EnumerationDefinition value.template destroy< EnumerationDefinition::Ptr > (); break; - case 136: // ExistentialQuantifierExpression + case 141: // ExistentialQuantifierExpression value.template destroy< ExistentialQuantifierExpression::Ptr > (); break; - case 90: // MaybeDefined - case 114: // Atom - case 123: // Term - case 124: // Expression + case 91: // MaybeDefined + case 119: // Atom + case 128: // Term + case 129: // Expression value.template destroy< Expression::Ptr > (); break; - case 156: // ExpressionAttribute + case 161: // ExpressionAttribute value.template destroy< ExpressionAttribute::Ptr > (); break; - case 127: // Terms - case 128: // Arguments - case 129: // TwoOrMoreArguments + case 132: // Terms + case 133: // Arguments + case 134: // TwoOrMoreArguments value.template destroy< Expressions::Ptr > (); break; - case 112: // FixedSizedType + case 101: // FeatureDefinition + value.template destroy< FeatureDefinition::Ptr > (); + break; + + case 117: // FixedSizedType value.template destroy< FixedSizedType::Ptr > (); break; - case 146: // ForallRule + case 151: // ForallRule value.template destroy< ForallRule::Ptr > (); break; - case 87: // FunctionDefinition - case 93: // ProgramFunctionDefinition + case 88: // FunctionDefinition + case 94: // ProgramFunctionDefinition value.template destroy< FunctionDefinition::Ptr > (); break; - case 88: // FunctionDefinitions + case 89: // FunctionDefinitions value.template destroy< FunctionDefinitions::Ptr > (); break; - case 100: // Identifier + case 105: // Identifier value.template destroy< Identifier::Ptr > (); break; - case 103: // IdentifierPath + case 108: // IdentifierPath value.template destroy< IdentifierPath::Ptr > (); break; - case 101: // Identifiers - case 102: // DotSeparatedIdentifiers + case 106: // Identifiers + case 107: // DotSeparatedIdentifiers value.template destroy< Identifiers::Ptr > (); break; - case 131: // IndirectCallExpression + case 136: // IndirectCallExpression value.template destroy< IndirectCallExpression::Ptr > (); break; - case 148: // IterateRule + case 153: // IterateRule value.template destroy< IterateRule::Ptr > (); break; - case 132: // LetExpression + case 137: // LetExpression value.template destroy< LetExpression::Ptr > (); break; - case 145: // LetRule + case 150: // LetRule value.template destroy< LetRule::Ptr > (); break; - case 126: // List + case 131: // List value.template destroy< ListExpression::Ptr > (); break; - case 89: // MaybeInitially - case 95: // Initializers - case 96: // MaybeInitializers + case 90: // MaybeInitially + case 96: // Initializers + case 97: // MaybeInitializers value.template destroy< NodeList< UpdateRule >::Ptr > (); break; - case 106: // Parameters - case 107: // MaybeParameters + case 111: // Parameters + case 112: // MaybeParameters value.template destroy< NodeList< VariableDefinition >::Ptr > (); break; - case 125: // Range + case 130: // Range value.template destroy< RangeExpression::Ptr > (); break; - case 122: // Reference + case 127: // Reference value.template destroy< ReferenceAtom::Ptr > (); break; - case 111: // RelationType + case 116: // RelationType value.template destroy< RelationType::Ptr > (); break; - case 138: // Rule + case 143: // Rule value.template destroy< Rule::Ptr > (); break; - case 137: // RuleDefinition + case 142: // RuleDefinition value.template destroy< RuleDefinition::Ptr > (); break; - case 139: // Rules + case 144: // Rules value.template destroy< Rules::Ptr > (); break; - case 150: // SequenceRule + case 155: // SequenceRule value.template destroy< SequenceRule::Ptr > (); break; - case 140: // SkipRule + case 145: // SkipRule value.template destroy< SkipRule::Ptr > (); break; - case 83: // Specification + case 84: // Specification value.template destroy< Specification::Ptr > (); break; - case 99: // StructureDefinition + case 100: // StructureDefinition value.template destroy< StructureDefinition::Ptr > (); break; - case 108: // Type + case 113: // Type value.template destroy< Type::Ptr > (); break; - case 91: // FunctionParameters - case 92: // MaybeFunctionParameters - case 113: // Types + case 92: // FunctionParameters + case 93: // MaybeFunctionParameters + case 118: // Types value.template destroy< Types::Ptr > (); break; - case 115: // Undefined + case 120: // Undefined value.template destroy< UndefAtom::Ptr > (); break; - case 135: // UniversalQuantifierExpression + case 140: // UniversalQuantifierExpression value.template destroy< UniversalQuantifierExpression::Ptr > (); break; - case 94: // Initializer - case 151: // UpdateRule + case 95: // Initializer + case 156: // UpdateRule value.template destroy< UpdateRule::Ptr > (); break; - case 116: // Boolean - case 117: // String - case 118: // BitNumber - case 119: // IntegerNumber - case 120: // FloatingNumber - case 121: // RationalNumber + case 121: // Boolean + case 122: // String + case 123: // BitNumber + case 124: // IntegerNumber + case 125: // FloatingNumber + case 126: // RationalNumber value.template destroy< ValueAtom::Ptr > (); break; - case 104: // Variable - case 105: // AttributedVariable + case 109: // Variable + case 110: // AttributedVariable value.template destroy< VariableDefinition::Ptr > (); break; - case 71: // "binary" - case 72: // "hexadecimal" - case 73: // "integer" - case 74: // "rational" - case 75: // "floating" - case 76: // "string" - case 77: // "identifier" + case 72: // "binary" + case 73: // "hexadecimal" + case 74: // "integer" + case 75: // "rational" + case 76: // "floating" + case 77: // "string" + case 78: // "identifier" value.template destroy< std::string > (); break; @@ -2628,249 +2689,259 @@ namespace libcasm_fe { super_type::move(s); switch (this->type_get ()) { - case 153: // Attribute + case 158: // Attribute value.move< Attribute::Ptr > (s.value); break; - case 154: // Attributes + case 159: // Attributes value.move< Attributes::Ptr > (s.value); break; - case 155: // BasicAttribute + case 160: // BasicAttribute value.move< BasicAttribute::Ptr > (s.value); break; - case 109: // BasicType + case 114: // BasicType value.move< BasicType::Ptr > (s.value); break; - case 149: // BlockRule + case 154: // BlockRule value.move< BlockRule::Ptr > (s.value); break; - case 152: // CallRule + case 157: // CallRule value.move< CallRule::Ptr > (s.value); break; - case 143: // CaseLabel + case 148: // CaseLabel value.move< Case::Ptr > (s.value); break; - case 142: // CaseRule + case 147: // CaseRule value.move< CaseRule::Ptr > (s.value); break; - case 144: // CaseLabels + case 149: // CaseLabels value.move< Cases::Ptr > (s.value); break; - case 134: // ChooseExpression + case 139: // ChooseExpression value.move< ChooseExpression::Ptr > (s.value); break; - case 147: // ChooseRule + case 152: // ChooseRule value.move< ChooseRule::Ptr > (s.value); break; - case 110: // ComposedType + case 115: // ComposedType value.move< ComposedType::Ptr > (s.value); break; - case 133: // ConditionalExpression + case 138: // ConditionalExpression value.move< ConditionalExpression::Ptr > (s.value); break; - case 141: // ConditionalRule + case 146: // ConditionalRule value.move< ConditionalRule::Ptr > (s.value); break; - case 84: // Definition - case 85: // AttributedDefinition + case 104: // DeclarationDefinition + value.move< DeclarationDefinition::Ptr > (s.value); + break; + + case 85: // Definition + case 86: // AttributedDefinition + case 102: // FeatureDeclarationOrDefinition value.move< Definition::Ptr > (s.value); break; - case 86: // Definitions + case 87: // Definitions + case 103: // FeatureDeclarationsAndDefinitions value.move< Definitions::Ptr > (s.value); break; - case 97: // DerivedDefinition + case 98: // DerivedDefinition value.move< DerivedDefinition::Ptr > (s.value); break; - case 130: // DirectCallExpression + case 135: // DirectCallExpression value.move< DirectCallExpression::Ptr > (s.value); break; - case 98: // EnumerationDefinition + case 99: // EnumerationDefinition value.move< EnumerationDefinition::Ptr > (s.value); break; - case 136: // ExistentialQuantifierExpression + case 141: // ExistentialQuantifierExpression value.move< ExistentialQuantifierExpression::Ptr > (s.value); break; - case 90: // MaybeDefined - case 114: // Atom - case 123: // Term - case 124: // Expression + case 91: // MaybeDefined + case 119: // Atom + case 128: // Term + case 129: // Expression value.move< Expression::Ptr > (s.value); break; - case 156: // ExpressionAttribute + case 161: // ExpressionAttribute value.move< ExpressionAttribute::Ptr > (s.value); break; - case 127: // Terms - case 128: // Arguments - case 129: // TwoOrMoreArguments + case 132: // Terms + case 133: // Arguments + case 134: // TwoOrMoreArguments value.move< Expressions::Ptr > (s.value); break; - case 112: // FixedSizedType + case 101: // FeatureDefinition + value.move< FeatureDefinition::Ptr > (s.value); + break; + + case 117: // FixedSizedType value.move< FixedSizedType::Ptr > (s.value); break; - case 146: // ForallRule + case 151: // ForallRule value.move< ForallRule::Ptr > (s.value); break; - case 87: // FunctionDefinition - case 93: // ProgramFunctionDefinition + case 88: // FunctionDefinition + case 94: // ProgramFunctionDefinition value.move< FunctionDefinition::Ptr > (s.value); break; - case 88: // FunctionDefinitions + case 89: // FunctionDefinitions value.move< FunctionDefinitions::Ptr > (s.value); break; - case 100: // Identifier + case 105: // Identifier value.move< Identifier::Ptr > (s.value); break; - case 103: // IdentifierPath + case 108: // IdentifierPath value.move< IdentifierPath::Ptr > (s.value); break; - case 101: // Identifiers - case 102: // DotSeparatedIdentifiers + case 106: // Identifiers + case 107: // DotSeparatedIdentifiers value.move< Identifiers::Ptr > (s.value); break; - case 131: // IndirectCallExpression + case 136: // IndirectCallExpression value.move< IndirectCallExpression::Ptr > (s.value); break; - case 148: // IterateRule + case 153: // IterateRule value.move< IterateRule::Ptr > (s.value); break; - case 132: // LetExpression + case 137: // LetExpression value.move< LetExpression::Ptr > (s.value); break; - case 145: // LetRule + case 150: // LetRule value.move< LetRule::Ptr > (s.value); break; - case 126: // List + case 131: // List value.move< ListExpression::Ptr > (s.value); break; - case 89: // MaybeInitially - case 95: // Initializers - case 96: // MaybeInitializers + case 90: // MaybeInitially + case 96: // Initializers + case 97: // MaybeInitializers value.move< NodeList< UpdateRule >::Ptr > (s.value); break; - case 106: // Parameters - case 107: // MaybeParameters + case 111: // Parameters + case 112: // MaybeParameters value.move< NodeList< VariableDefinition >::Ptr > (s.value); break; - case 125: // Range + case 130: // Range value.move< RangeExpression::Ptr > (s.value); break; - case 122: // Reference + case 127: // Reference value.move< ReferenceAtom::Ptr > (s.value); break; - case 111: // RelationType + case 116: // RelationType value.move< RelationType::Ptr > (s.value); break; - case 138: // Rule + case 143: // Rule value.move< Rule::Ptr > (s.value); break; - case 137: // RuleDefinition + case 142: // RuleDefinition value.move< RuleDefinition::Ptr > (s.value); break; - case 139: // Rules + case 144: // Rules value.move< Rules::Ptr > (s.value); break; - case 150: // SequenceRule + case 155: // SequenceRule value.move< SequenceRule::Ptr > (s.value); break; - case 140: // SkipRule + case 145: // SkipRule value.move< SkipRule::Ptr > (s.value); break; - case 83: // Specification + case 84: // Specification value.move< Specification::Ptr > (s.value); break; - case 99: // StructureDefinition + case 100: // StructureDefinition value.move< StructureDefinition::Ptr > (s.value); break; - case 108: // Type + case 113: // Type value.move< Type::Ptr > (s.value); break; - case 91: // FunctionParameters - case 92: // MaybeFunctionParameters - case 113: // Types + case 92: // FunctionParameters + case 93: // MaybeFunctionParameters + case 118: // Types value.move< Types::Ptr > (s.value); break; - case 115: // Undefined + case 120: // Undefined value.move< UndefAtom::Ptr > (s.value); break; - case 135: // UniversalQuantifierExpression + case 140: // UniversalQuantifierExpression value.move< UniversalQuantifierExpression::Ptr > (s.value); break; - case 94: // Initializer - case 151: // UpdateRule + case 95: // Initializer + case 156: // UpdateRule value.move< UpdateRule::Ptr > (s.value); break; - case 116: // Boolean - case 117: // String - case 118: // BitNumber - case 119: // IntegerNumber - case 120: // FloatingNumber - case 121: // RationalNumber + case 121: // Boolean + case 122: // String + case 123: // BitNumber + case 124: // IntegerNumber + case 125: // FloatingNumber + case 126: // RationalNumber value.move< ValueAtom::Ptr > (s.value); break; - case 104: // Variable - case 105: // AttributedVariable + case 109: // Variable + case 110: // AttributedVariable value.move< VariableDefinition::Ptr > (s.value); break; - case 71: // "binary" - case 72: // "hexadecimal" - case 73: // "integer" - case 74: // "rational" - case 75: // "floating" - case 76: // "string" - case 77: // "identifier" + case 72: // "binary" + case 73: // "hexadecimal" + case 74: // "integer" + case 75: // "rational" + case 76: // "floating" + case 77: // "string" + case 78: // "identifier" value.move< std::string > (s.value); break; @@ -2937,7 +3008,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 + 335, 336, 337 }; return static_cast (yytoken_number_[type]); } @@ -3002,6 +3073,12 @@ namespace libcasm_fe { return symbol_type (token::STRUCTURE, l); } + Parser::symbol_type + Parser::make_FEATURE (const location_type& l) + { + return symbol_type (token::FEATURE, l); + } + Parser::symbol_type Parser::make_SEQ (const location_type& l) { @@ -3425,7 +3502,7 @@ namespace libcasm_fe { #line 31 "../../obj/src/GrammarParser.yy" // lalr1.cc:377 } // libcasm_fe -#line 3429 "GrammarParser.tab.h" // lalr1.cc:377 +#line 3506 "GrammarParser.tab.h" // lalr1.cc:377