From b408c2fe1285a7c6ebe92277d6d7dd52ce02f3fb Mon Sep 17 00:00:00 2001 From: Emmanuel Pescosta Date: Mon, 17 Jul 2017 14:06:40 +0200 Subject: [PATCH] Grammar: add support for type aliasing The rule is: TYPE Identifier = Type Refs casm-lang/casm#16 --- src/GrammarParser.yy | 13 + src/GrammarToken.hpp | 1 + src/ast/Definition.cpp | 17 + src/ast/Definition.h | 16 + src/ast/EmptyVisitor.cpp | 4 + src/ast/EmptyVisitor.h | 1 + src/ast/Node.cpp | 4 + src/ast/Node.h | 1 + src/ast/RecursiveVisitor.cpp | 7 + src/ast/RecursiveVisitor.h | 1 + src/ast/Visitor.h | 2 + src/transform/AstDumpDotPass.cpp | 8 + src/transform/AstDumpSourcePass.cpp | 9 + src/transform/AstToCasmIRPass.cpp | 7 + src/various/Grammar.org | 4 + src/various/GrammarLexer.cpp | 579 +- src/various/GrammarParser.cpp | 2679 +++--- src/various/GrammarParser.output | 12865 +++++++++++++------------- src/various/GrammarParser.tab.h | 847 +- 19 files changed, 8649 insertions(+), 8416 deletions(-) diff --git a/src/GrammarParser.yy b/src/GrammarParser.yy index 79745674c..2b360a79b 100644 --- a/src/GrammarParser.yy +++ b/src/GrammarParser.yy @@ -170,6 +170,7 @@ END 0 "end of file" %type DerivedDefinition %type RuleDefinition %type EnumerationDefinition +%type TypeDefinition // expressions %type Expression Term Atom @@ -297,6 +298,10 @@ Definition { $$ = $1; } +| TypeDefinition + { + $$ = $1; + } | error // error recovery { $$ = nullptr; @@ -524,6 +529,14 @@ EnumerationDefinition ; +TypeDefinition +: TYPE Identifier EQUAL Type + { + $$ = Ast::make< TypeDefinition >( @$, $2, $4 ); + } +; + + Identifier : IDENTIFIER { diff --git a/src/GrammarToken.hpp b/src/GrammarToken.hpp index 6e5d38e44..d10380b02 100644 --- a/src/GrammarToken.hpp +++ b/src/GrammarToken.hpp @@ -30,6 +30,7 @@ INIT "init" { return Parser::make_INIT(loc); } DERIVED "derived" { return Parser::make_DERIVED(loc); } ENUM "enum" { return Parser::make_ENUM(loc); } RULE "rule" { return Parser::make_RULE(loc); } +TYPE "type" { return Parser::make_TYPE(loc); } FUNCTION "function" { return Parser::make_FUNCTION(loc); } INITIALLY "initially" { return Parser::make_INITIALLY(loc); } diff --git a/src/ast/Definition.cpp b/src/ast/Definition.cpp index ac8c7d511..37e4b63e3 100644 --- a/src/ast/Definition.cpp +++ b/src/ast/Definition.cpp @@ -306,3 +306,20 @@ void EnumerationDefinition::accept( Visitor& visitor ) { visitor.visit( *this ); } + +TypeDefinition::TypeDefinition( + const Identifier::Ptr& identifier, const Type::Ptr& type ) +: Definition( Node::ID::TYPE_DEFINITION, identifier ) +, m_type( type ) +{ +} + +const Type::Ptr& TypeDefinition::type( void ) const +{ + return m_type; +} + +void TypeDefinition::accept( Visitor& visitor ) +{ + visitor.visit( *this ); +} diff --git a/src/ast/Definition.h b/src/ast/Definition.h index b78582254..4d00c4891 100644 --- a/src/ast/Definition.h +++ b/src/ast/Definition.h @@ -216,6 +216,22 @@ namespace libcasm_fe private: const Identifiers::Ptr m_enumerators; }; + + class TypeDefinition final : public Definition + { + public: + using Ptr = std::shared_ptr< TypeDefinition >; + + TypeDefinition( + const Identifier::Ptr& identifier, const Type::Ptr& type ); + + const Type::Ptr& type( void ) const; + + void accept( Visitor& visitor ) override final; + + private: + const Type::Ptr m_type; + }; } } diff --git a/src/ast/EmptyVisitor.cpp b/src/ast/EmptyVisitor.cpp index 986665b9a..4a5c7b331 100644 --- a/src/ast/EmptyVisitor.cpp +++ b/src/ast/EmptyVisitor.cpp @@ -54,6 +54,10 @@ void EmptyVisitor::visit( EnumerationDefinition& ) { } +void EmptyVisitor::visit( TypeDefinition& ) +{ +} + void EmptyVisitor::visit( ValueAtom& ) { } diff --git a/src/ast/EmptyVisitor.h b/src/ast/EmptyVisitor.h index d35b13bdc..d826aa6a7 100644 --- a/src/ast/EmptyVisitor.h +++ b/src/ast/EmptyVisitor.h @@ -42,6 +42,7 @@ namespace libcasm_fe void visit( DerivedDefinition& node ) override; void visit( RuleDefinition& node ) override; void visit( EnumerationDefinition& node ) override; + void visit( TypeDefinition& 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 e0505ca58..244eadf2a 100644 --- a/src/ast/Node.cpp +++ b/src/ast/Node.cpp @@ -77,6 +77,10 @@ std::string Node::description( void ) const { return "enumeration"; } + case ID::TYPE_DEFINITION: + { + return "type"; + } case ID::VALUE_ATOM: { return "value"; diff --git a/src/ast/Node.h b/src/ast/Node.h index 2d4683661..303e5f495 100644 --- a/src/ast/Node.h +++ b/src/ast/Node.h @@ -55,6 +55,7 @@ namespace libcasm_fe DERIVED_DEFINITION, RULE_DEFINITION, ENUMERATION_DEFINITION, + TYPE_DEFINITION, // expressions VALUE_ATOM, diff --git a/src/ast/RecursiveVisitor.cpp b/src/ast/RecursiveVisitor.cpp index 519efdeee..c3ca00f8e 100644 --- a/src/ast/RecursiveVisitor.cpp +++ b/src/ast/RecursiveVisitor.cpp @@ -78,6 +78,13 @@ void RecursiveVisitor::visit( EnumerationDefinition& node ) node.attributes()->accept( *this ); } +void RecursiveVisitor::visit( TypeDefinition& node ) +{ + node.identifier()->accept( *this ); + node.type()->accept( *this ); + node.attributes()->accept( *this ); +} + void RecursiveVisitor::visit( ValueAtom& node ) { } diff --git a/src/ast/RecursiveVisitor.h b/src/ast/RecursiveVisitor.h index 7c10b5a81..5ce1a1c74 100644 --- a/src/ast/RecursiveVisitor.h +++ b/src/ast/RecursiveVisitor.h @@ -42,6 +42,7 @@ namespace libcasm_fe void visit( DerivedDefinition& node ) override; void visit( RuleDefinition& node ) override; void visit( EnumerationDefinition& node ) override; + void visit( TypeDefinition& 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 3d29da139..9b3da588d 100644 --- a/src/ast/Visitor.h +++ b/src/ast/Visitor.h @@ -37,6 +37,7 @@ namespace libcasm_fe class DerivedDefinition; class RuleDefinition; class EnumerationDefinition; + class TypeDefinition; class ValueAtom; class ReferenceAtom; @@ -94,6 +95,7 @@ namespace libcasm_fe virtual void visit( DerivedDefinition& node ) = 0; virtual void visit( RuleDefinition& node ) = 0; virtual void visit( EnumerationDefinition& node ) = 0; + virtual void visit( TypeDefinition& node ) = 0; virtual void visit( ValueAtom& node ) = 0; virtual void visit( ReferenceAtom& node ) = 0; diff --git a/src/transform/AstDumpDotPass.cpp b/src/transform/AstDumpDotPass.cpp index fc84ae1a1..8605f2373 100644 --- a/src/transform/AstDumpDotPass.cpp +++ b/src/transform/AstDumpDotPass.cpp @@ -85,6 +85,7 @@ class AstDumpDotVisitor final : public RecursiveVisitor void visit( DerivedDefinition& node ) override; void visit( RuleDefinition& node ) override; void visit( EnumerationDefinition& node ) override; + void visit( TypeDefinition& node ) override; void visit( ValueAtom& node ) override; void visit( ReferenceAtom& node ) override; @@ -201,6 +202,13 @@ void AstDumpDotVisitor::visit( EnumerationDefinition& node ) RecursiveVisitor::visit( node ); } +void AstDumpDotVisitor::visit( TypeDefinition& node ) +{ + DotLink link( this, &node ); + dumpNode( node, "TypeDefinition" ); + RecursiveVisitor::visit( node ); +} + void AstDumpDotVisitor::visit( ValueAtom& node ) { DotLink link( this, &node ); diff --git a/src/transform/AstDumpSourcePass.cpp b/src/transform/AstDumpSourcePass.cpp index bfaf323eb..477889a3c 100644 --- a/src/transform/AstDumpSourcePass.cpp +++ b/src/transform/AstDumpSourcePass.cpp @@ -130,6 +130,7 @@ class AstDumpSourceVisitor final : public Visitor void visit( DerivedDefinition& node ) override; void visit( RuleDefinition& node ) override; void visit( EnumerationDefinition& node ) override; + void visit( TypeDefinition& node ) override; void visit( ValueAtom& node ) override; void visit( ReferenceAtom& node ) override; @@ -323,6 +324,14 @@ void AstDumpSourceVisitor::visit( EnumerationDefinition& node ) m_stream << "}"; } +void AstDumpSourceVisitor::visit( TypeDefinition& node ) +{ + m_stream << "type "; + node.identifier()->accept( *this ); + m_stream << " = "; + node.type()->accept( *this ); +} + void AstDumpSourceVisitor::visit( ValueAtom& node ) { m_stream << node.value()->name(); diff --git a/src/transform/AstToCasmIRPass.cpp b/src/transform/AstToCasmIRPass.cpp index fba59a967..e5e636aca 100644 --- a/src/transform/AstToCasmIRPass.cpp +++ b/src/transform/AstToCasmIRPass.cpp @@ -56,6 +56,7 @@ class AstToCasmIRVisitor final : public RecursiveVisitor void visit( DerivedDefinition& node ) override; void visit( RuleDefinition& node ) override; void visit( EnumerationDefinition& node ) override; + void visit( TypeDefinition& node ) override; void visit( ValueAtom& node ) override; void visit( ReferenceAtom& node ) override; @@ -262,6 +263,12 @@ void AstToCasmIRVisitor::visit( EnumerationDefinition& node ) "%s:%i: TODO %s", __FILE__, __LINE__, node.description().c_str() ); } +void AstToCasmIRVisitor::visit( TypeDefinition& node ) +{ + m_log.info( + "%s:%i: TODO %s", __FILE__, __LINE__, node.description().c_str() ); +} + void AstToCasmIRVisitor::visit( ValueAtom& node ) { assert( node.type() ); diff --git a/src/various/Grammar.org b/src/various/Grammar.org index f5222abd0..ad1547222 100644 --- a/src/various/Grammar.org +++ b/src/various/Grammar.org @@ -7,6 +7,7 @@ Definition | DerivedDefinition | RuleDefinition | EnumerationDefinition +| TypeDefinition | error // error recovery AttributedDefinition @@ -60,6 +61,9 @@ DerivedDefinition EnumerationDefinition : ENUM Identifier EQUAL LCURPAREN Identifiers RCURPAREN +TypeDefinition +: TYPE Identifier EQUAL Type + Identifier : IDENTIFIER | IN // allow in keyword as identifier diff --git a/src/various/GrammarLexer.cpp b/src/various/GrammarLexer.cpp index f46f80c43..a69017375 100644 --- a/src/various/GrammarLexer.cpp +++ b/src/various/GrammarLexer.cpp @@ -320,8 +320,8 @@ int yyFlexLexer::yylex() (yy_hold_char) = *yy_cp; \ *yy_cp = '\0'; \ (yy_c_buf_p) = yy_cp; -#define YY_NUM_RULES 92 -#define YY_END_OF_BUFFER 93 +#define YY_NUM_RULES 93 +#define YY_END_OF_BUFFER 94 /* This struct is not used in this scanner, but its presence is necessary. */ struct yy_trans_info @@ -329,34 +329,34 @@ struct yy_trans_info flex_int32_t yy_verify; flex_int32_t yy_nxt; }; -static const flex_int16_t yy_accept[236] = +static const flex_int16_t yy_accept[239] = { 0, - 0, 0, 0, 0, 0, 0, 84, 84, 93, 91, - 74, 75, 91, 83, 60, 62, 46, 47, 58, 43, - 55, 44, 64, 59, 4, 4, 52, 56, 45, 57, - 54, 73, 73, 48, 49, 61, 53, 73, 73, 73, - 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, - 73, 73, 73, 73, 50, 91, 51, 77, 78, 82, - 81, 82, 82, 84, 85, 90, 92, 74, 75, 68, - 65, 63, 79, 76, 4, 0, 4, 0, 0, 0, - 67, 69, 66, 70, 73, 73, 73, 73, 73, 73, - 24, 73, 73, 73, 73, 73, 73, 73, 26, 73, - - 20, 73, 73, 73, 30, 39, 73, 73, 73, 73, - 73, 73, 73, 73, 73, 71, 72, 82, 82, 80, - 84, 88, 89, 86, 87, 4, 5, 1, 3, 2, - 73, 38, 73, 73, 73, 73, 73, 73, 73, 73, - 73, 73, 73, 73, 73, 73, 73, 73, 19, 42, - 16, 73, 14, 73, 73, 73, 73, 73, 40, 0, - 1, 1, 3, 0, 3, 2, 2, 6, 25, 29, - 73, 73, 73, 73, 28, 73, 73, 9, 73, 73, - 73, 73, 73, 73, 7, 73, 10, 18, 27, 37, - 73, 34, 0, 5, 3, 73, 73, 73, 73, 73, - - 73, 73, 36, 73, 73, 32, 73, 73, 73, 35, - 3, 3, 22, 73, 73, 73, 17, 15, 33, 21, - 73, 73, 73, 73, 31, 13, 8, 73, 41, 73, - 23, 11, 73, 12, 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, + 28, 38, 11, 74, 35, 0, 5, 3, 74, 74, + + 74, 74, 74, 74, 74, 37, 74, 74, 33, 74, + 74, 74, 36, 3, 3, 23, 74, 74, 74, 18, + 16, 34, 22, 74, 74, 74, 74, 32, 14, 8, + 74, 42, 74, 24, 12, 74, 13, 0 } ; static const YY_CHAR yy_ec[256] = @@ -402,69 +402,69 @@ static const YY_CHAR yy_meta[65] = 7, 1, 1, 1 } ; -static const flex_int16_t yy_base[244] = +static const flex_int16_t yy_base[247] = { 0, - 0, 0, 353, 352, 62, 64, 66, 68, 354, 357, - 74, 350, 330, 357, 357, 357, 357, 357, 357, 357, - 357, 328, 335, 66, 97, 71, 327, 326, 324, 324, - 357, 0, 320, 357, 357, 357, 0, 294, 40, 40, - 46, 30, 292, 51, 299, 290, 49, 300, 282, 66, - 54, 288, 291, 285, 272, 270, 357, 357, 357, 329, - 357, 328, 315, 0, 357, 357, 111, 116, 327, 357, - 357, 357, 357, 357, 116, 108, 122, 80, 125, 0, - 357, 357, 357, 357, 0, 296, 286, 73, 276, 78, - 0, 271, 96, 279, 276, 269, 272, 273, 0, 268, - - 273, 275, 261, 260, 0, 0, 261, 266, 260, 266, - 268, 253, 267, 252, 253, 357, 357, 302, 301, 357, - 0, 357, 357, 357, 357, 128, 131, 146, 154, 296, - 272, 0, 254, 258, 249, 112, 253, 255, 104, 248, - 241, 240, 254, 252, 250, 243, 234, 235, 0, 0, - 0, 245, 0, 235, 236, 242, 241, 238, 0, 163, - 161, 168, 175, 170, 182, 274, 273, 0, 0, 0, - 225, 222, 228, 219, 0, 236, 232, 0, 218, 230, - 224, 215, 215, 223, 222, 227, 0, 0, 0, 0, - 222, 0, 178, 185, 197, 222, 216, 220, 218, 201, - - 201, 195, 0, 199, 167, 0, 169, 170, 153, 0, - 200, 203, 0, 151, 164, 142, 0, 0, 0, 0, - 117, 111, 117, 112, 0, 0, 0, 61, 0, 62, - 0, 0, 31, 0, 357, 222, 229, 236, 238, 245, - 252, 78, 256 + 0, 0, 356, 355, 62, 64, 66, 68, 357, 360, + 74, 353, 333, 360, 360, 360, 360, 360, 360, 360, + 360, 331, 338, 66, 97, 71, 330, 329, 327, 327, + 360, 0, 323, 360, 360, 360, 0, 297, 40, 40, + 46, 30, 295, 51, 302, 293, 49, 303, 285, 66, + 63, 291, 294, 288, 275, 273, 360, 360, 360, 332, + 360, 331, 318, 0, 360, 360, 91, 116, 330, 360, + 360, 360, 360, 360, 117, 109, 125, 93, 120, 0, + 360, 360, 360, 360, 0, 299, 289, 97, 279, 78, + 0, 274, 104, 282, 279, 272, 275, 276, 0, 271, + + 276, 278, 264, 263, 0, 0, 264, 269, 263, 269, + 271, 256, 260, 269, 254, 255, 360, 360, 304, 303, + 360, 0, 360, 360, 360, 360, 141, 136, 154, 158, + 298, 274, 0, 256, 260, 251, 52, 255, 257, 112, + 250, 243, 242, 256, 254, 252, 245, 236, 237, 0, + 0, 0, 247, 0, 237, 238, 244, 243, 242, 239, + 0, 166, 173, 178, 181, 151, 185, 275, 274, 0, + 0, 0, 226, 223, 229, 220, 0, 237, 233, 0, + 219, 231, 225, 216, 216, 224, 223, 227, 0, 0, + 0, 0, 0, 217, 0, 188, 191, 203, 217, 208, + + 210, 176, 164, 163, 160, 0, 165, 166, 0, 151, + 152, 132, 0, 206, 209, 0, 131, 140, 131, 0, + 0, 0, 0, 112, 101, 102, 105, 0, 0, 0, + 80, 0, 73, 0, 0, 58, 0, 360, 228, 235, + 242, 244, 251, 258, 78, 262 } ; -static const flex_int16_t yy_def[244] = +static const flex_int16_t yy_def[247] = { 0, - 235, 1, 236, 236, 237, 237, 238, 238, 235, 235, - 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, - 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, - 235, 239, 239, 235, 235, 235, 239, 239, 239, 239, - 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, - 239, 239, 239, 239, 235, 235, 235, 235, 235, 240, - 235, 240, 235, 241, 235, 235, 235, 235, 235, 235, - 235, 235, 235, 235, 235, 235, 235, 235, 235, 242, - 235, 235, 235, 235, 239, 239, 239, 239, 239, 239, - 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, - - 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, - 239, 239, 239, 239, 239, 235, 235, 240, 240, 235, - 241, 235, 235, 235, 235, 235, 235, 235, 235, 243, - 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, - 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, - 239, 239, 239, 239, 239, 239, 239, 239, 239, 235, - 235, 235, 235, 235, 235, 243, 243, 239, 239, 239, - 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, - 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, - 239, 239, 235, 235, 235, 239, 239, 239, 239, 239, - - 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, - 235, 235, 239, 239, 239, 239, 239, 239, 239, 239, - 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, - 239, 239, 239, 239, 0, 235, 235, 235, 235, 235, - 235, 235, 235 + 238, 1, 239, 239, 240, 240, 241, 241, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 242, 242, 238, 238, 238, 242, 242, 242, 242, + 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, + 242, 242, 242, 242, 238, 238, 238, 238, 238, 243, + 238, 243, 238, 244, 238, 238, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 245, + 238, 238, 238, 238, 242, 242, 242, 242, 242, 242, + 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, + + 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, + 242, 242, 242, 242, 242, 242, 238, 238, 243, 243, + 238, 244, 238, 238, 238, 238, 238, 238, 238, 238, + 246, 242, 242, 242, 242, 242, 242, 242, 242, 242, + 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, + 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, + 242, 238, 238, 238, 238, 238, 238, 246, 246, 242, + 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, + 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, + 242, 242, 242, 242, 242, 238, 238, 238, 242, 242, + + 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, + 242, 242, 242, 238, 238, 242, 242, 242, 242, 242, + 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, + 242, 242, 242, 242, 242, 242, 242, 0, 238, 238, + 238, 238, 238, 238, 238, 238 } ; -static const flex_int16_t yy_nxt[422] = +static const flex_int16_t yy_nxt[425] = { 0, 10, 11, 12, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 26, 27, @@ -474,48 +474,48 @@ static const flex_int16_t yy_nxt[422] = 47, 48, 32, 49, 50, 51, 52, 32, 53, 54, 32, 55, 56, 57, 61, 62, 61, 62, 65, 95, 65, 66, 63, 66, 63, 68, 73, 68, 75, 88, - 96, 74, 90, 130, 89, 76, 97, 77, 77, 77, - 91, 234, 105, 92, 99, 93, 128, 128, 111, 100, - - 101, 67, 106, 67, 75, 94, 102, 112, 109, 233, - 232, 76, 110, 77, 77, 77, 122, 68, 123, 68, - 133, 136, 78, 75, 127, 127, 127, 134, 79, 75, - 80, 137, 126, 126, 126, 75, 76, 139, 77, 77, - 77, 129, 129, 129, 126, 126, 126, 127, 127, 127, - 79, 172, 140, 161, 231, 176, 80, 173, 177, 160, - 124, 163, 162, 162, 230, 229, 125, 228, 161, 164, - 165, 165, 165, 160, 193, 161, 193, 162, 162, 194, - 194, 194, 163, 227, 162, 162, 195, 195, 195, 163, - 164, 165, 165, 165, 194, 194, 194, 164, 165, 165, - - 165, 194, 194, 194, 211, 226, 225, 211, 224, 223, - 211, 222, 221, 212, 212, 212, 212, 212, 212, 212, - 212, 212, 58, 58, 58, 58, 58, 58, 58, 60, - 60, 60, 60, 60, 60, 60, 64, 64, 64, 64, - 64, 64, 64, 85, 85, 118, 220, 118, 118, 219, - 118, 118, 121, 218, 217, 121, 121, 121, 121, 167, - 216, 167, 215, 214, 213, 210, 209, 208, 207, 206, - 205, 204, 203, 202, 201, 200, 199, 198, 197, 196, - 166, 166, 192, 191, 190, 189, 188, 187, 186, 185, - 184, 183, 182, 181, 180, 179, 178, 175, 174, 171, - - 170, 169, 168, 166, 119, 119, 159, 158, 157, 156, - 155, 154, 153, 152, 151, 150, 149, 148, 147, 146, - 145, 144, 143, 142, 141, 138, 135, 132, 131, 69, - 120, 119, 119, 117, 116, 115, 114, 113, 108, 107, - 104, 103, 98, 87, 86, 84, 83, 82, 81, 72, - 71, 70, 69, 235, 59, 59, 9, 235, 235, 235, - 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, - 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, - 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, - 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, - - 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, - 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, - 235 + 96, 74, 90, 131, 89, 76, 97, 77, 77, 77, + 91, 174, 105, 92, 99, 93, 123, 175, 124, 100, + + 101, 67, 106, 67, 75, 94, 102, 111, 109, 129, + 129, 76, 110, 77, 77, 77, 112, 68, 237, 68, + 236, 137, 78, 113, 75, 128, 128, 128, 79, 235, + 80, 138, 75, 127, 127, 127, 130, 130, 130, 76, + 125, 77, 77, 77, 134, 140, 126, 234, 75, 233, + 79, 135, 128, 128, 128, 232, 80, 127, 127, 127, + 141, 163, 231, 178, 162, 165, 179, 198, 198, 198, + 164, 164, 230, 166, 167, 167, 167, 196, 162, 196, + 163, 229, 197, 197, 197, 163, 228, 227, 165, 164, + 164, 226, 165, 225, 164, 164, 166, 167, 167, 167, + + 166, 167, 167, 167, 197, 197, 197, 197, 197, 197, + 214, 224, 223, 214, 222, 221, 214, 220, 219, 215, + 215, 215, 215, 215, 215, 215, 215, 215, 58, 58, + 58, 58, 58, 58, 58, 60, 60, 60, 60, 60, + 60, 60, 64, 64, 64, 64, 64, 64, 64, 85, + 85, 119, 218, 119, 119, 217, 119, 119, 122, 216, + 213, 122, 122, 122, 122, 169, 212, 169, 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, 238, 59, 59, 9, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238, 238 } ; -static const flex_int16_t yy_chk[422] = +static const flex_int16_t yy_chk[425] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -525,45 +525,45 @@ static const flex_int16_t yy_chk[422] = 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 5, 6, 6, 7, 42, 8, 7, 5, 8, 6, 11, 24, 11, 26, 39, - 42, 24, 40, 242, 39, 26, 42, 26, 26, 26, - 40, 233, 47, 41, 44, 41, 78, 78, 51, 44, - - 44, 7, 47, 8, 25, 41, 44, 51, 50, 230, - 228, 25, 50, 25, 25, 25, 67, 68, 67, 68, - 88, 90, 25, 75, 76, 76, 76, 88, 25, 77, - 25, 90, 75, 75, 75, 126, 77, 93, 77, 77, - 77, 79, 79, 79, 126, 126, 126, 127, 127, 127, - 25, 136, 93, 128, 224, 139, 25, 136, 139, 127, - 67, 129, 128, 128, 223, 222, 67, 221, 161, 129, - 129, 129, 129, 127, 160, 162, 160, 161, 161, 160, - 160, 160, 163, 216, 162, 162, 164, 164, 164, 165, - 163, 163, 163, 163, 193, 193, 193, 165, 165, 165, - - 165, 194, 194, 194, 195, 215, 214, 211, 209, 208, - 212, 207, 205, 195, 195, 195, 211, 211, 211, 212, - 212, 212, 236, 236, 236, 236, 236, 236, 236, 237, - 237, 237, 237, 237, 237, 237, 238, 238, 238, 238, - 238, 238, 238, 239, 239, 240, 204, 240, 240, 202, - 240, 240, 241, 201, 200, 241, 241, 241, 241, 243, - 199, 243, 198, 197, 196, 191, 186, 185, 184, 183, - 182, 181, 180, 179, 177, 176, 174, 173, 172, 171, - 167, 166, 158, 157, 156, 155, 154, 152, 148, 147, - 146, 145, 144, 143, 142, 141, 140, 138, 137, 135, - - 134, 133, 131, 130, 119, 118, 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, 235, 235, 235, 235, - 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, - 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, - 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, - 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, - - 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, - 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, - 235 + 42, 24, 40, 245, 39, 26, 42, 26, 26, 26, + 40, 137, 47, 41, 44, 41, 67, 137, 67, 44, + + 44, 7, 47, 8, 25, 41, 44, 51, 50, 78, + 78, 25, 50, 25, 25, 25, 51, 68, 236, 68, + 233, 90, 25, 51, 75, 76, 76, 76, 25, 231, + 25, 90, 77, 75, 75, 75, 79, 79, 79, 77, + 67, 77, 77, 77, 88, 93, 67, 227, 127, 226, + 25, 88, 128, 128, 128, 225, 25, 127, 127, 127, + 93, 129, 224, 140, 128, 130, 140, 166, 166, 166, + 129, 129, 219, 130, 130, 130, 130, 162, 128, 162, + 163, 218, 162, 162, 162, 164, 217, 212, 165, 163, + 163, 211, 167, 210, 164, 164, 165, 165, 165, 165, + + 167, 167, 167, 167, 196, 196, 196, 197, 197, 197, + 198, 208, 207, 214, 205, 204, 215, 203, 202, 198, + 198, 198, 214, 214, 214, 215, 215, 215, 239, 239, + 239, 239, 239, 239, 239, 240, 240, 240, 240, 240, + 240, 240, 241, 241, 241, 241, 241, 241, 241, 242, + 242, 243, 201, 243, 243, 200, 243, 243, 244, 199, + 194, 244, 244, 244, 244, 246, 188, 246, 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, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, + 238, 238, 238, 238 } ; /* The intent behind this definition is that it'll catch @@ -789,13 +789,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 >= 236 ) + if ( yy_current_state >= 239 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; ++yy_cp; } - while ( yy_current_state != 235 ); + while ( yy_current_state != 238 ); yy_cp = (yy_last_accepting_cpos); yy_current_state = (yy_last_accepting_state); @@ -877,353 +877,358 @@ YY_RULE_SETUP YY_BREAK case 11: YY_RULE_SETUP -#line 93 "obj/src/GrammarLexer.l" -{ return Parser::make_FUNCTION(loc); } +#line 92 "obj/src/GrammarLexer.l" +{ return Parser::make_TYPE(loc); } YY_BREAK case 12: YY_RULE_SETUP #line 94 "obj/src/GrammarLexer.l" -{ return Parser::make_INITIALLY(loc); } +{ return Parser::make_FUNCTION(loc); } YY_BREAK case 13: YY_RULE_SETUP #line 95 "obj/src/GrammarLexer.l" -{ return Parser::make_DEFINED(loc); } +{ return Parser::make_INITIALLY(loc); } YY_BREAK case 14: YY_RULE_SETUP -#line 97 "obj/src/GrammarLexer.l" -{ return Parser::make_SEQ(loc); } +#line 96 "obj/src/GrammarLexer.l" +{ return Parser::make_DEFINED(loc); } YY_BREAK case 15: YY_RULE_SETUP #line 98 "obj/src/GrammarLexer.l" -{ return Parser::make_ENDSEQ(loc); } +{ return Parser::make_SEQ(loc); } YY_BREAK case 16: YY_RULE_SETUP #line 99 "obj/src/GrammarLexer.l" -{ return Parser::make_PAR(loc); } +{ return Parser::make_ENDSEQ(loc); } YY_BREAK case 17: YY_RULE_SETUP #line 100 "obj/src/GrammarLexer.l" -{ return Parser::make_ENDPAR(loc); } +{ return Parser::make_PAR(loc); } YY_BREAK case 18: YY_RULE_SETUP -#line 102 "obj/src/GrammarLexer.l" -{ return Parser::make_SKIP(loc); } +#line 101 "obj/src/GrammarLexer.l" +{ return Parser::make_ENDPAR(loc); } YY_BREAK case 19: YY_RULE_SETUP #line 103 "obj/src/GrammarLexer.l" -{ return Parser::make_LET(loc); } +{ return Parser::make_SKIP(loc); } YY_BREAK case 20: YY_RULE_SETUP #line 104 "obj/src/GrammarLexer.l" -{ return Parser::make_IN(loc); } +{ return Parser::make_LET(loc); } YY_BREAK case 21: YY_RULE_SETUP #line 105 "obj/src/GrammarLexer.l" -{ return Parser::make_FORALL(loc); } +{ return Parser::make_IN(loc); } YY_BREAK case 22: YY_RULE_SETUP #line 106 "obj/src/GrammarLexer.l" -{ return Parser::make_CHOOSE(loc); } +{ return Parser::make_FORALL(loc); } YY_BREAK case 23: YY_RULE_SETUP #line 107 "obj/src/GrammarLexer.l" -{ return Parser::make_ITERATE(loc); } +{ return Parser::make_CHOOSE(loc); } YY_BREAK case 24: YY_RULE_SETUP #line 108 "obj/src/GrammarLexer.l" -{ return Parser::make_DO(loc); } +{ return Parser::make_ITERATE(loc); } YY_BREAK case 25: YY_RULE_SETUP #line 109 "obj/src/GrammarLexer.l" -{ return Parser::make_CALL(loc); } +{ return Parser::make_DO(loc); } YY_BREAK case 26: YY_RULE_SETUP #line 110 "obj/src/GrammarLexer.l" -{ return Parser::make_IF(loc); } +{ return Parser::make_CALL(loc); } YY_BREAK case 27: YY_RULE_SETUP #line 111 "obj/src/GrammarLexer.l" -{ return Parser::make_THEN(loc); } +{ return Parser::make_IF(loc); } YY_BREAK case 28: YY_RULE_SETUP #line 112 "obj/src/GrammarLexer.l" -{ return Parser::make_ELSE(loc); } +{ return Parser::make_THEN(loc); } YY_BREAK case 29: YY_RULE_SETUP #line 113 "obj/src/GrammarLexer.l" -{ return Parser::make_CASE(loc); } +{ return Parser::make_ELSE(loc); } YY_BREAK case 30: YY_RULE_SETUP #line 114 "obj/src/GrammarLexer.l" -{ return Parser::make_OF(loc); } +{ return Parser::make_CASE(loc); } YY_BREAK case 31: YY_RULE_SETUP #line 115 "obj/src/GrammarLexer.l" -{ return Parser::make_DEFAULT(loc); } +{ return Parser::make_OF(loc); } YY_BREAK case 32: YY_RULE_SETUP #line 116 "obj/src/GrammarLexer.l" -{ return Parser::make_HOLDS(loc); } +{ return Parser::make_DEFAULT(loc); } YY_BREAK case 33: YY_RULE_SETUP #line 117 "obj/src/GrammarLexer.l" -{ return Parser::make_EXISTS(loc); } +{ return Parser::make_HOLDS(loc); } YY_BREAK case 34: YY_RULE_SETUP #line 118 "obj/src/GrammarLexer.l" -{ return Parser::make_WITH(loc); } +{ return Parser::make_EXISTS(loc); } YY_BREAK case 35: YY_RULE_SETUP -#line 120 "obj/src/GrammarLexer.l" -{ return Parser::make_UNDEF(loc); } +#line 119 "obj/src/GrammarLexer.l" +{ return Parser::make_WITH(loc); } YY_BREAK case 36: YY_RULE_SETUP #line 121 "obj/src/GrammarLexer.l" -{ return Parser::make_FALSE(loc); } +{ return Parser::make_UNDEF(loc); } YY_BREAK case 37: YY_RULE_SETUP #line 122 "obj/src/GrammarLexer.l" -{ return Parser::make_TRUE(loc); } +{ return Parser::make_FALSE(loc); } YY_BREAK case 38: YY_RULE_SETUP -#line 124 "obj/src/GrammarLexer.l" -{ return Parser::make_AND(loc); } +#line 123 "obj/src/GrammarLexer.l" +{ return Parser::make_TRUE(loc); } YY_BREAK case 39: YY_RULE_SETUP #line 125 "obj/src/GrammarLexer.l" -{ return Parser::make_OR(loc); } +{ return Parser::make_AND(loc); } YY_BREAK case 40: YY_RULE_SETUP #line 126 "obj/src/GrammarLexer.l" -{ return Parser::make_XOR(loc); } +{ return Parser::make_OR(loc); } YY_BREAK case 41: YY_RULE_SETUP #line 127 "obj/src/GrammarLexer.l" -{ return Parser::make_IMPLIES(loc); } +{ return Parser::make_XOR(loc); } YY_BREAK case 42: YY_RULE_SETUP #line 128 "obj/src/GrammarLexer.l" -{ return Parser::make_NOT(loc); } +{ return Parser::make_IMPLIES(loc); } YY_BREAK case 43: YY_RULE_SETUP -#line 130 "obj/src/GrammarLexer.l" -{ return Parser::make_PLUS(loc); } +#line 129 "obj/src/GrammarLexer.l" +{ return Parser::make_NOT(loc); } YY_BREAK case 44: YY_RULE_SETUP #line 131 "obj/src/GrammarLexer.l" -{ return Parser::make_MINUS(loc); } +{ return Parser::make_PLUS(loc); } YY_BREAK case 45: YY_RULE_SETUP #line 132 "obj/src/GrammarLexer.l" -{ return Parser::make_EQUAL(loc); } +{ return Parser::make_MINUS(loc); } YY_BREAK case 46: YY_RULE_SETUP #line 133 "obj/src/GrammarLexer.l" -{ return Parser::make_LPAREN(loc); } +{ return Parser::make_EQUAL(loc); } YY_BREAK case 47: YY_RULE_SETUP #line 134 "obj/src/GrammarLexer.l" -{ return Parser::make_RPAREN(loc); } +{ return Parser::make_LPAREN(loc); } YY_BREAK case 48: YY_RULE_SETUP #line 135 "obj/src/GrammarLexer.l" -{ return Parser::make_LSQPAREN(loc); } +{ return Parser::make_RPAREN(loc); } YY_BREAK case 49: YY_RULE_SETUP #line 136 "obj/src/GrammarLexer.l" -{ return Parser::make_RSQPAREN(loc); } +{ return Parser::make_LSQPAREN(loc); } YY_BREAK case 50: YY_RULE_SETUP #line 137 "obj/src/GrammarLexer.l" -{ return Parser::make_LCURPAREN(loc); } +{ return Parser::make_RSQPAREN(loc); } YY_BREAK case 51: YY_RULE_SETUP #line 138 "obj/src/GrammarLexer.l" -{ return Parser::make_RCURPAREN(loc); } +{ return Parser::make_LCURPAREN(loc); } YY_BREAK case 52: YY_RULE_SETUP #line 139 "obj/src/GrammarLexer.l" -{ return Parser::make_COLON(loc); } +{ return Parser::make_RCURPAREN(loc); } YY_BREAK case 53: YY_RULE_SETUP #line 140 "obj/src/GrammarLexer.l" -{ return Parser::make_UNDERLINE(loc); } +{ return Parser::make_COLON(loc); } YY_BREAK case 54: YY_RULE_SETUP #line 141 "obj/src/GrammarLexer.l" -{ return Parser::make_AT(loc); } +{ return Parser::make_UNDERLINE(loc); } YY_BREAK case 55: YY_RULE_SETUP #line 142 "obj/src/GrammarLexer.l" -{ return Parser::make_COMMA(loc); } +{ return Parser::make_AT(loc); } YY_BREAK case 56: YY_RULE_SETUP #line 143 "obj/src/GrammarLexer.l" -{ return Parser::make_LESSER(loc); } +{ return Parser::make_COMMA(loc); } YY_BREAK case 57: YY_RULE_SETUP #line 144 "obj/src/GrammarLexer.l" -{ return Parser::make_GREATER(loc); } +{ return Parser::make_LESSER(loc); } YY_BREAK case 58: YY_RULE_SETUP #line 145 "obj/src/GrammarLexer.l" -{ return Parser::make_ASTERIX(loc); } +{ return Parser::make_GREATER(loc); } YY_BREAK case 59: YY_RULE_SETUP #line 146 "obj/src/GrammarLexer.l" -{ return Parser::make_SLASH(loc); } +{ return Parser::make_ASTERIX(loc); } YY_BREAK case 60: YY_RULE_SETUP #line 147 "obj/src/GrammarLexer.l" -{ return Parser::make_PERCENT(loc); } +{ return Parser::make_SLASH(loc); } YY_BREAK case 61: YY_RULE_SETUP #line 148 "obj/src/GrammarLexer.l" -{ return Parser::make_CARET(loc); } +{ return Parser::make_PERCENT(loc); } YY_BREAK case 62: YY_RULE_SETUP #line 149 "obj/src/GrammarLexer.l" -{ return Parser::make_MARK(loc); } +{ return Parser::make_CARET(loc); } YY_BREAK case 63: YY_RULE_SETUP -#line 151 "obj/src/GrammarLexer.l" -{ return Parser::make_DOTDOT(loc); } +#line 150 "obj/src/GrammarLexer.l" +{ return Parser::make_MARK(loc); } YY_BREAK case 64: YY_RULE_SETUP #line 152 "obj/src/GrammarLexer.l" -{ return Parser::make_DOT(loc); } +{ return Parser::make_DOTDOT(loc); } YY_BREAK case 65: YY_RULE_SETUP #line 153 "obj/src/GrammarLexer.l" -{ return Parser::make_MAPS(loc); } +{ return Parser::make_DOT(loc); } YY_BREAK case 66: YY_RULE_SETUP #line 154 "obj/src/GrammarLexer.l" -{ return Parser::make_ARROW(loc); } +{ return Parser::make_MAPS(loc); } YY_BREAK case 67: YY_RULE_SETUP #line 155 "obj/src/GrammarLexer.l" -{ return Parser::make_UPDATE(loc); } +{ return Parser::make_ARROW(loc); } YY_BREAK case 68: YY_RULE_SETUP #line 156 "obj/src/GrammarLexer.l" -{ return Parser::make_NEQUAL(loc); } +{ return Parser::make_UPDATE(loc); } YY_BREAK case 69: YY_RULE_SETUP #line 157 "obj/src/GrammarLexer.l" -{ return Parser::make_LESSEQ(loc); } +{ return Parser::make_NEQUAL(loc); } YY_BREAK case 70: YY_RULE_SETUP #line 158 "obj/src/GrammarLexer.l" -{ return Parser::make_GREATEREQ(loc); } +{ return Parser::make_LESSEQ(loc); } YY_BREAK case 71: YY_RULE_SETUP #line 159 "obj/src/GrammarLexer.l" -{ return Parser::make_SEQ_BRACKET(loc); } +{ return Parser::make_GREATEREQ(loc); } YY_BREAK case 72: YY_RULE_SETUP #line 160 "obj/src/GrammarLexer.l" -{ return Parser::make_ENDSEQ_BRACKET(loc); } +{ return Parser::make_SEQ_BRACKET(loc); } YY_BREAK case 73: YY_RULE_SETUP -#line 164 "obj/src/GrammarLexer.l" +#line 161 "obj/src/GrammarLexer.l" +{ return Parser::make_ENDSEQ_BRACKET(loc); } + YY_BREAK +case 74: +YY_RULE_SETUP +#line 165 "obj/src/GrammarLexer.l" { return Parser::make_IDENTIFIER( yytext, loc ); } YY_BREAK -case 74: +case 75: YY_RULE_SETUP -#line 168 "obj/src/GrammarLexer.l" +#line 169 "obj/src/GrammarLexer.l" { // ignore spaces loc.step(); } YY_BREAK -case 75: -/* rule 75 can match eol */ +case 76: +/* rule 76 can match eol */ YY_RULE_SETUP -#line 172 "obj/src/GrammarLexer.l" +#line 173 "obj/src/GrammarLexer.l" { // ignore newlines loc.lines( yyleng ); loc.step(); } YY_BREAK -case 76: +case 77: YY_RULE_SETUP -#line 177 "obj/src/GrammarLexer.l" +#line 178 "obj/src/GrammarLexer.l" { // single-line comments BEGIN( LCOMMENT ); } YY_BREAK -case 77: +case 78: YY_RULE_SETUP -#line 180 "obj/src/GrammarLexer.l" +#line 181 "obj/src/GrammarLexer.l" YY_BREAK -case 78: -/* rule 78 can match eol */ +case 79: +/* rule 79 can match eol */ YY_RULE_SETUP -#line 181 "obj/src/GrammarLexer.l" +#line 182 "obj/src/GrammarLexer.l" { BEGIN( INITIAL ); loc.lines( 1 ); @@ -1231,127 +1236,127 @@ YY_RULE_SETUP } YY_BREAK case YY_STATE_EOF(LCOMMENT): -#line 186 "obj/src/GrammarLexer.l" +#line 187 "obj/src/GrammarLexer.l" { BEGIN( INITIAL ); } YY_BREAK -case 79: +case 80: YY_RULE_SETUP -#line 190 "obj/src/GrammarLexer.l" +#line 191 "obj/src/GrammarLexer.l" { // multi-line comments BEGIN( COMMENT ); } YY_BREAK -case 80: +case 81: YY_RULE_SETUP -#line 193 "obj/src/GrammarLexer.l" +#line 194 "obj/src/GrammarLexer.l" { BEGIN( INITIAL ); } YY_BREAK -case 81: -/* rule 81 can match eol */ +case 82: +/* rule 82 can match eol */ YY_RULE_SETUP -#line 196 "obj/src/GrammarLexer.l" +#line 197 "obj/src/GrammarLexer.l" { loc.lines( 1 ); } YY_BREAK -case 82: +case 83: YY_RULE_SETUP -#line 199 "obj/src/GrammarLexer.l" +#line 200 "obj/src/GrammarLexer.l" YY_BREAK case YY_STATE_EOF(COMMENT): -#line 200 "obj/src/GrammarLexer.l" +#line 201 "obj/src/GrammarLexer.l" { BEGIN( INITIAL ); log.error( {loc}, "multiline comment not terminated", Code::SyntaxErrorUnclosedComment ); yyterminate(); } YY_BREAK -case 83: +case 84: YY_RULE_SETUP -#line 206 "obj/src/GrammarLexer.l" +#line 207 "obj/src/GrammarLexer.l" { // strings BEGIN( STRING ); strbuf.clear(); } YY_BREAK -case 84: +case 85: YY_RULE_SETUP -#line 210 "obj/src/GrammarLexer.l" +#line 211 "obj/src/GrammarLexer.l" { /* eat all tokens */ strbuf.append( yytext ); } YY_BREAK -case 85: -/* rule 85 can match eol */ +case 86: +/* rule 86 can match eol */ YY_RULE_SETUP -#line 213 "obj/src/GrammarLexer.l" +#line 214 "obj/src/GrammarLexer.l" { loc.lines( 1 ); } YY_BREAK -case 86: +case 87: YY_RULE_SETUP -#line 216 "obj/src/GrammarLexer.l" +#line 217 "obj/src/GrammarLexer.l" { strbuf.append( "\n" ); } YY_BREAK -case 87: +case 88: YY_RULE_SETUP -#line 219 "obj/src/GrammarLexer.l" +#line 220 "obj/src/GrammarLexer.l" { strbuf.append( "\t" ); } YY_BREAK -case 88: +case 89: YY_RULE_SETUP -#line 222 "obj/src/GrammarLexer.l" +#line 223 "obj/src/GrammarLexer.l" { strbuf.append( "\"" ); } YY_BREAK -case 89: +case 90: YY_RULE_SETUP -#line 225 "obj/src/GrammarLexer.l" +#line 226 "obj/src/GrammarLexer.l" { strbuf.append( "\'" ); } YY_BREAK case YY_STATE_EOF(STRING): -#line 228 "obj/src/GrammarLexer.l" +#line 229 "obj/src/GrammarLexer.l" { BEGIN( INITIAL ); log.error( {loc}, "string not terminated", Code::SyntaxErrorUnclosedString ); yyterminate(); } YY_BREAK -case 90: +case 91: YY_RULE_SETUP -#line 233 "obj/src/GrammarLexer.l" +#line 234 "obj/src/GrammarLexer.l" { BEGIN( INITIAL ); return Parser::make_STRING( strbuf, loc ); } YY_BREAK -case 91: +case 92: YY_RULE_SETUP -#line 238 "obj/src/GrammarLexer.l" +#line 239 "obj/src/GrammarLexer.l" { log.error( {loc}, "unrecognized character `" + std::string( yytext ) + "`", Code::SyntaxErrorUnrecognizedCharacter ); } YY_BREAK -case 92: +case 93: YY_RULE_SETUP -#line 243 "obj/src/GrammarLexer.l" +#line 244 "obj/src/GrammarLexer.l" YY_FATAL_ERROR( "flex scanner jammed" ); YY_BREAK -#line 1354 "src/various/GrammarLexer.cpp" +#line 1359 "src/various/GrammarLexer.cpp" case YY_STATE_EOF(INITIAL): yyterminate(); @@ -1769,7 +1774,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 >= 236 ) + if ( yy_current_state >= 239 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; @@ -1797,11 +1802,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 >= 236 ) + if ( yy_current_state >= 239 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; - yy_is_jam = (yy_current_state == 235); + yy_is_jam = (yy_current_state == 238); return yy_is_jam ? 0 : yy_current_state; } @@ -2315,7 +2320,7 @@ void yyfree (void * ptr ) #define YYTABLES_NAME "yytables" -#line 243 "obj/src/GrammarLexer.l" +#line 244 "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 53db6bf93..57c3ccb6a 100644 --- a/src/various/GrammarParser.cpp +++ b/src/various/GrammarParser.cpp @@ -328,241 +328,245 @@ namespace libcasm_fe { { switch (that.type_get ()) { - case 150: // Attribute + case 152: // Attribute value.move< Attribute::Ptr > (that.value); break; - case 151: // Attributes + case 153: // Attributes value.move< Attributes::Ptr > (that.value); break; - case 152: // BasicAttribute + case 154: // BasicAttribute value.move< BasicAttribute::Ptr > (that.value); break; - case 106: // BasicType + case 108: // BasicType value.move< BasicType::Ptr > (that.value); break; - case 146: // BlockRule + case 148: // BlockRule value.move< BlockRule::Ptr > (that.value); break; - case 149: // CallRule + case 151: // CallRule value.move< CallRule::Ptr > (that.value); break; - case 140: // CaseLabel + case 142: // CaseLabel value.move< Case::Ptr > (that.value); break; - case 139: // CaseRule + case 141: // CaseRule value.move< CaseRule::Ptr > (that.value); break; - case 141: // CaseLabels + case 143: // CaseLabels value.move< Cases::Ptr > (that.value); break; - case 131: // ChooseExpression + case 133: // ChooseExpression value.move< ChooseExpression::Ptr > (that.value); break; - case 144: // ChooseRule + case 146: // ChooseRule value.move< ChooseRule::Ptr > (that.value); break; - case 107: // ComposedType + case 109: // ComposedType value.move< ComposedType::Ptr > (that.value); break; - case 130: // ConditionalExpression + case 132: // ConditionalExpression value.move< ConditionalExpression::Ptr > (that.value); break; - case 138: // ConditionalRule + case 140: // ConditionalRule value.move< ConditionalRule::Ptr > (that.value); break; - case 83: // Definition - case 84: // AttributedDefinition + case 84: // Definition + case 85: // AttributedDefinition value.move< Definition::Ptr > (that.value); break; - case 85: // Definitions + case 86: // Definitions value.move< Definitions::Ptr > (that.value); break; - case 95: // DerivedDefinition + case 96: // DerivedDefinition value.move< DerivedDefinition::Ptr > (that.value); break; - case 127: // DirectCallExpression + case 129: // DirectCallExpression value.move< DirectCallExpression::Ptr > (that.value); break; - case 96: // EnumerationDefinition + case 97: // EnumerationDefinition value.move< EnumerationDefinition::Ptr > (that.value); break; - case 133: // ExistentialQuantifierExpression + case 135: // ExistentialQuantifierExpression value.move< ExistentialQuantifierExpression::Ptr > (that.value); break; - case 88: // MaybeDefined - case 111: // Atom - case 120: // Term - case 121: // Expression + case 89: // MaybeDefined + case 113: // Atom + case 122: // Term + case 123: // Expression value.move< Expression::Ptr > (that.value); break; - case 153: // ExpressionAttribute + case 155: // ExpressionAttribute value.move< ExpressionAttribute::Ptr > (that.value); break; - case 124: // Terms - case 125: // Arguments - case 126: // TwoOrMoreArguments + case 126: // Terms + case 127: // Arguments + case 128: // TwoOrMoreArguments value.move< Expressions::Ptr > (that.value); break; - case 109: // FixedSizedType + case 111: // FixedSizedType value.move< FixedSizedType::Ptr > (that.value); break; - case 143: // ForallRule + case 145: // ForallRule value.move< ForallRule::Ptr > (that.value); break; - case 86: // FunctionDefinition - case 91: // ProgramFunctionDefinition + case 87: // FunctionDefinition + case 92: // ProgramFunctionDefinition value.move< FunctionDefinition::Ptr > (that.value); break; - case 97: // Identifier + case 99: // Identifier value.move< Identifier::Ptr > (that.value); break; - case 100: // IdentifierPath + case 102: // IdentifierPath value.move< IdentifierPath::Ptr > (that.value); break; - case 98: // Identifiers - case 99: // DotSeparatedIdentifiers + case 100: // Identifiers + case 101: // DotSeparatedIdentifiers value.move< Identifiers::Ptr > (that.value); break; - case 128: // IndirectCallExpression + case 130: // IndirectCallExpression value.move< IndirectCallExpression::Ptr > (that.value); break; - case 145: // IterateRule + case 147: // IterateRule value.move< IterateRule::Ptr > (that.value); break; - case 129: // LetExpression + case 131: // LetExpression value.move< LetExpression::Ptr > (that.value); break; - case 142: // LetRule + case 144: // LetRule value.move< LetRule::Ptr > (that.value); break; - case 123: // List + case 125: // List value.move< ListExpression::Ptr > (that.value); break; - case 87: // MaybeInitially - case 93: // Initializers - case 94: // MaybeInitializers + case 88: // MaybeInitially + case 94: // Initializers + case 95: // MaybeInitializers value.move< NodeList< UpdateRule >::Ptr > (that.value); break; - case 103: // Parameters - case 104: // MaybeParameters + case 105: // Parameters + case 106: // MaybeParameters value.move< NodeList< VariableDefinition >::Ptr > (that.value); break; - case 122: // Range + case 124: // Range value.move< RangeExpression::Ptr > (that.value); break; - case 119: // Reference + case 121: // Reference value.move< ReferenceAtom::Ptr > (that.value); break; - case 108: // RelationType + case 110: // RelationType value.move< RelationType::Ptr > (that.value); break; - case 135: // Rule + case 137: // Rule value.move< Rule::Ptr > (that.value); break; - case 134: // RuleDefinition + case 136: // RuleDefinition value.move< RuleDefinition::Ptr > (that.value); break; - case 136: // Rules + case 138: // Rules value.move< Rules::Ptr > (that.value); break; - case 147: // SequenceRule + case 149: // SequenceRule value.move< SequenceRule::Ptr > (that.value); break; - case 137: // SkipRule + case 139: // SkipRule value.move< SkipRule::Ptr > (that.value); break; - case 82: // Specification + case 83: // Specification value.move< Specification::Ptr > (that.value); break; - case 105: // Type + case 107: // Type value.move< Type::Ptr > (that.value); break; - case 89: // FunctionParameters - case 90: // MaybeFunctionParameters - case 110: // Types + case 98: // TypeDefinition + value.move< TypeDefinition::Ptr > (that.value); + break; + + case 90: // FunctionParameters + case 91: // MaybeFunctionParameters + case 112: // Types value.move< Types::Ptr > (that.value); break; - case 112: // Undefined + case 114: // Undefined value.move< UndefAtom::Ptr > (that.value); break; - case 132: // UniversalQuantifierExpression + case 134: // UniversalQuantifierExpression value.move< UniversalQuantifierExpression::Ptr > (that.value); break; - case 92: // Initializer - case 148: // UpdateRule + case 93: // Initializer + case 150: // UpdateRule value.move< UpdateRule::Ptr > (that.value); break; - case 113: // Boolean - case 114: // String - case 115: // BitNumber - case 116: // IntegerNumber - case 117: // FloatingNumber - case 118: // RationalNumber + case 115: // Boolean + case 116: // String + case 117: // BitNumber + case 118: // IntegerNumber + case 119: // FloatingNumber + case 120: // RationalNumber value.move< ValueAtom::Ptr > (that.value); break; - case 101: // Variable - case 102: // AttributedVariable + case 103: // Variable + case 104: // AttributedVariable value.move< VariableDefinition::Ptr > (that.value); break; - case 70: // "binary" - case 71: // "hexadecimal" - case 72: // "integer" - case 73: // "rational" - case 74: // "floating" - case 75: // "string" - case 76: // "identifier" + case 71: // "binary" + case 72: // "hexadecimal" + case 73: // "integer" + case 74: // "rational" + case 75: // "floating" + case 76: // "string" + case 77: // "identifier" value.move< std::string > (that.value); break; @@ -581,241 +585,245 @@ namespace libcasm_fe { state = that.state; switch (that.type_get ()) { - case 150: // Attribute + case 152: // Attribute value.copy< Attribute::Ptr > (that.value); break; - case 151: // Attributes + case 153: // Attributes value.copy< Attributes::Ptr > (that.value); break; - case 152: // BasicAttribute + case 154: // BasicAttribute value.copy< BasicAttribute::Ptr > (that.value); break; - case 106: // BasicType + case 108: // BasicType value.copy< BasicType::Ptr > (that.value); break; - case 146: // BlockRule + case 148: // BlockRule value.copy< BlockRule::Ptr > (that.value); break; - case 149: // CallRule + case 151: // CallRule value.copy< CallRule::Ptr > (that.value); break; - case 140: // CaseLabel + case 142: // CaseLabel value.copy< Case::Ptr > (that.value); break; - case 139: // CaseRule + case 141: // CaseRule value.copy< CaseRule::Ptr > (that.value); break; - case 141: // CaseLabels + case 143: // CaseLabels value.copy< Cases::Ptr > (that.value); break; - case 131: // ChooseExpression + case 133: // ChooseExpression value.copy< ChooseExpression::Ptr > (that.value); break; - case 144: // ChooseRule + case 146: // ChooseRule value.copy< ChooseRule::Ptr > (that.value); break; - case 107: // ComposedType + case 109: // ComposedType value.copy< ComposedType::Ptr > (that.value); break; - case 130: // ConditionalExpression + case 132: // ConditionalExpression value.copy< ConditionalExpression::Ptr > (that.value); break; - case 138: // ConditionalRule + case 140: // ConditionalRule value.copy< ConditionalRule::Ptr > (that.value); break; - case 83: // Definition - case 84: // AttributedDefinition + case 84: // Definition + case 85: // AttributedDefinition value.copy< Definition::Ptr > (that.value); break; - case 85: // Definitions + case 86: // Definitions value.copy< Definitions::Ptr > (that.value); break; - case 95: // DerivedDefinition + case 96: // DerivedDefinition value.copy< DerivedDefinition::Ptr > (that.value); break; - case 127: // DirectCallExpression + case 129: // DirectCallExpression value.copy< DirectCallExpression::Ptr > (that.value); break; - case 96: // EnumerationDefinition + case 97: // EnumerationDefinition value.copy< EnumerationDefinition::Ptr > (that.value); break; - case 133: // ExistentialQuantifierExpression + case 135: // ExistentialQuantifierExpression value.copy< ExistentialQuantifierExpression::Ptr > (that.value); break; - case 88: // MaybeDefined - case 111: // Atom - case 120: // Term - case 121: // Expression + case 89: // MaybeDefined + case 113: // Atom + case 122: // Term + case 123: // Expression value.copy< Expression::Ptr > (that.value); break; - case 153: // ExpressionAttribute + case 155: // ExpressionAttribute value.copy< ExpressionAttribute::Ptr > (that.value); break; - case 124: // Terms - case 125: // Arguments - case 126: // TwoOrMoreArguments + case 126: // Terms + case 127: // Arguments + case 128: // TwoOrMoreArguments value.copy< Expressions::Ptr > (that.value); break; - case 109: // FixedSizedType + case 111: // FixedSizedType value.copy< FixedSizedType::Ptr > (that.value); break; - case 143: // ForallRule + case 145: // ForallRule value.copy< ForallRule::Ptr > (that.value); break; - case 86: // FunctionDefinition - case 91: // ProgramFunctionDefinition + case 87: // FunctionDefinition + case 92: // ProgramFunctionDefinition value.copy< FunctionDefinition::Ptr > (that.value); break; - case 97: // Identifier + case 99: // Identifier value.copy< Identifier::Ptr > (that.value); break; - case 100: // IdentifierPath + case 102: // IdentifierPath value.copy< IdentifierPath::Ptr > (that.value); break; - case 98: // Identifiers - case 99: // DotSeparatedIdentifiers + case 100: // Identifiers + case 101: // DotSeparatedIdentifiers value.copy< Identifiers::Ptr > (that.value); break; - case 128: // IndirectCallExpression + case 130: // IndirectCallExpression value.copy< IndirectCallExpression::Ptr > (that.value); break; - case 145: // IterateRule + case 147: // IterateRule value.copy< IterateRule::Ptr > (that.value); break; - case 129: // LetExpression + case 131: // LetExpression value.copy< LetExpression::Ptr > (that.value); break; - case 142: // LetRule + case 144: // LetRule value.copy< LetRule::Ptr > (that.value); break; - case 123: // List + case 125: // List value.copy< ListExpression::Ptr > (that.value); break; - case 87: // MaybeInitially - case 93: // Initializers - case 94: // MaybeInitializers + case 88: // MaybeInitially + case 94: // Initializers + case 95: // MaybeInitializers value.copy< NodeList< UpdateRule >::Ptr > (that.value); break; - case 103: // Parameters - case 104: // MaybeParameters + case 105: // Parameters + case 106: // MaybeParameters value.copy< NodeList< VariableDefinition >::Ptr > (that.value); break; - case 122: // Range + case 124: // Range value.copy< RangeExpression::Ptr > (that.value); break; - case 119: // Reference + case 121: // Reference value.copy< ReferenceAtom::Ptr > (that.value); break; - case 108: // RelationType + case 110: // RelationType value.copy< RelationType::Ptr > (that.value); break; - case 135: // Rule + case 137: // Rule value.copy< Rule::Ptr > (that.value); break; - case 134: // RuleDefinition + case 136: // RuleDefinition value.copy< RuleDefinition::Ptr > (that.value); break; - case 136: // Rules + case 138: // Rules value.copy< Rules::Ptr > (that.value); break; - case 147: // SequenceRule + case 149: // SequenceRule value.copy< SequenceRule::Ptr > (that.value); break; - case 137: // SkipRule + case 139: // SkipRule value.copy< SkipRule::Ptr > (that.value); break; - case 82: // Specification + case 83: // Specification value.copy< Specification::Ptr > (that.value); break; - case 105: // Type + case 107: // Type value.copy< Type::Ptr > (that.value); break; - case 89: // FunctionParameters - case 90: // MaybeFunctionParameters - case 110: // Types + case 98: // TypeDefinition + value.copy< TypeDefinition::Ptr > (that.value); + break; + + case 90: // FunctionParameters + case 91: // MaybeFunctionParameters + case 112: // Types value.copy< Types::Ptr > (that.value); break; - case 112: // Undefined + case 114: // Undefined value.copy< UndefAtom::Ptr > (that.value); break; - case 132: // UniversalQuantifierExpression + case 134: // UniversalQuantifierExpression value.copy< UniversalQuantifierExpression::Ptr > (that.value); break; - case 92: // Initializer - case 148: // UpdateRule + case 93: // Initializer + case 150: // UpdateRule value.copy< UpdateRule::Ptr > (that.value); break; - case 113: // Boolean - case 114: // String - case 115: // BitNumber - case 116: // IntegerNumber - case 117: // FloatingNumber - case 118: // RationalNumber + case 115: // Boolean + case 116: // String + case 117: // BitNumber + case 118: // IntegerNumber + case 119: // FloatingNumber + case 120: // RationalNumber value.copy< ValueAtom::Ptr > (that.value); break; - case 101: // Variable - case 102: // AttributedVariable + case 103: // Variable + case 104: // AttributedVariable value.copy< VariableDefinition::Ptr > (that.value); break; - case 70: // "binary" - case 71: // "hexadecimal" - case 72: // "integer" - case 73: // "rational" - case 74: // "floating" - case 75: // "string" - case 76: // "identifier" + case 71: // "binary" + case 72: // "hexadecimal" + case 73: // "integer" + case 74: // "rational" + case 75: // "floating" + case 76: // "string" + case 77: // "identifier" value.copy< std::string > (that.value); break; @@ -1047,241 +1055,245 @@ namespace libcasm_fe { when using variants. */ switch (yyr1_[yyn]) { - case 150: // Attribute + case 152: // Attribute yylhs.value.build< Attribute::Ptr > (); break; - case 151: // Attributes + case 153: // Attributes yylhs.value.build< Attributes::Ptr > (); break; - case 152: // BasicAttribute + case 154: // BasicAttribute yylhs.value.build< BasicAttribute::Ptr > (); break; - case 106: // BasicType + case 108: // BasicType yylhs.value.build< BasicType::Ptr > (); break; - case 146: // BlockRule + case 148: // BlockRule yylhs.value.build< BlockRule::Ptr > (); break; - case 149: // CallRule + case 151: // CallRule yylhs.value.build< CallRule::Ptr > (); break; - case 140: // CaseLabel + case 142: // CaseLabel yylhs.value.build< Case::Ptr > (); break; - case 139: // CaseRule + case 141: // CaseRule yylhs.value.build< CaseRule::Ptr > (); break; - case 141: // CaseLabels + case 143: // CaseLabels yylhs.value.build< Cases::Ptr > (); break; - case 131: // ChooseExpression + case 133: // ChooseExpression yylhs.value.build< ChooseExpression::Ptr > (); break; - case 144: // ChooseRule + case 146: // ChooseRule yylhs.value.build< ChooseRule::Ptr > (); break; - case 107: // ComposedType + case 109: // ComposedType yylhs.value.build< ComposedType::Ptr > (); break; - case 130: // ConditionalExpression + case 132: // ConditionalExpression yylhs.value.build< ConditionalExpression::Ptr > (); break; - case 138: // ConditionalRule + case 140: // ConditionalRule yylhs.value.build< ConditionalRule::Ptr > (); break; - case 83: // Definition - case 84: // AttributedDefinition + case 84: // Definition + case 85: // AttributedDefinition yylhs.value.build< Definition::Ptr > (); break; - case 85: // Definitions + case 86: // Definitions yylhs.value.build< Definitions::Ptr > (); break; - case 95: // DerivedDefinition + case 96: // DerivedDefinition yylhs.value.build< DerivedDefinition::Ptr > (); break; - case 127: // DirectCallExpression + case 129: // DirectCallExpression yylhs.value.build< DirectCallExpression::Ptr > (); break; - case 96: // EnumerationDefinition + case 97: // EnumerationDefinition yylhs.value.build< EnumerationDefinition::Ptr > (); break; - case 133: // ExistentialQuantifierExpression + case 135: // ExistentialQuantifierExpression yylhs.value.build< ExistentialQuantifierExpression::Ptr > (); break; - case 88: // MaybeDefined - case 111: // Atom - case 120: // Term - case 121: // Expression + case 89: // MaybeDefined + case 113: // Atom + case 122: // Term + case 123: // Expression yylhs.value.build< Expression::Ptr > (); break; - case 153: // ExpressionAttribute + case 155: // ExpressionAttribute yylhs.value.build< ExpressionAttribute::Ptr > (); break; - case 124: // Terms - case 125: // Arguments - case 126: // TwoOrMoreArguments + case 126: // Terms + case 127: // Arguments + case 128: // TwoOrMoreArguments yylhs.value.build< Expressions::Ptr > (); break; - case 109: // FixedSizedType + case 111: // FixedSizedType yylhs.value.build< FixedSizedType::Ptr > (); break; - case 143: // ForallRule + case 145: // ForallRule yylhs.value.build< ForallRule::Ptr > (); break; - case 86: // FunctionDefinition - case 91: // ProgramFunctionDefinition + case 87: // FunctionDefinition + case 92: // ProgramFunctionDefinition yylhs.value.build< FunctionDefinition::Ptr > (); break; - case 97: // Identifier + case 99: // Identifier yylhs.value.build< Identifier::Ptr > (); break; - case 100: // IdentifierPath + case 102: // IdentifierPath yylhs.value.build< IdentifierPath::Ptr > (); break; - case 98: // Identifiers - case 99: // DotSeparatedIdentifiers + case 100: // Identifiers + case 101: // DotSeparatedIdentifiers yylhs.value.build< Identifiers::Ptr > (); break; - case 128: // IndirectCallExpression + case 130: // IndirectCallExpression yylhs.value.build< IndirectCallExpression::Ptr > (); break; - case 145: // IterateRule + case 147: // IterateRule yylhs.value.build< IterateRule::Ptr > (); break; - case 129: // LetExpression + case 131: // LetExpression yylhs.value.build< LetExpression::Ptr > (); break; - case 142: // LetRule + case 144: // LetRule yylhs.value.build< LetRule::Ptr > (); break; - case 123: // List + case 125: // List yylhs.value.build< ListExpression::Ptr > (); break; - case 87: // MaybeInitially - case 93: // Initializers - case 94: // MaybeInitializers + case 88: // MaybeInitially + case 94: // Initializers + case 95: // MaybeInitializers yylhs.value.build< NodeList< UpdateRule >::Ptr > (); break; - case 103: // Parameters - case 104: // MaybeParameters + case 105: // Parameters + case 106: // MaybeParameters yylhs.value.build< NodeList< VariableDefinition >::Ptr > (); break; - case 122: // Range + case 124: // Range yylhs.value.build< RangeExpression::Ptr > (); break; - case 119: // Reference + case 121: // Reference yylhs.value.build< ReferenceAtom::Ptr > (); break; - case 108: // RelationType + case 110: // RelationType yylhs.value.build< RelationType::Ptr > (); break; - case 135: // Rule + case 137: // Rule yylhs.value.build< Rule::Ptr > (); break; - case 134: // RuleDefinition + case 136: // RuleDefinition yylhs.value.build< RuleDefinition::Ptr > (); break; - case 136: // Rules + case 138: // Rules yylhs.value.build< Rules::Ptr > (); break; - case 147: // SequenceRule + case 149: // SequenceRule yylhs.value.build< SequenceRule::Ptr > (); break; - case 137: // SkipRule + case 139: // SkipRule yylhs.value.build< SkipRule::Ptr > (); break; - case 82: // Specification + case 83: // Specification yylhs.value.build< Specification::Ptr > (); break; - case 105: // Type + case 107: // Type yylhs.value.build< Type::Ptr > (); break; - case 89: // FunctionParameters - case 90: // MaybeFunctionParameters - case 110: // Types + case 98: // TypeDefinition + yylhs.value.build< TypeDefinition::Ptr > (); + break; + + case 90: // FunctionParameters + case 91: // MaybeFunctionParameters + case 112: // Types yylhs.value.build< Types::Ptr > (); break; - case 112: // Undefined + case 114: // Undefined yylhs.value.build< UndefAtom::Ptr > (); break; - case 132: // UniversalQuantifierExpression + case 134: // UniversalQuantifierExpression yylhs.value.build< UniversalQuantifierExpression::Ptr > (); break; - case 92: // Initializer - case 148: // UpdateRule + case 93: // Initializer + case 150: // UpdateRule yylhs.value.build< UpdateRule::Ptr > (); break; - case 113: // Boolean - case 114: // String - case 115: // BitNumber - case 116: // IntegerNumber - case 117: // FloatingNumber - case 118: // RationalNumber + case 115: // Boolean + case 116: // String + case 117: // BitNumber + case 118: // IntegerNumber + case 119: // FloatingNumber + case 120: // RationalNumber yylhs.value.build< ValueAtom::Ptr > (); break; - case 101: // Variable - case 102: // AttributedVariable + case 103: // Variable + case 104: // AttributedVariable yylhs.value.build< VariableDefinition::Ptr > (); break; - case 70: // "binary" - case 71: // "hexadecimal" - case 72: // "integer" - case 73: // "rational" - case 74: // "floating" - case 75: // "string" - case 76: // "identifier" + case 71: // "binary" + case 72: // "hexadecimal" + case 73: // "integer" + case 74: // "rational" + case 75: // "floating" + case 76: // "string" + case 77: // "identifier" yylhs.value.build< std::string > (); break; @@ -1303,7 +1315,7 @@ namespace libcasm_fe { switch (yyn) { case 2: -#line 351 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 +#line 353 "../../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( "." ) ); @@ -1311,89 +1323,97 @@ 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 1315 "GrammarParser.cpp" // lalr1.cc:859 +#line 1327 "GrammarParser.cpp" // lalr1.cc:859 break; case 3: -#line 363 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 +#line 365 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< FunctionDefinition::Ptr > (); } -#line 1323 "GrammarParser.cpp" // lalr1.cc:859 +#line 1335 "GrammarParser.cpp" // lalr1.cc:859 break; case 4: -#line 367 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 +#line 369 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< DerivedDefinition::Ptr > (); } -#line 1331 "GrammarParser.cpp" // lalr1.cc:859 +#line 1343 "GrammarParser.cpp" // lalr1.cc:859 break; case 5: -#line 371 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 +#line 373 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< RuleDefinition::Ptr > (); } -#line 1339 "GrammarParser.cpp" // lalr1.cc:859 +#line 1351 "GrammarParser.cpp" // lalr1.cc:859 break; case 6: -#line 375 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 +#line 377 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< EnumerationDefinition::Ptr > (); } -#line 1347 "GrammarParser.cpp" // lalr1.cc:859 +#line 1359 "GrammarParser.cpp" // lalr1.cc:859 break; case 7: -#line 379 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 +#line 381 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { - yylhs.value.as< Definition::Ptr > () = nullptr; + yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< TypeDefinition::Ptr > (); } -#line 1355 "GrammarParser.cpp" // lalr1.cc:859 +#line 1367 "GrammarParser.cpp" // lalr1.cc:859 break; case 8: -#line 387 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 +#line 385 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + { + yylhs.value.as< Definition::Ptr > () = nullptr; + } +#line 1375 "GrammarParser.cpp" // lalr1.cc:859 + break; + + case 9: +#line 393 "../../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 1365 "GrammarParser.cpp" // lalr1.cc:859 +#line 1385 "GrammarParser.cpp" // lalr1.cc:859 break; - case 9: -#line 393 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 10: +#line 399 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< Definition::Ptr > (); } -#line 1373 "GrammarParser.cpp" // lalr1.cc:859 +#line 1393 "GrammarParser.cpp" // lalr1.cc:859 break; - case 10: -#line 401 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 11: +#line 407 "../../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 1383 "GrammarParser.cpp" // lalr1.cc:859 +#line 1403 "GrammarParser.cpp" // lalr1.cc:859 break; - case 11: -#line 407 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 12: +#line 413 "../../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 1393 "GrammarParser.cpp" // lalr1.cc:859 +#line 1413 "GrammarParser.cpp" // lalr1.cc:859 break; - case 12: -#line 417 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 13: +#line 423 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { const auto identifier = yystack_[6].value.as< Identifier::Ptr > (); @@ -1409,87 +1429,87 @@ namespace libcasm_fe { yylhs.value.as< FunctionDefinition::Ptr > () = function; } -#line 1413 "GrammarParser.cpp" // lalr1.cc:859 +#line 1433 "GrammarParser.cpp" // lalr1.cc:859 break; - case 13: -#line 433 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 14: +#line 439 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< FunctionDefinition::Ptr > () = yystack_[0].value.as< FunctionDefinition::Ptr > (); // `init` special case } -#line 1421 "GrammarParser.cpp" // lalr1.cc:859 +#line 1441 "GrammarParser.cpp" // lalr1.cc:859 break; - case 14: -#line 441 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 15: +#line 447 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< NodeList< UpdateRule >::Ptr > () = yystack_[1].value.as< NodeList< UpdateRule >::Ptr > (); } -#line 1429 "GrammarParser.cpp" // lalr1.cc:859 +#line 1449 "GrammarParser.cpp" // lalr1.cc:859 break; - case 15: -#line 445 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 16: +#line 451 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< NodeList< UpdateRule >::Ptr > () = Ast::make< NodeList< UpdateRule > >( yylhs.location ); } -#line 1437 "GrammarParser.cpp" // lalr1.cc:859 +#line 1457 "GrammarParser.cpp" // lalr1.cc:859 break; - case 16: -#line 453 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 17: +#line 459 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[1].value.as< Expression::Ptr > (); } -#line 1445 "GrammarParser.cpp" // lalr1.cc:859 +#line 1465 "GrammarParser.cpp" // lalr1.cc:859 break; - case 17: -#line 457 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 18: +#line 463 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = Ast::make< UndefAtom >( yylhs.location ); } -#line 1453 "GrammarParser.cpp" // lalr1.cc:859 +#line 1473 "GrammarParser.cpp" // lalr1.cc:859 break; - case 18: -#line 465 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 19: +#line 471 "../../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 1463 "GrammarParser.cpp" // lalr1.cc:859 +#line 1483 "GrammarParser.cpp" // lalr1.cc:859 break; - case 19: -#line 471 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 20: +#line 477 "../../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 1473 "GrammarParser.cpp" // lalr1.cc:859 +#line 1493 "GrammarParser.cpp" // lalr1.cc:859 break; - case 20: -#line 481 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 21: +#line 487 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Types::Ptr > () = yystack_[0].value.as< Types::Ptr > (); } -#line 1481 "GrammarParser.cpp" // lalr1.cc:859 +#line 1501 "GrammarParser.cpp" // lalr1.cc:859 break; - case 21: -#line 485 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 22: +#line 491 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Types::Ptr > () = Ast::make< Types >( yylhs.location ); } -#line 1489 "GrammarParser.cpp" // lalr1.cc:859 +#line 1509 "GrammarParser.cpp" // lalr1.cc:859 break; - case 22: -#line 493 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 23: +#line 499 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { const auto singleAgentIdentifier = Ast::make< Identifier >( yylhs.location, "$" ); auto singleAgentArguments = libcasm_fe::Ast::make< Expressions >( yylhs.location ); @@ -1512,11 +1532,11 @@ namespace libcasm_fe { yylhs.value.as< FunctionDefinition::Ptr > () = programDefinition; } -#line 1516 "GrammarParser.cpp" // lalr1.cc:859 +#line 1536 "GrammarParser.cpp" // lalr1.cc:859 break; - case 23: -#line 516 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 24: +#line 522 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto programDefinition = createProgramFunction( yylhs.location ); @@ -1530,11 +1550,11 @@ namespace libcasm_fe { yylhs.value.as< FunctionDefinition::Ptr > () = programDefinition; } -#line 1534 "GrammarParser.cpp" // lalr1.cc:859 +#line 1554 "GrammarParser.cpp" // lalr1.cc:859 break; - case 24: -#line 534 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 25: +#line 540 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { // the unknown function identifier will be replaced in FunctionDefinition const auto arguments = Ast::make< Expressions >( yylhs.location ); @@ -1542,11 +1562,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 1546 "GrammarParser.cpp" // lalr1.cc:859 +#line 1566 "GrammarParser.cpp" // lalr1.cc:859 break; - case 25: -#line 542 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 26: +#line 548 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { auto arguments = Ast::make< Expressions >( yylhs.location ); arguments->add( yystack_[2].value.as< Expression::Ptr > () ); @@ -1556,399 +1576,407 @@ 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 1560 "GrammarParser.cpp" // lalr1.cc:859 +#line 1580 "GrammarParser.cpp" // lalr1.cc:859 break; - case 26: -#line 552 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 27: +#line 558 "../../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 1571 "GrammarParser.cpp" // lalr1.cc:859 +#line 1591 "GrammarParser.cpp" // lalr1.cc:859 break; - case 27: -#line 563 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 28: +#line 569 "../../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 1581 "GrammarParser.cpp" // lalr1.cc:859 +#line 1601 "GrammarParser.cpp" // lalr1.cc:859 break; - case 28: -#line 569 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 29: +#line 575 "../../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 1591 "GrammarParser.cpp" // lalr1.cc:859 +#line 1611 "GrammarParser.cpp" // lalr1.cc:859 break; - case 29: -#line 579 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 30: +#line 585 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< NodeList< UpdateRule >::Ptr > () = yystack_[0].value.as< NodeList< UpdateRule >::Ptr > (); } -#line 1599 "GrammarParser.cpp" // lalr1.cc:859 +#line 1619 "GrammarParser.cpp" // lalr1.cc:859 break; - case 30: -#line 583 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 31: +#line 589 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< NodeList< UpdateRule >::Ptr > () = Ast::make< NodeList< UpdateRule > >( yylhs.location ); } -#line 1607 "GrammarParser.cpp" // lalr1.cc:859 +#line 1627 "GrammarParser.cpp" // lalr1.cc:859 break; - case 31: -#line 591 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 32: +#line 597 "../../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 1615 "GrammarParser.cpp" // lalr1.cc:859 +#line 1635 "GrammarParser.cpp" // lalr1.cc:859 break; - case 32: -#line 599 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 33: +#line 605 "../../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 1623 "GrammarParser.cpp" // lalr1.cc:859 +#line 1643 "GrammarParser.cpp" // lalr1.cc:859 break; - case 33: -#line 607 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 34: +#line 613 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + { + yylhs.value.as< TypeDefinition::Ptr > () = Ast::make< TypeDefinition >( yylhs.location, yystack_[2].value.as< Identifier::Ptr > (), yystack_[0].value.as< Type::Ptr > () ); + } +#line 1651 "GrammarParser.cpp" // lalr1.cc:859 + break; + + case 35: +#line 621 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Identifier::Ptr > () = Ast::make< Identifier >( yylhs.location, yystack_[0].value.as< std::string > () ); } -#line 1631 "GrammarParser.cpp" // lalr1.cc:859 +#line 1659 "GrammarParser.cpp" // lalr1.cc:859 break; - case 34: -#line 611 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 36: +#line 625 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Identifier::Ptr > () = Ast::make< Identifier >( yylhs.location, "in" ); } -#line 1639 "GrammarParser.cpp" // lalr1.cc:859 +#line 1667 "GrammarParser.cpp" // lalr1.cc:859 break; - case 35: -#line 619 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 37: +#line 633 "../../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 1649 "GrammarParser.cpp" // lalr1.cc:859 +#line 1677 "GrammarParser.cpp" // lalr1.cc:859 break; - case 36: -#line 625 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 38: +#line 639 "../../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 1659 "GrammarParser.cpp" // lalr1.cc:859 +#line 1687 "GrammarParser.cpp" // lalr1.cc:859 break; - case 37: -#line 635 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 39: +#line 649 "../../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 1669 "GrammarParser.cpp" // lalr1.cc:859 +#line 1697 "GrammarParser.cpp" // lalr1.cc:859 break; - case 38: -#line 641 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 40: +#line 655 "../../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 1679 "GrammarParser.cpp" // lalr1.cc:859 +#line 1707 "GrammarParser.cpp" // lalr1.cc:859 break; - case 39: -#line 651 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 41: +#line 665 "../../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 1687 "GrammarParser.cpp" // lalr1.cc:859 +#line 1715 "GrammarParser.cpp" // lalr1.cc:859 break; - case 40: -#line 655 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 42: +#line 669 "../../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 1695 "GrammarParser.cpp" // lalr1.cc:859 +#line 1723 "GrammarParser.cpp" // lalr1.cc:859 break; - case 41: -#line 663 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 43: +#line 677 "../../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 1703 "GrammarParser.cpp" // lalr1.cc:859 +#line 1731 "GrammarParser.cpp" // lalr1.cc:859 break; - case 42: -#line 667 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 44: +#line 681 "../../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 1712 "GrammarParser.cpp" // lalr1.cc:859 +#line 1740 "GrammarParser.cpp" // lalr1.cc:859 break; - case 43: -#line 676 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 45: +#line 690 "../../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 1722 "GrammarParser.cpp" // lalr1.cc:859 +#line 1750 "GrammarParser.cpp" // lalr1.cc:859 break; - case 44: -#line 682 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 46: +#line 696 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< VariableDefinition::Ptr > () = yystack_[0].value.as< VariableDefinition::Ptr > (); } -#line 1730 "GrammarParser.cpp" // lalr1.cc:859 +#line 1758 "GrammarParser.cpp" // lalr1.cc:859 break; - case 45: -#line 690 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 47: +#line 704 "../../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 1740 "GrammarParser.cpp" // lalr1.cc:859 +#line 1768 "GrammarParser.cpp" // lalr1.cc:859 break; - case 46: -#line 696 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 48: +#line 710 "../../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 1750 "GrammarParser.cpp" // lalr1.cc:859 +#line 1778 "GrammarParser.cpp" // lalr1.cc:859 break; - case 47: -#line 706 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 49: +#line 720 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< NodeList< VariableDefinition >::Ptr > () = yystack_[1].value.as< NodeList< VariableDefinition >::Ptr > (); } -#line 1758 "GrammarParser.cpp" // lalr1.cc:859 +#line 1786 "GrammarParser.cpp" // lalr1.cc:859 break; - case 48: -#line 710 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 50: +#line 724 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< NodeList< VariableDefinition >::Ptr > () = nullptr; } -#line 1766 "GrammarParser.cpp" // lalr1.cc:859 +#line 1794 "GrammarParser.cpp" // lalr1.cc:859 break; - case 49: -#line 714 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 51: +#line 728 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< NodeList< VariableDefinition >::Ptr > () = Ast::make< NodeList< VariableDefinition > >( yylhs.location ); } -#line 1774 "GrammarParser.cpp" // lalr1.cc:859 +#line 1802 "GrammarParser.cpp" // lalr1.cc:859 break; - case 50: -#line 722 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 52: +#line 736 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Type::Ptr > () = yystack_[0].value.as< BasicType::Ptr > (); } -#line 1782 "GrammarParser.cpp" // lalr1.cc:859 +#line 1810 "GrammarParser.cpp" // lalr1.cc:859 break; - case 51: -#line 726 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 53: +#line 740 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Type::Ptr > () = yystack_[0].value.as< ComposedType::Ptr > (); } -#line 1790 "GrammarParser.cpp" // lalr1.cc:859 +#line 1818 "GrammarParser.cpp" // lalr1.cc:859 break; - case 52: -#line 730 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 54: +#line 744 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Type::Ptr > () = yystack_[0].value.as< RelationType::Ptr > (); } -#line 1798 "GrammarParser.cpp" // lalr1.cc:859 +#line 1826 "GrammarParser.cpp" // lalr1.cc:859 break; - case 53: -#line 734 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 55: +#line 748 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Type::Ptr > () = yystack_[0].value.as< FixedSizedType::Ptr > (); } -#line 1806 "GrammarParser.cpp" // lalr1.cc:859 +#line 1834 "GrammarParser.cpp" // lalr1.cc:859 break; - case 54: -#line 742 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 56: +#line 756 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< BasicType::Ptr > () = Ast::make< BasicType >( yylhs.location, yystack_[0].value.as< IdentifierPath::Ptr > () ); } -#line 1814 "GrammarParser.cpp" // lalr1.cc:859 +#line 1842 "GrammarParser.cpp" // lalr1.cc:859 break; - case 55: -#line 750 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 57: +#line 764 "../../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 1822 "GrammarParser.cpp" // lalr1.cc:859 +#line 1850 "GrammarParser.cpp" // lalr1.cc:859 break; - case 56: -#line 758 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 58: +#line 772 "../../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 1830 "GrammarParser.cpp" // lalr1.cc:859 +#line 1858 "GrammarParser.cpp" // lalr1.cc:859 break; - case 57: -#line 766 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 59: +#line 780 "../../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 1838 "GrammarParser.cpp" // lalr1.cc:859 +#line 1866 "GrammarParser.cpp" // lalr1.cc:859 break; - case 58: -#line 774 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 60: +#line 788 "../../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 1848 "GrammarParser.cpp" // lalr1.cc:859 +#line 1876 "GrammarParser.cpp" // lalr1.cc:859 break; - case 59: -#line 780 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 61: +#line 794 "../../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 1858 "GrammarParser.cpp" // lalr1.cc:859 +#line 1886 "GrammarParser.cpp" // lalr1.cc:859 break; - case 60: -#line 790 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 62: +#line 804 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ReferenceAtom::Ptr > (); } -#line 1866 "GrammarParser.cpp" // lalr1.cc:859 +#line 1894 "GrammarParser.cpp" // lalr1.cc:859 break; - case 61: -#line 794 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 63: +#line 808 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ValueAtom::Ptr > (); } -#line 1874 "GrammarParser.cpp" // lalr1.cc:859 +#line 1902 "GrammarParser.cpp" // lalr1.cc:859 break; - case 62: -#line 798 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 64: +#line 812 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ValueAtom::Ptr > (); } -#line 1882 "GrammarParser.cpp" // lalr1.cc:859 +#line 1910 "GrammarParser.cpp" // lalr1.cc:859 break; - case 63: -#line 802 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 65: +#line 816 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ValueAtom::Ptr > (); } -#line 1890 "GrammarParser.cpp" // lalr1.cc:859 +#line 1918 "GrammarParser.cpp" // lalr1.cc:859 break; - case 64: -#line 806 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 66: +#line 820 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ValueAtom::Ptr > (); } -#line 1898 "GrammarParser.cpp" // lalr1.cc:859 +#line 1926 "GrammarParser.cpp" // lalr1.cc:859 break; - case 65: -#line 810 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 67: +#line 824 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ValueAtom::Ptr > (); } -#line 1906 "GrammarParser.cpp" // lalr1.cc:859 +#line 1934 "GrammarParser.cpp" // lalr1.cc:859 break; - case 66: -#line 814 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 68: +#line 828 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< UndefAtom::Ptr > (); } -#line 1914 "GrammarParser.cpp" // lalr1.cc:859 +#line 1942 "GrammarParser.cpp" // lalr1.cc:859 break; - case 67: -#line 818 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 69: +#line 832 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ValueAtom::Ptr > (); } -#line 1922 "GrammarParser.cpp" // lalr1.cc:859 +#line 1950 "GrammarParser.cpp" // lalr1.cc:859 break; - case 68: -#line 826 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 70: +#line 840 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< UndefAtom::Ptr > () = Ast::make< UndefAtom >( yylhs.location ); } -#line 1930 "GrammarParser.cpp" // lalr1.cc:859 +#line 1958 "GrammarParser.cpp" // lalr1.cc:859 break; - case 69: -#line 834 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 71: +#line 848 "../../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 1939 "GrammarParser.cpp" // lalr1.cc:859 +#line 1967 "GrammarParser.cpp" // lalr1.cc:859 break; - case 70: -#line 839 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 72: +#line 853 "../../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 1948 "GrammarParser.cpp" // lalr1.cc:859 +#line 1976 "GrammarParser.cpp" // lalr1.cc:859 break; - case 71: -#line 848 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 73: +#line 862 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { try { @@ -1960,11 +1988,11 @@ namespace libcasm_fe { throw syntax_error( yylhs.location, e.what() ); } } -#line 1964 "GrammarParser.cpp" // lalr1.cc:859 +#line 1992 "GrammarParser.cpp" // lalr1.cc:859 break; - case 72: -#line 864 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 74: +#line 878 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { try { @@ -1976,11 +2004,11 @@ namespace libcasm_fe { throw syntax_error( yylhs.location, e.what() ); } } -#line 1980 "GrammarParser.cpp" // lalr1.cc:859 +#line 2008 "GrammarParser.cpp" // lalr1.cc:859 break; - case 73: -#line 876 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 75: +#line 890 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { try { @@ -1992,11 +2020,11 @@ namespace libcasm_fe { throw syntax_error( yylhs.location, e.what() ); } } -#line 1996 "GrammarParser.cpp" // lalr1.cc:859 +#line 2024 "GrammarParser.cpp" // lalr1.cc:859 break; - case 74: -#line 892 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 76: +#line 906 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { try { @@ -2008,11 +2036,11 @@ namespace libcasm_fe { throw syntax_error( yylhs.location, e.what() ); } } -#line 2012 "GrammarParser.cpp" // lalr1.cc:859 +#line 2040 "GrammarParser.cpp" // lalr1.cc:859 break; - case 75: -#line 908 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 77: +#line 922 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { try { @@ -2024,11 +2052,11 @@ namespace libcasm_fe { throw syntax_error( yylhs.location, e.what() ); } } -#line 2028 "GrammarParser.cpp" // lalr1.cc:859 +#line 2056 "GrammarParser.cpp" // lalr1.cc:859 break; - case 76: -#line 924 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 78: +#line 938 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { try { @@ -2040,850 +2068,850 @@ namespace libcasm_fe { throw syntax_error( yylhs.location, e.what() ); } } -#line 2044 "GrammarParser.cpp" // lalr1.cc:859 +#line 2072 "GrammarParser.cpp" // lalr1.cc:859 break; - case 77: -#line 940 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 79: +#line 954 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< ReferenceAtom::Ptr > () = Ast::make< ReferenceAtom >( yylhs.location, yystack_[0].value.as< IdentifierPath::Ptr > () ); } -#line 2052 "GrammarParser.cpp" // lalr1.cc:859 +#line 2080 "GrammarParser.cpp" // lalr1.cc:859 break; - case 78: -#line 948 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 80: +#line 962 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< DirectCallExpression::Ptr > (); } -#line 2060 "GrammarParser.cpp" // lalr1.cc:859 +#line 2088 "GrammarParser.cpp" // lalr1.cc:859 break; - case 79: -#line 952 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 81: +#line 966 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< IndirectCallExpression::Ptr > (); } -#line 2068 "GrammarParser.cpp" // lalr1.cc:859 +#line 2096 "GrammarParser.cpp" // lalr1.cc:859 break; - case 80: -#line 956 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 82: +#line 970 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< LetExpression::Ptr > (); } -#line 2076 "GrammarParser.cpp" // lalr1.cc:859 +#line 2104 "GrammarParser.cpp" // lalr1.cc:859 break; - case 81: -#line 960 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 83: +#line 974 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ConditionalExpression::Ptr > (); } -#line 2084 "GrammarParser.cpp" // lalr1.cc:859 +#line 2112 "GrammarParser.cpp" // lalr1.cc:859 break; - case 82: -#line 964 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 84: +#line 978 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ChooseExpression::Ptr > (); } -#line 2092 "GrammarParser.cpp" // lalr1.cc:859 +#line 2120 "GrammarParser.cpp" // lalr1.cc:859 break; - case 83: -#line 968 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 85: +#line 982 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< UniversalQuantifierExpression::Ptr > (); } -#line 2100 "GrammarParser.cpp" // lalr1.cc:859 +#line 2128 "GrammarParser.cpp" // lalr1.cc:859 break; - case 84: -#line 972 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 86: +#line 986 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ExistentialQuantifierExpression::Ptr > (); } -#line 2108 "GrammarParser.cpp" // lalr1.cc:859 +#line 2136 "GrammarParser.cpp" // lalr1.cc:859 break; - case 85: -#line 976 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 87: +#line 990 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< Expression::Ptr > (); } -#line 2116 "GrammarParser.cpp" // lalr1.cc:859 +#line 2144 "GrammarParser.cpp" // lalr1.cc:859 break; - case 86: -#line 980 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 88: +#line 994 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ListExpression::Ptr > (); } -#line 2124 "GrammarParser.cpp" // lalr1.cc:859 +#line 2152 "GrammarParser.cpp" // lalr1.cc:859 break; - case 87: -#line 984 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 89: +#line 998 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< RangeExpression::Ptr > (); } -#line 2132 "GrammarParser.cpp" // lalr1.cc:859 +#line 2160 "GrammarParser.cpp" // lalr1.cc:859 break; - case 88: -#line 988 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 90: +#line 1002 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< Expression::Ptr > (); } -#line 2140 "GrammarParser.cpp" // lalr1.cc:859 +#line 2168 "GrammarParser.cpp" // lalr1.cc:859 break; - case 89: -#line 996 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 91: +#line 1010 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[1].value.as< Expression::Ptr > (); } -#line 2148 "GrammarParser.cpp" // lalr1.cc:859 +#line 2176 "GrammarParser.cpp" // lalr1.cc:859 break; - case 90: -#line 1000 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 92: +#line 1014 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = nullptr; } -#line 2156 "GrammarParser.cpp" // lalr1.cc:859 +#line 2184 "GrammarParser.cpp" // lalr1.cc:859 break; - case 91: -#line 1004 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 93: +#line 1018 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< Expression::Ptr > (); } -#line 2164 "GrammarParser.cpp" // lalr1.cc:859 +#line 2192 "GrammarParser.cpp" // lalr1.cc:859 break; - case 92: -#line 1008 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 94: +#line 1022 "../../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 2172 "GrammarParser.cpp" // lalr1.cc:859 +#line 2200 "GrammarParser.cpp" // lalr1.cc:859 break; - case 93: -#line 1012 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 95: +#line 1026 "../../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 2180 "GrammarParser.cpp" // lalr1.cc:859 +#line 2208 "GrammarParser.cpp" // lalr1.cc:859 break; - case 94: -#line 1016 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 96: +#line 1030 "../../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 2188 "GrammarParser.cpp" // lalr1.cc:859 +#line 2216 "GrammarParser.cpp" // lalr1.cc:859 break; - case 95: -#line 1020 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 97: +#line 1034 "../../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 2196 "GrammarParser.cpp" // lalr1.cc:859 +#line 2224 "GrammarParser.cpp" // lalr1.cc:859 break; - case 96: -#line 1024 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 98: +#line 1038 "../../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 2204 "GrammarParser.cpp" // lalr1.cc:859 +#line 2232 "GrammarParser.cpp" // lalr1.cc:859 break; - case 97: -#line 1028 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 99: +#line 1042 "../../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 2212 "GrammarParser.cpp" // lalr1.cc:859 +#line 2240 "GrammarParser.cpp" // lalr1.cc:859 break; - case 98: -#line 1032 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 100: +#line 1046 "../../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 2220 "GrammarParser.cpp" // lalr1.cc:859 +#line 2248 "GrammarParser.cpp" // lalr1.cc:859 break; - case 99: -#line 1036 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 101: +#line 1050 "../../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 2228 "GrammarParser.cpp" // lalr1.cc:859 +#line 2256 "GrammarParser.cpp" // lalr1.cc:859 break; - case 100: -#line 1040 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 102: +#line 1054 "../../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 2236 "GrammarParser.cpp" // lalr1.cc:859 +#line 2264 "GrammarParser.cpp" // lalr1.cc:859 break; - case 101: -#line 1044 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 103: +#line 1058 "../../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 2244 "GrammarParser.cpp" // lalr1.cc:859 +#line 2272 "GrammarParser.cpp" // lalr1.cc:859 break; - case 102: -#line 1048 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 104: +#line 1062 "../../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 2252 "GrammarParser.cpp" // lalr1.cc:859 +#line 2280 "GrammarParser.cpp" // lalr1.cc:859 break; - case 103: -#line 1052 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 105: +#line 1066 "../../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 2260 "GrammarParser.cpp" // lalr1.cc:859 +#line 2288 "GrammarParser.cpp" // lalr1.cc:859 break; - case 104: -#line 1056 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 106: +#line 1070 "../../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 2268 "GrammarParser.cpp" // lalr1.cc:859 +#line 2296 "GrammarParser.cpp" // lalr1.cc:859 break; - case 105: -#line 1060 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 107: +#line 1074 "../../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 2276 "GrammarParser.cpp" // lalr1.cc:859 +#line 2304 "GrammarParser.cpp" // lalr1.cc:859 break; - case 106: -#line 1064 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 108: +#line 1078 "../../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 2284 "GrammarParser.cpp" // lalr1.cc:859 +#line 2312 "GrammarParser.cpp" // lalr1.cc:859 break; - case 107: -#line 1068 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 109: +#line 1082 "../../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 2292 "GrammarParser.cpp" // lalr1.cc:859 +#line 2320 "GrammarParser.cpp" // lalr1.cc:859 break; - case 108: -#line 1072 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 110: +#line 1086 "../../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 2300 "GrammarParser.cpp" // lalr1.cc:859 +#line 2328 "GrammarParser.cpp" // lalr1.cc:859 break; - case 109: -#line 1076 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 111: +#line 1090 "../../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 2308 "GrammarParser.cpp" // lalr1.cc:859 +#line 2336 "GrammarParser.cpp" // lalr1.cc:859 break; - case 110: -#line 1080 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 112: +#line 1094 "../../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 2316 "GrammarParser.cpp" // lalr1.cc:859 +#line 2344 "GrammarParser.cpp" // lalr1.cc:859 break; - case 111: -#line 1088 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 113: +#line 1102 "../../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 2324 "GrammarParser.cpp" // lalr1.cc:859 +#line 2352 "GrammarParser.cpp" // lalr1.cc:859 break; - case 112: -#line 1096 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 114: +#line 1110 "../../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 2333 "GrammarParser.cpp" // lalr1.cc:859 +#line 2361 "GrammarParser.cpp" // lalr1.cc:859 break; - case 113: -#line 1101 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 115: +#line 1115 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< ListExpression::Ptr > () = Ast::make< ListExpression >( yylhs.location, yystack_[1].value.as< Expressions::Ptr > () ); } -#line 2341 "GrammarParser.cpp" // lalr1.cc:859 +#line 2369 "GrammarParser.cpp" // lalr1.cc:859 break; - case 114: -#line 1105 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 116: +#line 1119 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< ListExpression::Ptr > () = nullptr; } -#line 2349 "GrammarParser.cpp" // lalr1.cc:859 +#line 2377 "GrammarParser.cpp" // lalr1.cc:859 break; - case 115: -#line 1113 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 117: +#line 1127 "../../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 2359 "GrammarParser.cpp" // lalr1.cc:859 +#line 2387 "GrammarParser.cpp" // lalr1.cc:859 break; - case 116: -#line 1119 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 118: +#line 1133 "../../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 2369 "GrammarParser.cpp" // lalr1.cc:859 +#line 2397 "GrammarParser.cpp" // lalr1.cc:859 break; - case 117: -#line 1129 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 119: +#line 1143 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expressions::Ptr > () = yystack_[1].value.as< Expressions::Ptr > (); } -#line 2377 "GrammarParser.cpp" // lalr1.cc:859 +#line 2405 "GrammarParser.cpp" // lalr1.cc:859 break; - case 118: -#line 1133 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 120: +#line 1147 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Expressions::Ptr > () = nullptr; } -#line 2385 "GrammarParser.cpp" // lalr1.cc:859 +#line 2413 "GrammarParser.cpp" // lalr1.cc:859 break; - case 119: -#line 1137 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 121: +#line 1151 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { const auto expressions = Ast::make< Expressions >( yylhs.location ); yylhs.value.as< Expressions::Ptr > () = expressions; } -#line 2394 "GrammarParser.cpp" // lalr1.cc:859 +#line 2422 "GrammarParser.cpp" // lalr1.cc:859 break; - case 120: -#line 1146 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 122: +#line 1160 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { const auto expressions = yystack_[1].value.as< Expressions::Ptr > (); expressions->add( yystack_[3].value.as< Expression::Ptr > () ); yylhs.value.as< Expressions::Ptr > () = expressions; } -#line 2404 "GrammarParser.cpp" // lalr1.cc:859 +#line 2432 "GrammarParser.cpp" // lalr1.cc:859 break; - case 121: -#line 1156 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 123: +#line 1170 "../../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 2413 "GrammarParser.cpp" // lalr1.cc:859 +#line 2441 "GrammarParser.cpp" // lalr1.cc:859 break; - case 122: -#line 1161 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 124: +#line 1175 "../../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 2421 "GrammarParser.cpp" // lalr1.cc:859 +#line 2449 "GrammarParser.cpp" // lalr1.cc:859 break; - case 123: -#line 1169 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 125: +#line 1183 "../../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 2429 "GrammarParser.cpp" // lalr1.cc:859 +#line 2457 "GrammarParser.cpp" // lalr1.cc:859 break; - case 124: -#line 1177 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 126: +#line 1191 "../../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 2437 "GrammarParser.cpp" // lalr1.cc:859 +#line 2465 "GrammarParser.cpp" // lalr1.cc:859 break; - case 125: -#line 1185 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 127: +#line 1199 "../../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 2445 "GrammarParser.cpp" // lalr1.cc:859 +#line 2473 "GrammarParser.cpp" // lalr1.cc:859 break; - case 126: -#line 1193 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 128: +#line 1207 "../../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 2453 "GrammarParser.cpp" // lalr1.cc:859 +#line 2481 "GrammarParser.cpp" // lalr1.cc:859 break; - case 127: -#line 1201 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 129: +#line 1215 "../../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 2461 "GrammarParser.cpp" // lalr1.cc:859 +#line 2489 "GrammarParser.cpp" // lalr1.cc:859 break; - case 128: -#line 1209 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 130: +#line 1223 "../../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 2469 "GrammarParser.cpp" // lalr1.cc:859 +#line 2497 "GrammarParser.cpp" // lalr1.cc:859 break; - case 129: -#line 1217 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 131: +#line 1231 "../../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 2478 "GrammarParser.cpp" // lalr1.cc:859 +#line 2506 "GrammarParser.cpp" // lalr1.cc:859 break; - case 130: -#line 1222 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 132: +#line 1236 "../../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 2487 "GrammarParser.cpp" // lalr1.cc:859 +#line 2515 "GrammarParser.cpp" // lalr1.cc:859 break; - case 131: -#line 1231 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 133: +#line 1245 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< SkipRule::Ptr > (); } -#line 2495 "GrammarParser.cpp" // lalr1.cc:859 +#line 2523 "GrammarParser.cpp" // lalr1.cc:859 break; - case 132: -#line 1235 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 134: +#line 1249 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< ConditionalRule::Ptr > (); } -#line 2503 "GrammarParser.cpp" // lalr1.cc:859 +#line 2531 "GrammarParser.cpp" // lalr1.cc:859 break; - case 133: -#line 1239 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 135: +#line 1253 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< CaseRule::Ptr > (); } -#line 2511 "GrammarParser.cpp" // lalr1.cc:859 +#line 2539 "GrammarParser.cpp" // lalr1.cc:859 break; - case 134: -#line 1243 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 136: +#line 1257 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< LetRule::Ptr > (); } -#line 2519 "GrammarParser.cpp" // lalr1.cc:859 +#line 2547 "GrammarParser.cpp" // lalr1.cc:859 break; - case 135: -#line 1247 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 137: +#line 1261 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< ForallRule::Ptr > (); } -#line 2527 "GrammarParser.cpp" // lalr1.cc:859 +#line 2555 "GrammarParser.cpp" // lalr1.cc:859 break; - case 136: -#line 1251 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 138: +#line 1265 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< ChooseRule::Ptr > (); } -#line 2535 "GrammarParser.cpp" // lalr1.cc:859 +#line 2563 "GrammarParser.cpp" // lalr1.cc:859 break; - case 137: -#line 1255 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 139: +#line 1269 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< IterateRule::Ptr > (); } -#line 2543 "GrammarParser.cpp" // lalr1.cc:859 +#line 2571 "GrammarParser.cpp" // lalr1.cc:859 break; - case 138: -#line 1259 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 140: +#line 1273 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< BlockRule::Ptr > (); } -#line 2551 "GrammarParser.cpp" // lalr1.cc:859 +#line 2579 "GrammarParser.cpp" // lalr1.cc:859 break; - case 139: -#line 1263 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 141: +#line 1277 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< SequenceRule::Ptr > (); } -#line 2559 "GrammarParser.cpp" // lalr1.cc:859 +#line 2587 "GrammarParser.cpp" // lalr1.cc:859 break; - case 140: -#line 1267 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 142: +#line 1281 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< UpdateRule::Ptr > (); } -#line 2567 "GrammarParser.cpp" // lalr1.cc:859 +#line 2595 "GrammarParser.cpp" // lalr1.cc:859 break; - case 141: -#line 1271 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 143: +#line 1285 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< CallRule::Ptr > (); } -#line 2575 "GrammarParser.cpp" // lalr1.cc:859 +#line 2603 "GrammarParser.cpp" // lalr1.cc:859 break; - case 142: -#line 1279 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 144: +#line 1293 "../../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 2585 "GrammarParser.cpp" // lalr1.cc:859 +#line 2613 "GrammarParser.cpp" // lalr1.cc:859 break; - case 143: -#line 1285 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 145: +#line 1299 "../../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 2595 "GrammarParser.cpp" // lalr1.cc:859 +#line 2623 "GrammarParser.cpp" // lalr1.cc:859 break; - case 144: -#line 1295 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 146: +#line 1309 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< SkipRule::Ptr > () = Ast::make< SkipRule >( yylhs.location ); } -#line 2603 "GrammarParser.cpp" // lalr1.cc:859 +#line 2631 "GrammarParser.cpp" // lalr1.cc:859 break; - case 145: -#line 1303 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 147: +#line 1317 "../../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 2611 "GrammarParser.cpp" // lalr1.cc:859 +#line 2639 "GrammarParser.cpp" // lalr1.cc:859 break; - case 146: -#line 1307 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 148: +#line 1321 "../../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 2619 "GrammarParser.cpp" // lalr1.cc:859 +#line 2647 "GrammarParser.cpp" // lalr1.cc:859 break; - case 147: -#line 1315 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 149: +#line 1329 "../../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 2627 "GrammarParser.cpp" // lalr1.cc:859 +#line 2655 "GrammarParser.cpp" // lalr1.cc:859 break; - case 148: -#line 1319 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 150: +#line 1333 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< CaseRule::Ptr > () = nullptr; } -#line 2635 "GrammarParser.cpp" // lalr1.cc:859 +#line 2663 "GrammarParser.cpp" // lalr1.cc:859 break; - case 149: -#line 1327 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 151: +#line 1341 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Case::Ptr > () = Ast::make< DefaultCase >( yylhs.location, yystack_[0].value.as< Rule::Ptr > () ); } -#line 2643 "GrammarParser.cpp" // lalr1.cc:859 +#line 2671 "GrammarParser.cpp" // lalr1.cc:859 break; - case 150: -#line 1331 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 152: +#line 1345 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Case::Ptr > () = Ast::make< DefaultCase >( yylhs.location, yystack_[0].value.as< Rule::Ptr > () ); } -#line 2651 "GrammarParser.cpp" // lalr1.cc:859 +#line 2679 "GrammarParser.cpp" // lalr1.cc:859 break; - case 151: -#line 1335 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 153: +#line 1349 "../../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 2659 "GrammarParser.cpp" // lalr1.cc:859 +#line 2687 "GrammarParser.cpp" // lalr1.cc:859 break; - case 152: -#line 1343 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 154: +#line 1357 "../../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 2669 "GrammarParser.cpp" // lalr1.cc:859 +#line 2697 "GrammarParser.cpp" // lalr1.cc:859 break; - case 153: -#line 1349 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 155: +#line 1363 "../../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 2679 "GrammarParser.cpp" // lalr1.cc:859 +#line 2707 "GrammarParser.cpp" // lalr1.cc:859 break; - case 154: -#line 1359 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 156: +#line 1373 "../../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 2687 "GrammarParser.cpp" // lalr1.cc:859 +#line 2715 "GrammarParser.cpp" // lalr1.cc:859 break; - case 155: -#line 1367 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 157: +#line 1381 "../../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 2695 "GrammarParser.cpp" // lalr1.cc:859 +#line 2723 "GrammarParser.cpp" // lalr1.cc:859 break; - case 156: -#line 1375 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 158: +#line 1389 "../../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 2703 "GrammarParser.cpp" // lalr1.cc:859 +#line 2731 "GrammarParser.cpp" // lalr1.cc:859 break; - case 157: -#line 1383 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 159: +#line 1397 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< IterateRule::Ptr > () = Ast::make< IterateRule >( yylhs.location, yystack_[0].value.as< Rule::Ptr > () ); } -#line 2711 "GrammarParser.cpp" // lalr1.cc:859 +#line 2739 "GrammarParser.cpp" // lalr1.cc:859 break; - case 158: -#line 1391 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 160: +#line 1405 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< BlockRule::Ptr > () = Ast::make< BlockRule >( yylhs.location, yystack_[1].value.as< Rules::Ptr > () ); } -#line 2719 "GrammarParser.cpp" // lalr1.cc:859 +#line 2747 "GrammarParser.cpp" // lalr1.cc:859 break; - case 159: -#line 1395 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 161: +#line 1409 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< BlockRule::Ptr > () = Ast::make< BlockRule >( yylhs.location, yystack_[1].value.as< Rules::Ptr > () ); } -#line 2727 "GrammarParser.cpp" // lalr1.cc:859 +#line 2755 "GrammarParser.cpp" // lalr1.cc:859 break; - case 160: -#line 1399 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 162: +#line 1413 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< BlockRule::Ptr > () = nullptr; yyerrok; } -#line 2736 "GrammarParser.cpp" // lalr1.cc:859 +#line 2764 "GrammarParser.cpp" // lalr1.cc:859 break; - case 161: -#line 1404 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 163: +#line 1418 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< BlockRule::Ptr > () = nullptr; yyerrok; } -#line 2745 "GrammarParser.cpp" // lalr1.cc:859 +#line 2773 "GrammarParser.cpp" // lalr1.cc:859 break; - case 162: -#line 1413 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 164: +#line 1427 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< SequenceRule::Ptr > () = Ast::make< SequenceRule >( yylhs.location, yystack_[1].value.as< Rules::Ptr > () ); } -#line 2753 "GrammarParser.cpp" // lalr1.cc:859 +#line 2781 "GrammarParser.cpp" // lalr1.cc:859 break; - case 163: -#line 1417 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 165: +#line 1431 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< SequenceRule::Ptr > () = Ast::make< SequenceRule >( yylhs.location, yystack_[1].value.as< Rules::Ptr > () ); } -#line 2761 "GrammarParser.cpp" // lalr1.cc:859 +#line 2789 "GrammarParser.cpp" // lalr1.cc:859 break; - case 164: -#line 1421 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 166: +#line 1435 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< SequenceRule::Ptr > () = nullptr; yyerrok; } -#line 2770 "GrammarParser.cpp" // lalr1.cc:859 +#line 2798 "GrammarParser.cpp" // lalr1.cc:859 break; - case 165: -#line 1426 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 167: +#line 1440 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< SequenceRule::Ptr > () = nullptr; yyerrok; } -#line 2779 "GrammarParser.cpp" // lalr1.cc:859 +#line 2807 "GrammarParser.cpp" // lalr1.cc:859 break; - case 166: -#line 1435 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 168: +#line 1449 "../../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 2789 "GrammarParser.cpp" // lalr1.cc:859 +#line 2817 "GrammarParser.cpp" // lalr1.cc:859 break; - case 167: -#line 1445 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 169: +#line 1459 "../../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 2799 "GrammarParser.cpp" // lalr1.cc:859 +#line 2827 "GrammarParser.cpp" // lalr1.cc:859 break; - case 168: -#line 1451 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 170: +#line 1465 "../../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 2810 "GrammarParser.cpp" // lalr1.cc:859 +#line 2838 "GrammarParser.cpp" // lalr1.cc:859 break; - case 169: -#line 1458 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 171: +#line 1472 "../../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 2820 "GrammarParser.cpp" // lalr1.cc:859 +#line 2848 "GrammarParser.cpp" // lalr1.cc:859 break; - case 170: -#line 1464 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 172: +#line 1478 "../../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 2831 "GrammarParser.cpp" // lalr1.cc:859 +#line 2859 "GrammarParser.cpp" // lalr1.cc:859 break; - case 171: -#line 1475 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 173: +#line 1489 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Attribute::Ptr > () = yystack_[0].value.as< BasicAttribute::Ptr > (); } -#line 2839 "GrammarParser.cpp" // lalr1.cc:859 +#line 2867 "GrammarParser.cpp" // lalr1.cc:859 break; - case 172: -#line 1479 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 174: +#line 1493 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< Attribute::Ptr > () = yystack_[0].value.as< ExpressionAttribute::Ptr > (); } -#line 2847 "GrammarParser.cpp" // lalr1.cc:859 +#line 2875 "GrammarParser.cpp" // lalr1.cc:859 break; - case 173: -#line 1487 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 175: +#line 1501 "../../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 2857 "GrammarParser.cpp" // lalr1.cc:859 +#line 2885 "GrammarParser.cpp" // lalr1.cc:859 break; - case 174: -#line 1493 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 176: +#line 1507 "../../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 2867 "GrammarParser.cpp" // lalr1.cc:859 +#line 2895 "GrammarParser.cpp" // lalr1.cc:859 break; - case 175: -#line 1503 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 177: +#line 1517 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 { yylhs.value.as< BasicAttribute::Ptr > () = Ast::make< BasicAttribute >( yylhs.location, yystack_[0].value.as< Identifier::Ptr > () ); } -#line 2875 "GrammarParser.cpp" // lalr1.cc:859 +#line 2903 "GrammarParser.cpp" // lalr1.cc:859 break; - case 176: -#line 1511 "../../obj/src/GrammarParser.yy" // lalr1.cc:859 + case 178: +#line 1525 "../../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 2883 "GrammarParser.cpp" // lalr1.cc:859 +#line 2911 "GrammarParser.cpp" // lalr1.cc:859 break; -#line 2887 "GrammarParser.cpp" // lalr1.cc:859 +#line 2915 "GrammarParser.cpp" // lalr1.cc:859 default: break; } @@ -3138,590 +3166,595 @@ namespace libcasm_fe { } - const short int Parser::yypact_ninf_ = -195; + const short int Parser::yypact_ninf_ = -178; - const signed char Parser::yytable_ninf_ = -60; + const signed char Parser::yytable_ninf_ = -62; const short int Parser::yypact_[] = { - 10, 199, 23, -195, -11, -8, -8, -8, -8, -8, - -195, -195, 74, -195, -195, -195, -195, -195, -195, -195, - 974, -8, -195, -195, -13, -195, 8, 17, 8, 20, - 1035, -195, 61, -195, -195, -195, -16, -16, -16, 1035, - -16, -195, -195, -195, 1035, 1035, 1035, 457, 518, -3, - -195, -195, -195, -195, -195, -195, -195, 24, 66, 29, - -195, -195, -195, -195, -195, -195, -195, -195, -195, 1478, - -195, -195, -195, 59, -195, -195, -195, -195, -195, -195, - -195, -195, -8, 39, 73, 100, -38, -3, 457, 1709, - 119, -8, -8, 103, -195, 107, 137, 144, 1244, 150, - -195, -195, -195, 124, 1035, 1445, 123, -195, 1511, 70, - -195, 974, -195, 579, -195, 1035, 1035, 1035, 1035, 1035, - 1035, 1035, 1035, 1035, 1035, 1035, 1035, 1035, 1035, 1035, - 1035, 1035, 1035, 1035, -195, 130, -195, -5, -3, -8, - 881, -3, 120, 114, 80, -195, -195, -195, -195, -195, - 1544, -195, -195, 96, -3, 1035, 1035, 1035, 1035, 1035, - -195, 1577, -195, 1035, -195, 1035, -195, 1035, -195, 133, - -195, 1709, 2, 269, 1775, 1827, 1742, 88, 88, 185, - -14, -14, 126, 126, 126, -195, 1709, 1742, 185, -14, - -14, 1709, -195, -195, -16, 136, -195, 19, 140, 616, - -195, -16, -16, -16, 881, -6, 1035, 1035, 127, 656, - 693, 117, -195, -195, -195, -195, -195, -195, -195, -195, - -195, -195, -195, -195, -195, 146, -3, -3, -3, 1035, - -8, -195, 1062, 1379, 1133, 1313, 1412, 29, 5, 1610, - 1709, -195, -195, -195, 1035, -195, -8, 177, -195, 730, - 176, 767, 149, 175, 179, -195, -195, -195, 1279, 1346, - 145, 804, 125, 844, 1035, 881, -195, 187, 147, -24, - 33, 1808, -195, 1035, 1035, 1035, 1035, 1035, -195, -195, - -195, 1709, -195, -195, -195, -195, -195, -195, 1035, 1035, - 1035, 881, 151, -195, -195, -195, -195, 1709, -195, 152, - 201, -3, -3, -195, 1709, -195, 1709, 1709, -195, 1095, - 1171, 1209, 186, 396, 1035, 165, -195, 159, -195, 881, - 881, 881, 881, 166, 169, 172, 1643, 913, 167, 1676, - 974, -195, -195, -195, -195, -195, -195, 881, 881, 881, - -195, -195, -195, 182, -195, -195, -195, -195 + 10, 122, 40, -178, -7, -14, -14, -14, -14, -14, + -14, -178, -178, 185, -178, -178, -178, -178, -178, -178, + -178, -178, 978, -14, -178, -178, -18, -178, 1, 8, + 1, 36, 3, 1039, -178, 9, -178, -178, -178, -16, + -16, -16, 1039, -16, -178, -178, -178, 1039, 1039, 1039, + 459, 521, -3, -178, -178, -178, -178, -178, -178, -178, + 30, 35, 41, -178, -178, -178, -178, -178, -178, -178, + -178, -178, 1482, -178, -178, -178, 27, -178, -178, -178, + -178, -178, -178, -178, -178, -14, 0, 56, 72, -35, + -3, -3, 459, 1713, 109, -14, -14, 74, -178, 82, + 121, 138, 1248, 139, -178, -178, -178, 92, 1039, 1449, + 115, -178, 1515, 25, -178, 978, -178, 583, -178, 1039, + 1039, 1039, 1039, 1039, 1039, 1039, 1039, 1039, 1039, 1039, + 1039, 1039, 1039, 1039, 1039, 1039, 1039, 1039, -178, 118, + -178, -6, -3, -14, 885, -3, -11, -178, -178, -178, + -178, -178, 108, 103, -178, 1548, -178, -178, 29, -3, + 1039, 1039, 1039, 1039, 1039, -178, 1581, -178, 1039, -178, + 1039, -178, 1039, -178, 125, -178, 1713, 5, 1813, 1779, + 1807, 1746, 93, 93, 1835, 119, 119, 112, 112, 112, + -178, 1713, 1746, 1835, 119, 119, 1713, -178, -178, -16, + 124, -178, -24, 297, 620, -178, -16, -16, -16, 885, + -2, 1039, 1039, 123, 660, 697, 116, -178, -178, -178, + -178, -178, -178, -178, -178, -178, -178, -178, -178, -178, + 137, -3, 1039, -3, -3, -14, -178, 1066, 1383, 1137, + 1317, 1416, 41, 28, 1614, 1713, -178, -178, -178, 1039, + -178, -14, 169, -178, 734, 172, 771, 145, 177, 178, + -178, -178, -178, 1283, 1350, 148, 808, 129, 848, 1039, + 885, 140, -43, -29, 319, -178, 190, -178, 1039, 1039, + 1039, 1039, 1039, -178, -178, -178, 1713, -178, -178, -178, + -178, -178, -178, 1039, 1039, 1039, 885, 154, -178, -178, + -178, -178, 1713, -178, -3, -3, -178, 157, 196, 1713, + -178, 1713, 1713, -178, 1099, 1175, 1213, 181, 397, 153, + -178, 1039, 161, -178, 885, 885, 885, 885, 162, 165, + 168, 1647, 917, 170, -178, 1680, 978, -178, -178, -178, + -178, -178, 885, 885, 885, -178, -178, -178, 173, -178, + -178, -178, -178 }; const unsigned char Parser::yydefact_[] = { - 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, - 9, 11, 0, 3, 13, 4, 6, 5, 1, 34, - 30, 0, 33, 38, 39, 22, 49, 0, 49, 0, - 175, 174, 0, 171, 172, 10, 0, 0, 0, 0, - 0, 68, 70, 69, 0, 0, 0, 0, 0, 0, - 72, 73, 74, 76, 75, 71, 28, 29, 0, 121, - 88, 66, 67, 65, 61, 62, 63, 64, 60, 24, - 85, 87, 86, 0, 78, 79, 80, 81, 82, 83, - 84, 40, 0, 0, 0, 0, 0, 21, 0, 176, - 0, 0, 0, 42, 44, 0, 0, 0, 0, 0, - 110, 91, 92, 0, 0, 0, 0, 112, 116, 0, - 77, 0, 23, 0, 122, 0, 0, 0, 0, 0, + 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, + 0, 10, 12, 0, 3, 14, 4, 6, 7, 5, + 1, 36, 31, 0, 35, 40, 41, 23, 51, 0, + 51, 0, 0, 177, 176, 0, 173, 174, 11, 0, + 0, 0, 0, 0, 70, 72, 71, 0, 0, 0, + 0, 0, 0, 74, 75, 76, 78, 77, 73, 29, + 30, 0, 123, 90, 68, 69, 67, 63, 64, 65, + 66, 62, 25, 87, 89, 88, 0, 80, 81, 82, + 83, 84, 85, 86, 42, 0, 0, 0, 0, 0, + 0, 22, 0, 178, 0, 0, 0, 44, 46, 0, + 0, 0, 0, 0, 112, 93, 94, 0, 0, 0, + 0, 114, 118, 0, 79, 0, 24, 0, 124, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 37, 0, 46, 0, 0, 0, - 0, 0, 20, 0, 54, 19, 50, 51, 52, 53, - 0, 8, 173, 0, 0, 0, 0, 0, 0, 0, - 90, 0, 89, 0, 114, 0, 113, 0, 27, 0, - 119, 116, 0, 107, 105, 106, 109, 93, 94, 100, - 101, 102, 95, 96, 97, 98, 25, 108, 99, 103, - 104, 26, 48, 47, 0, 0, 36, 0, 0, 0, - 144, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 168, 170, 129, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 0, 0, 0, 21, 0, - 0, 41, 0, 0, 0, 0, 0, 0, 0, 0, - 115, 118, 117, 45, 0, 32, 0, 0, 143, 0, - 0, 0, 0, 0, 0, 157, 167, 169, 0, 0, - 0, 0, 0, 0, 0, 0, 18, 17, 0, 19, - 0, 57, 43, 0, 0, 0, 0, 0, 123, 120, - 111, 31, 35, 165, 163, 142, 161, 159, 0, 0, - 0, 0, 0, 160, 158, 164, 162, 166, 130, 0, - 15, 0, 0, 55, 124, 127, 126, 125, 128, 0, - 0, 0, 145, 0, 0, 0, 12, 0, 58, 0, - 0, 0, 0, 0, 0, 0, 0, 153, 0, 0, - 30, 56, 154, 155, 156, 146, 148, 0, 0, 0, - 152, 147, 16, 0, 149, 150, 151, 14 + 0, 0, 0, 0, 0, 0, 0, 0, 39, 0, + 48, 0, 0, 0, 0, 0, 56, 34, 52, 53, + 54, 55, 21, 0, 20, 0, 9, 175, 0, 0, + 0, 0, 0, 0, 0, 92, 0, 91, 0, 116, + 0, 115, 0, 28, 0, 121, 118, 0, 109, 107, + 108, 111, 95, 96, 102, 103, 104, 97, 98, 99, + 100, 26, 110, 101, 105, 106, 27, 50, 49, 0, + 0, 38, 0, 0, 0, 146, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 170, 172, 131, 133, + 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 0, 22, 0, 0, 0, 0, 43, 0, 0, 0, + 0, 0, 0, 0, 0, 117, 120, 119, 47, 0, + 33, 0, 0, 145, 0, 0, 0, 0, 0, 0, + 159, 169, 171, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 20, 0, 59, 19, 18, 45, 0, 0, + 0, 0, 0, 125, 122, 113, 32, 37, 167, 165, + 144, 163, 161, 0, 0, 0, 0, 0, 162, 160, + 166, 164, 168, 132, 0, 0, 57, 0, 16, 126, + 129, 128, 127, 130, 0, 0, 0, 147, 0, 0, + 60, 0, 0, 13, 0, 0, 0, 0, 0, 0, + 0, 0, 155, 0, 58, 0, 31, 156, 157, 158, + 148, 150, 0, 0, 0, 154, 149, 17, 0, 151, + 152, 153, 15 }; const short int Parser::yypgoto_[] = { - -195, -195, 141, 220, -195, -195, -195, -195, -195, 7, - -195, 122, -195, -94, -195, -195, 26, -195, 224, -4, - 25, -30, -195, 229, -116, -195, -195, -195, -195, -195, - -195, -195, -195, -195, -195, -195, -195, -195, -195, -27, - -195, -195, -195, -111, 21, -195, 55, 79, -195, -195, - -195, -195, -195, -195, 30, -194, -195, -195, -195, -195, - -61, -195, -195, -195, -195, -195, -195, -195, -195, 178, - 181, -195, -195 + -178, -178, 130, 210, -178, -178, -178, -178, -178, -5, + -178, 113, -178, -101, -178, -178, -178, 26, -178, 213, + -4, 2, -34, -178, 208, -88, -178, -178, -178, -178, + -178, -178, -178, -178, -178, -178, -178, -178, -178, -178, + -28, -178, -178, -178, -100, 4, -178, -56, 69, -178, + -178, -178, -178, -178, -178, 76, -177, -178, -178, -178, + -178, -93, -178, -178, -178, -178, -178, -178, -178, -178, + 147, 149, -178, -178 }; const short int Parser::yydefgoto_[] = { - -1, 2, 10, 11, 12, 13, 316, 300, 142, 143, - 14, 56, 57, 58, 15, 16, 23, 197, 24, 59, - 94, 95, 137, 84, 145, 146, 147, 148, 149, 270, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 109, 114, 73, 74, 75, 76, 77, - 78, 79, 80, 17, 248, 249, 214, 215, 216, 327, - 328, 217, 218, 219, 220, 221, 222, 223, 224, 31, - 32, 33, 34 + -1, 2, 11, 12, 13, 14, 323, 308, 152, 153, + 15, 59, 60, 61, 16, 17, 18, 25, 202, 26, + 62, 98, 99, 141, 87, 147, 148, 149, 150, 151, + 273, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 113, 118, 76, 77, 78, 79, + 80, 81, 82, 83, 19, 253, 254, 219, 220, 221, + 332, 333, 222, 223, 224, 225, 226, 227, 228, 229, + 34, 35, 36, 37 }; const short int Parser::yytable_[] = { - 25, 19, 172, 89, 140, 251, 19, 96, 97, 19, - 99, 19, 98, 1, 19, 261, 263, 100, 101, 102, - 105, 108, 195, 18, 141, 225, 119, 120, -59, 92, - -59, 26, 27, 28, 29, 30, 20, 208, 231, 193, - 135, 124, 125, 126, 127, 110, 242, 194, 82, 279, - 21, 83, 238, 136, 167, 21, 19, 167, 21, 85, - 22, 150, 93, 93, 93, 22, 93, 245, 22, 87, - 22, 246, 113, 22, -2, 3, 111, 161, 4, 5, - 6, 7, 8, 144, 92, 302, 171, 303, 173, 174, - 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 90, 134, 93, - 266, 267, 269, 91, 112, 22, 166, 30, 30, 9, - 3, 133, 167, 4, 5, 6, 7, 8, 232, 233, - 234, 235, 236, 228, 144, 138, 171, 144, 239, 229, - 240, 247, 230, 124, 125, 126, 127, 139, 91, 155, - 144, 198, 154, 199, 156, 200, 201, 19, 202, 203, - 204, 157, 205, 206, 243, 196, 207, 159, 160, 164, - 213, 252, 253, 254, 192, 226, 227, 241, 244, 258, - 259, 264, 104, 208, 127, 317, 318, 209, 265, 283, - 286, 288, 289, 293, 295, 211, 290, 299, 313, 314, - 3, 21, 271, 4, 5, 6, 7, 8, 210, 301, - 315, 322, 330, 331, 336, 341, 22, 281, 337, 212, - 93, 338, 144, 144, 144, 119, 120, 93, 93, 93, - 347, 151, 35, 168, 255, 268, 343, 297, 122, 123, - 124, 125, 126, 127, 9, 81, 304, 305, 306, 307, - 308, 131, 132, 211, 211, 272, 93, 86, 278, 211, - 256, 309, 310, 311, 211, 211, 340, 0, 0, 152, - 0, 0, 282, 153, 0, 0, 0, 212, 212, 285, - 0, 285, 0, 212, 257, 0, 326, 329, 212, 212, - 0, 285, 0, 285, 0, 298, 0, 144, 144, 0, - 326, 0, 0, 0, 211, 0, 211, 0, 0, 119, - 120, 121, 0, 0, 0, 0, 211, 0, 211, 0, - 211, 312, 122, 123, 124, 125, 126, 127, 212, 0, - 212, 0, 0, 0, 130, 131, 132, 0, 0, 0, - 212, 0, 212, 0, 212, 0, 211, 0, 0, 332, - 333, 334, 335, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 344, 345, 346, - 212, 0, 0, 0, 211, 211, 211, 211, 0, 0, + 27, 139, 21, 154, 21, 93, 100, 101, 144, 103, + -61, 21, -61, 1, 102, 21, 21, 177, 21, 104, + 105, 106, 109, 112, 305, 250, 306, 256, 145, 251, + 96, 28, 29, 30, 31, 32, 33, 266, 268, 198, + 20, 22, 213, 231, 85, 86, 96, 199, 114, 232, + 247, 88, 140, 91, 200, 23, 94, 230, 172, 23, + 23, 24, 95, 24, 155, 97, 97, 97, 243, 97, + 24, 236, 171, 284, 24, 24, 235, 24, 172, 90, + 166, 172, 95, 115, 116, 117, 146, 146, 216, 176, + 137, 178, 179, 180, 181, 182, 183, 184, 185, 186, + 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, + 3, 138, 97, 4, 5, 6, 7, 8, 9, 142, + 143, 33, 33, 3, 159, 160, 4, 5, 6, 7, + 8, 9, 237, 238, 239, 240, 241, 165, 146, 161, + 176, 146, 244, 272, 245, 275, 276, 216, 216, 128, + 129, 130, 131, 216, 261, 146, 162, 164, 216, 216, + 123, 124, 169, 197, 233, 248, 234, 249, 10, 201, + 246, 131, 257, 258, 259, 128, 129, 130, 131, 108, + 270, 269, 288, 263, 264, -2, 3, 291, 293, 4, + 5, 6, 7, 8, 9, 294, 295, 298, 216, 300, + 216, 307, 318, 304, 274, 321, 322, 327, 334, 336, + 216, 341, 216, 217, 216, 342, 319, 320, 343, 346, + 218, 286, 352, 38, 156, 97, 271, 146, 173, 146, + 146, 10, 97, 97, 97, 348, 84, 277, 89, 345, + 216, 302, 157, 0, 0, 158, 283, 0, 0, 0, + 309, 310, 311, 312, 313, 0, 0, 0, 0, 0, + 0, 97, 0, 0, 0, 314, 315, 316, 216, 216, + 216, 216, 217, 217, 0, 0, 0, 287, 217, 262, + 0, 0, 0, 217, 217, 260, 216, 216, 216, 0, + 331, 0, 0, 335, 0, 0, 0, 0, 252, 0, + 146, 146, 0, 0, 331, 0, 0, 0, 0, 203, + 0, 204, 0, 205, 206, 21, 207, 208, 209, 0, + 210, 211, 0, 217, 212, 217, 0, 0, 0, 0, + 290, 0, 290, 0, 0, 217, 0, 217, 0, 217, + 0, 213, 290, 0, 290, 214, 303, 0, 0, 0, + 0, 0, 0, 0, 0, 119, 120, 121, 122, 23, + 123, 124, 0, 0, 0, 217, 215, 0, 0, 0, + 0, 0, 317, 126, 24, 0, 129, 130, 131, 0, + 0, 0, 0, 133, 0, 134, 135, 136, 0, 0, + 0, 0, 0, 217, 217, 217, 217, 0, 328, 0, + 337, 338, 339, 340, 0, 0, 0, 0, 0, 0, + 0, 217, 217, 217, 39, 21, 40, 41, 349, 350, + 351, 42, 0, 0, 0, 0, 329, 0, 43, 0, + 44, 45, 46, 0, 0, 0, 0, 47, 48, 49, + 0, 92, 0, 51, 0, 0, 0, 0, 330, 52, + 0, 0, 0, 0, 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, + 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, 0, 0, 0, 0, + 0, 52, 0, 0, 0, 108, 0, 0, 0, 0, + 0, 23, 110, 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, 0, + 0, 47, 48, 49, 0, 92, 0, 51, 111, 0, + 0, 0, 0, 52, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 23, 174, 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, 175, 51, + 0, 0, 203, 0, 204, 52, 205, 206, 21, 207, + 208, 209, 0, 210, 211, 23, 0, 212, 0, 0, + 0, 0, 0, 0, 53, 54, 55, 56, 57, 58, + 24, 265, 0, 0, 213, 0, 0, 0, 214, 0, + 0, 0, 203, 0, 204, 0, 205, 206, 21, 207, + 208, 209, 23, 210, 211, 0, 0, 212, 0, 215, + 0, 0, 0, 0, 0, 0, 0, 24, 267, 0, + 0, 0, 0, 0, 213, 0, 0, 0, 214, 203, + 0, 204, 0, 205, 206, 21, 207, 208, 209, 0, + 210, 211, 23, 0, 212, 0, 0, 0, 0, 215, + 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, + 0, 213, 0, 0, 0, 214, 203, 289, 204, 0, + 205, 206, 21, 207, 208, 209, 0, 210, 211, 23, + 0, 212, 0, 0, 0, 0, 215, 0, 0, 0, + 0, 0, 0, 0, 24, 0, 0, 0, 213, 0, + 0, 0, 214, 203, 0, 204, 292, 205, 206, 21, + 207, 208, 209, 0, 210, 211, 23, 0, 212, 0, + 0, 0, 0, 215, 0, 0, 0, 0, 0, 0, + 0, 24, 0, 0, 0, 213, 0, 0, 0, 214, + 203, 0, 204, 0, 205, 206, 21, 207, 208, 209, + 0, 210, 211, 23, 0, 212, 0, 0, 0, 0, + 215, 0, 0, 0, 0, 0, 0, 0, 24, 0, + 0, 0, 213, 0, 0, 0, 214, 299, 0, 0, + 203, 0, 204, 0, 205, 206, 21, 207, 208, 209, + 23, 210, 211, 0, 0, 212, 0, 215, 0, 0, + 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, + 0, 0, 213, 0, 0, 0, 214, 203, 0, 204, + 0, 205, 206, 21, 207, 208, 209, 0, 210, 211, + 23, 0, 212, 0, 0, 0, 0, 215, 301, 0, + 0, 0, 0, 0, 0, 24, 0, 0, 0, 213, + 0, 0, 0, 214, 39, 21, 40, 41, 0, 0, + 0, 42, 0, 0, 0, 0, 329, 23, 43, 0, + 44, 45, 46, 0, 215, 0, 0, 47, 48, 49, + 0, 92, 24, 51, 0, 0, 0, 0, 330, 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, 278, 51, 0, 0, 0, 0, + 0, 52, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 23, 119, 120, 121, 122, 0, 123, 124, 125, + 53, 54, 55, 56, 57, 58, 24, 324, 0, 0, + 126, 127, 128, 129, 130, 131, 0, 0, 0, 0, + 133, 0, 134, 135, 136, 119, 120, 121, 122, 0, + 123, 124, 125, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 126, 127, 128, 129, 130, 131, 280, + 0, 0, 0, 133, 0, 134, 135, 136, 0, 0, + 0, 0, 0, 119, 120, 121, 122, 0, 123, 124, + 125, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 126, 127, 128, 129, 130, 131, 325, 0, 0, + 0, 133, 0, 134, 135, 136, 0, 0, 0, 0, + 0, 119, 120, 121, 122, 0, 123, 124, 125, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 126, + 127, 128, 129, 130, 131, 326, 0, 0, 0, 133, + 0, 134, 135, 136, 0, 0, 0, 0, 0, 119, + 120, 121, 122, 0, 123, 124, 125, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 126, 127, 128, + 129, 130, 131, 163, 0, 0, 0, 133, 0, 134, + 135, 136, 0, 0, 119, 120, 121, 122, 0, 123, + 124, 125, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 126, 127, 128, 129, 130, 131, 296, 0, + 0, 0, 133, 0, 134, 135, 136, 0, 0, 119, + 120, 121, 122, 0, 123, 124, 125, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 126, 127, 128, + 129, 130, 131, 281, 0, 0, 0, 133, 0, 134, + 135, 136, 0, 119, 120, 121, 122, 0, 123, 124, + 125, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 126, 127, 128, 129, 130, 131, 0, 297, 0, + 0, 133, 0, 134, 135, 136, 119, 120, 121, 122, + 0, 123, 124, 125, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 126, 127, 128, 129, 130, 131, + 0, 0, 0, 279, 133, 0, 134, 135, 136, 119, + 120, 121, 122, 0, 123, 124, 125, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 126, 127, 128, + 129, 130, 131, 0, 0, 0, 0, 133, 282, 134, + 135, 136, 119, 120, 121, 122, 0, 123, 124, 125, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 211, 211, 211, 0, 0, 323, 212, 212, - 212, 212, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 36, 19, 37, 38, 212, 212, 212, 39, - 0, 0, 0, 0, 324, 0, 40, 0, 41, 42, - 43, 0, 0, 0, 0, 44, 45, 46, 0, 88, - 0, 48, 0, 0, 0, 0, 325, 49, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 21, 103, 0, - 0, 0, 0, 0, 0, 0, 50, 51, 52, 53, - 54, 55, 22, 36, 19, 37, 38, 0, 0, 0, - 39, 0, 0, 0, 0, 0, 0, 40, 0, 41, - 42, 43, 0, 0, 0, 0, 44, 45, 46, 0, - 88, 0, 48, 0, 0, 0, 0, 0, 49, 0, - 0, 0, 104, 0, 0, 0, 0, 0, 21, 106, - 0, 0, 0, 0, 0, 0, 0, 50, 51, 52, - 53, 54, 55, 22, 36, 19, 37, 38, 0, 0, - 0, 39, 0, 0, 0, 0, 0, 0, 40, 0, - 41, 42, 43, 0, 0, 0, 0, 44, 45, 46, - 0, 88, 0, 48, 107, 0, 0, 0, 0, 49, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, - 169, 0, 0, 0, 0, 0, 0, 0, 50, 51, - 52, 53, 54, 55, 22, 36, 19, 37, 38, 0, - 0, 0, 39, 0, 0, 0, 0, 0, 0, 40, - 0, 41, 42, 43, 0, 0, 0, 250, 44, 45, - 46, 0, 88, 170, 48, 0, 0, 198, 0, 199, - 49, 200, 201, 19, 202, 203, 204, 0, 205, 206, - 21, 0, 207, 0, 0, 0, 0, 0, 0, 50, - 51, 52, 53, 54, 55, 22, 0, 260, 0, 208, - 0, 0, 0, 209, 0, 0, 0, 198, 0, 199, - 0, 200, 201, 19, 202, 203, 204, 21, 205, 206, - 0, 0, 207, 0, 210, 0, 0, 0, 0, 0, - 0, 0, 22, 0, 262, 0, 0, 0, 0, 208, - 0, 0, 0, 209, 198, 0, 199, 0, 200, 201, - 19, 202, 203, 204, 0, 205, 206, 21, 0, 207, - 0, 0, 0, 0, 210, 0, 0, 0, 0, 0, - 0, 0, 22, 0, 0, 0, 208, 0, 0, 0, - 209, 198, 284, 199, 0, 200, 201, 19, 202, 203, - 204, 0, 205, 206, 21, 0, 207, 0, 0, 0, - 0, 210, 0, 0, 0, 0, 0, 0, 0, 22, - 0, 0, 0, 208, 0, 0, 0, 209, 198, 0, - 199, 287, 200, 201, 19, 202, 203, 204, 0, 205, - 206, 21, 0, 207, 0, 0, 0, 0, 210, 0, - 0, 0, 0, 0, 0, 0, 22, 0, 0, 0, - 208, 0, 0, 0, 209, 198, 0, 199, 0, 200, - 201, 19, 202, 203, 204, 0, 205, 206, 21, 0, - 207, 0, 0, 0, 0, 210, 0, 0, 0, 0, - 0, 0, 0, 22, 0, 0, 0, 208, 0, 0, - 0, 209, 294, 0, 0, 198, 0, 199, 0, 200, - 201, 19, 202, 203, 204, 21, 205, 206, 0, 0, - 207, 0, 210, 0, 0, 0, 0, 0, 0, 0, - 22, 0, 0, 0, 0, 0, 0, 208, 0, 0, - 0, 209, 198, 0, 199, 0, 200, 201, 19, 202, - 203, 204, 0, 205, 206, 21, 0, 207, 0, 0, - 0, 0, 210, 296, 0, 0, 0, 0, 0, 0, - 22, 0, 0, 0, 208, 0, 0, 0, 209, 36, - 19, 37, 38, 0, 0, 0, 39, 0, 0, 0, - 0, 324, 21, 40, 0, 41, 42, 43, 0, 210, - 0, 0, 44, 45, 46, 0, 88, 22, 48, 0, - 0, 0, 0, 325, 49, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 21, 0, 0, 0, 0, 0, - 0, 0, 0, 50, 51, 52, 53, 54, 55, 22, - 36, 19, 37, 38, 0, 0, 0, 39, 0, 0, - 0, 0, 0, 0, 40, 0, 41, 42, 43, 0, - 0, 0, 0, 44, 45, 46, 0, 47, 0, 48, - 0, 0, 0, 0, 0, 49, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 21, 0, 0, 0, 0, - 0, 0, 0, 0, 50, 51, 52, 53, 54, 55, - 22, 36, 19, 37, 38, 0, 0, 0, 39, 0, - 0, 0, 0, 0, 0, 40, 0, 41, 42, 43, - 0, 0, 0, 0, 44, 45, 46, 0, 88, 273, - 48, 0, 0, 0, 0, 0, 49, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 21, 115, 116, 117, - 118, 0, 119, 120, 121, 50, 51, 52, 53, 54, - 55, 22, 319, 0, 0, 122, 123, 124, 125, 126, - 127, 0, 0, 0, 0, 129, 0, 130, 131, 132, - 115, 116, 117, 118, 0, 119, 120, 121, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, - 124, 125, 126, 127, 275, 0, 0, 0, 129, 0, - 130, 131, 132, 0, 0, 0, 0, 0, 115, 116, - 117, 118, 0, 119, 120, 121, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, - 126, 127, 320, 0, 0, 0, 129, 0, 130, 131, - 132, 0, 0, 0, 0, 0, 115, 116, 117, 118, - 0, 119, 120, 121, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, - 321, 0, 0, 0, 129, 0, 130, 131, 132, 0, - 0, 0, 0, 0, 115, 116, 117, 118, 0, 119, - 120, 121, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 122, 123, 124, 125, 126, 127, 158, 0, - 0, 0, 129, 0, 130, 131, 132, 0, 0, 115, - 116, 117, 118, 0, 119, 120, 121, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, - 125, 126, 127, 291, 0, 0, 0, 129, 0, 130, - 131, 132, 0, 0, 115, 116, 117, 118, 0, 119, - 120, 121, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 122, 123, 124, 125, 126, 127, 276, 0, - 0, 0, 129, 0, 130, 131, 132, 0, 115, 116, - 117, 118, 0, 119, 120, 121, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, - 126, 127, 0, 292, 0, 0, 129, 0, 130, 131, - 132, 115, 116, 117, 118, 0, 119, 120, 121, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, - 123, 124, 125, 126, 127, 0, 0, 0, 274, 129, - 0, 130, 131, 132, 115, 116, 117, 118, 0, 119, - 120, 121, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 122, 123, 124, 125, 126, 127, 0, 0, - 0, 0, 129, 277, 130, 131, 132, 115, 116, 117, - 118, 0, 119, 120, 121, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, - 127, 0, 0, 0, 0, 129, 0, 130, 131, 132, - 115, 116, 117, 118, 0, 119, 120, 121, 0, 162, - 0, 0, 0, 0, 0, 0, 0, 163, 122, 123, - 124, 125, 126, 127, 0, 0, 0, 0, 129, 0, - 130, 131, 132, 115, 116, 117, 118, 0, 119, 120, - 121, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 122, 123, 124, 125, 126, 127, 0, 0, 0, - 128, 129, 0, 130, 131, 132, 115, 116, 117, 118, - 0, 119, 120, 121, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, - 0, 165, 0, 0, 129, 0, 130, 131, 132, 115, - 116, 117, 118, 0, 119, 120, 121, 0, 162, 0, - 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, - 125, 126, 127, 0, 0, 0, 0, 129, 0, 130, - 131, 132, 115, 116, 117, 118, 0, 119, 120, 121, - 0, 237, 0, 0, 0, 0, 0, 0, 0, 0, - 122, 123, 124, 125, 126, 127, 0, 0, 0, 0, - 129, 0, 130, 131, 132, 115, 116, 117, 118, 0, - 119, 120, 121, 0, 0, 0, 280, 0, 0, 0, - 0, 0, 0, 122, 123, 124, 125, 126, 127, 0, - 0, 0, 0, 129, 0, 130, 131, 132, 115, 116, - 117, 118, 0, 119, 120, 121, 0, 0, 0, 0, - 0, 0, 339, 0, 0, 0, 122, 123, 124, 125, - 126, 127, 0, 0, 0, 0, 129, 0, 130, 131, - 132, 115, 116, 117, 118, 0, 119, 120, 121, 0, - 0, 0, 0, 0, 342, 0, 0, 0, 0, 122, - 123, 124, 125, 126, 127, 0, 0, 0, 0, 129, - 0, 130, 131, 132, 115, 116, 117, 118, 0, 119, - 120, 121, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 122, 123, 124, 125, 126, 127, 0, 0, - 0, 0, 129, 0, 130, 131, 132, 115, 116, 117, - 0, 0, 119, 120, 121, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, - 127, 0, 0, 0, 0, 0, 0, 130, 131, 132, - 115, 0, 117, 0, 0, 119, 120, 121, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, - 124, 125, 126, 127, 0, 0, 0, 0, 0, 0, - 130, 131, 132, 115, 116, 117, 118, 0, 119, 120, + 126, 127, 128, 129, 130, 131, 0, 0, 0, 0, + 133, 0, 134, 135, 136, 119, 120, 121, 122, 0, + 123, 124, 125, 0, 167, 0, 0, 0, 0, 0, + 0, 0, 168, 126, 127, 128, 129, 130, 131, 0, + 0, 0, 0, 133, 0, 134, 135, 136, 119, 120, + 121, 122, 0, 123, 124, 125, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 126, 127, 128, 129, + 130, 131, 0, 0, 0, 132, 133, 0, 134, 135, + 136, 119, 120, 121, 122, 0, 123, 124, 125, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 126, + 127, 128, 129, 130, 131, 0, 170, 0, 0, 133, + 0, 134, 135, 136, 119, 120, 121, 122, 0, 123, + 124, 125, 0, 167, 0, 0, 0, 0, 0, 0, + 0, 0, 126, 127, 128, 129, 130, 131, 0, 0, + 0, 0, 133, 0, 134, 135, 136, 119, 120, 121, + 122, 0, 123, 124, 125, 0, 242, 0, 0, 0, + 0, 0, 0, 0, 0, 126, 127, 128, 129, 130, + 131, 0, 0, 0, 0, 133, 0, 134, 135, 136, + 119, 120, 121, 122, 0, 123, 124, 125, 0, 0, + 0, 285, 0, 0, 0, 0, 0, 0, 126, 127, + 128, 129, 130, 131, 0, 0, 0, 0, 133, 0, + 134, 135, 136, 119, 120, 121, 122, 0, 123, 124, + 125, 0, 0, 0, 0, 0, 0, 344, 0, 0, + 0, 126, 127, 128, 129, 130, 131, 0, 0, 0, + 0, 133, 0, 134, 135, 136, 119, 120, 121, 122, + 0, 123, 124, 125, 0, 0, 0, 0, 0, 347, + 0, 0, 0, 0, 126, 127, 128, 129, 130, 131, + 0, 0, 0, 0, 133, 0, 134, 135, 136, 119, + 120, 121, 122, 0, 123, 124, 125, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 126, 127, 128, + 129, 130, 131, 0, 0, 0, 0, 133, 0, 134, + 135, 136, 119, 120, 121, 0, 0, 123, 124, 125, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 122, 115, 0, 125, 126, 127, 119, 120, 121, - 0, 129, 0, 130, 131, 132, 0, 0, 0, 0, - 122, 123, 124, 125, 126, 127, 0, 0, 0, 0, - 0, 0, 130, 131, 132 + 126, 127, 128, 129, 130, 131, 0, 0, 0, 0, + 0, 0, 134, 135, 136, 119, 0, 121, 0, 0, + 123, 124, 125, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 126, 127, 128, 129, 130, 131, 0, + 0, 0, 0, 119, 0, 134, 135, 136, 123, 124, + 125, 0, 0, 0, 123, 124, 125, 0, 0, 0, + 0, 126, 127, 128, 129, 130, 131, 126, 127, 128, + 129, 130, 131, 134, 135, 136, 123, 124, 0, 134, + 135, 136, 0, 0, 0, 0, 0, 0, 0, 126, + 127, 128, 129, 130, 131, 0, 0, 0, 0, 0, + 0, 0, 135, 136 }; const short int Parser::yycheck_[] = { - 4, 17, 113, 30, 42, 199, 17, 37, 38, 17, - 40, 17, 39, 3, 17, 209, 210, 44, 45, 46, - 47, 48, 138, 0, 62, 141, 40, 41, 52, 45, - 54, 5, 6, 7, 8, 9, 47, 43, 154, 44, - 1, 55, 56, 57, 58, 49, 44, 52, 61, 44, - 61, 43, 163, 83, 52, 61, 17, 52, 61, 42, - 76, 88, 36, 37, 38, 76, 40, 48, 76, 49, - 76, 52, 43, 76, 0, 1, 52, 104, 4, 5, - 6, 7, 8, 87, 45, 52, 113, 54, 115, 116, - 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, - 127, 128, 129, 130, 131, 132, 133, 46, 82, 83, - 226, 227, 228, 52, 48, 76, 46, 91, 92, 45, - 1, 62, 52, 4, 5, 6, 7, 8, 155, 156, - 157, 158, 159, 53, 138, 62, 163, 141, 165, 59, - 167, 1, 46, 55, 56, 57, 58, 47, 52, 42, - 154, 11, 49, 13, 17, 15, 16, 17, 18, 19, - 20, 17, 22, 23, 194, 139, 26, 17, 44, 46, - 140, 201, 202, 203, 44, 55, 62, 44, 42, 206, - 207, 64, 55, 43, 58, 301, 302, 47, 42, 12, - 14, 42, 17, 48, 69, 140, 17, 10, 47, 47, - 1, 61, 229, 4, 5, 6, 7, 8, 68, 62, - 9, 25, 47, 54, 48, 48, 76, 244, 49, 140, - 194, 49, 226, 227, 228, 40, 41, 201, 202, 203, - 48, 90, 12, 111, 204, 228, 330, 264, 53, 54, - 55, 56, 57, 58, 45, 21, 273, 274, 275, 276, - 277, 66, 67, 198, 199, 230, 230, 28, 237, 204, - 205, 288, 289, 290, 209, 210, 327, -1, -1, 91, - -1, -1, 246, 92, -1, -1, -1, 198, 199, 249, - -1, 251, -1, 204, 205, -1, 313, 314, 209, 210, - -1, 261, -1, 263, -1, 265, -1, 301, 302, -1, - 327, -1, -1, -1, 249, -1, 251, -1, -1, 40, - 41, 42, -1, -1, -1, -1, 261, -1, 263, -1, - 265, 291, 53, 54, 55, 56, 57, 58, 249, -1, - 251, -1, -1, -1, 65, 66, 67, -1, -1, -1, - 261, -1, 263, -1, 265, -1, 291, -1, -1, 319, - 320, 321, 322, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 337, 338, 339, - 291, -1, -1, -1, 319, 320, 321, 322, -1, -1, + 4, 1, 18, 91, 18, 33, 40, 41, 43, 43, + 53, 18, 55, 3, 42, 18, 18, 117, 18, 47, + 48, 49, 50, 51, 53, 49, 55, 204, 63, 53, + 46, 5, 6, 7, 8, 9, 10, 214, 215, 45, + 0, 48, 44, 54, 62, 44, 46, 53, 52, 60, + 45, 43, 86, 50, 142, 62, 47, 145, 53, 62, + 62, 77, 53, 77, 92, 39, 40, 41, 168, 43, + 77, 159, 47, 45, 77, 77, 47, 77, 53, 43, + 108, 53, 53, 53, 49, 44, 90, 91, 144, 117, + 63, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, + 1, 85, 86, 4, 5, 6, 7, 8, 9, 63, + 48, 95, 96, 1, 50, 43, 4, 5, 6, 7, + 8, 9, 160, 161, 162, 163, 164, 45, 142, 18, + 168, 145, 170, 231, 172, 233, 234, 203, 204, 56, + 57, 58, 59, 209, 210, 159, 18, 18, 214, 215, + 41, 42, 47, 45, 56, 199, 63, 43, 46, 143, + 45, 59, 206, 207, 208, 56, 57, 58, 59, 56, + 43, 65, 13, 211, 212, 0, 1, 15, 43, 4, + 5, 6, 7, 8, 9, 18, 18, 49, 254, 70, + 256, 11, 48, 63, 232, 48, 10, 26, 55, 48, + 266, 49, 268, 144, 270, 50, 304, 305, 50, 49, + 144, 249, 49, 13, 94, 199, 231, 231, 115, 233, + 234, 46, 206, 207, 208, 336, 23, 235, 30, 332, + 296, 269, 95, -1, -1, 96, 242, -1, -1, -1, + 278, 279, 280, 281, 282, -1, -1, -1, -1, -1, + -1, 235, -1, -1, -1, 293, 294, 295, 324, 325, + 326, 327, 203, 204, -1, -1, -1, 251, 209, 210, + -1, -1, -1, 214, 215, 209, 342, 343, 344, -1, + 318, -1, -1, 321, -1, -1, -1, -1, 1, -1, + 304, 305, -1, -1, 332, -1, -1, -1, -1, 12, + -1, 14, -1, 16, 17, 18, 19, 20, 21, -1, + 23, 24, -1, 254, 27, 256, -1, -1, -1, -1, + 254, -1, 256, -1, -1, 266, -1, 268, -1, 270, + -1, 44, 266, -1, 268, 48, 270, -1, -1, -1, + -1, -1, -1, -1, -1, 36, 37, 38, 39, 62, + 41, 42, -1, -1, -1, 296, 69, -1, -1, -1, + -1, -1, 296, 54, 77, -1, 57, 58, 59, -1, + -1, -1, -1, 64, -1, 66, 67, 68, -1, -1, + -1, -1, -1, 324, 325, 326, 327, -1, 1, -1, + 324, 325, 326, 327, -1, -1, -1, -1, -1, -1, + -1, 342, 343, 344, 17, 18, 19, 20, 342, 343, + 344, 24, -1, -1, -1, -1, 29, -1, 31, -1, + 33, 34, 35, -1, -1, -1, -1, 40, 41, 42, + -1, 44, -1, 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, -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, -1, -1, -1, -1, + -1, 52, -1, -1, -1, 56, -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, -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, 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, -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, - -1, -1, 337, 338, 339, -1, -1, 1, 319, 320, - 321, 322, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 16, 17, 18, 19, 337, 338, 339, 23, - -1, -1, -1, -1, 28, -1, 30, -1, 32, 33, - 34, -1, -1, -1, -1, 39, 40, 41, -1, 43, - -1, 45, -1, -1, -1, -1, 50, 51, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 61, 1, -1, - -1, -1, -1, -1, -1, -1, 70, 71, 72, 73, - 74, 75, 76, 16, 17, 18, 19, -1, -1, -1, - 23, -1, -1, -1, -1, -1, -1, 30, -1, 32, - 33, 34, -1, -1, -1, -1, 39, 40, 41, -1, - 43, -1, 45, -1, -1, -1, -1, -1, 51, -1, - -1, -1, 55, -1, -1, -1, -1, -1, 61, 1, - -1, -1, -1, -1, -1, -1, -1, 70, 71, 72, - 73, 74, 75, 76, 16, 17, 18, 19, -1, -1, - -1, 23, -1, -1, -1, -1, -1, -1, 30, -1, - 32, 33, 34, -1, -1, -1, -1, 39, 40, 41, - -1, 43, -1, 45, 46, -1, -1, -1, -1, 51, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 61, - 1, -1, -1, -1, -1, -1, -1, -1, 70, 71, - 72, 73, 74, 75, 76, 16, 17, 18, 19, -1, - -1, -1, 23, -1, -1, -1, -1, -1, -1, 30, - -1, 32, 33, 34, -1, -1, -1, 1, 39, 40, - 41, -1, 43, 44, 45, -1, -1, 11, -1, 13, - 51, 15, 16, 17, 18, 19, 20, -1, 22, 23, - 61, -1, 26, -1, -1, -1, -1, -1, -1, 70, - 71, 72, 73, 74, 75, 76, -1, 1, -1, 43, - -1, -1, -1, 47, -1, -1, -1, 11, -1, 13, - -1, 15, 16, 17, 18, 19, 20, 61, 22, 23, - -1, -1, 26, -1, 68, -1, -1, -1, -1, -1, - -1, -1, 76, -1, 1, -1, -1, -1, -1, 43, - -1, -1, -1, 47, 11, -1, 13, -1, 15, 16, - 17, 18, 19, 20, -1, 22, 23, 61, -1, 26, - -1, -1, -1, -1, 68, -1, -1, -1, -1, -1, - -1, -1, 76, -1, -1, -1, 43, -1, -1, -1, - 47, 11, 12, 13, -1, 15, 16, 17, 18, 19, - 20, -1, 22, 23, 61, -1, 26, -1, -1, -1, - -1, 68, -1, -1, -1, -1, -1, -1, -1, 76, - -1, -1, -1, 43, -1, -1, -1, 47, 11, -1, - 13, 14, 15, 16, 17, 18, 19, 20, -1, 22, - 23, 61, -1, 26, -1, -1, -1, -1, 68, -1, - -1, -1, -1, -1, -1, -1, 76, -1, -1, -1, - 43, -1, -1, -1, 47, 11, -1, 13, -1, 15, - 16, 17, 18, 19, 20, -1, 22, 23, 61, -1, - 26, -1, -1, -1, -1, 68, -1, -1, -1, -1, - -1, -1, -1, 76, -1, -1, -1, 43, -1, -1, - -1, 47, 48, -1, -1, 11, -1, 13, -1, 15, - 16, 17, 18, 19, 20, 61, 22, 23, -1, -1, - 26, -1, 68, -1, -1, -1, -1, -1, -1, -1, - 76, -1, -1, -1, -1, -1, -1, 43, -1, -1, - -1, 47, 11, -1, 13, -1, 15, 16, 17, 18, - 19, 20, -1, 22, 23, 61, -1, 26, -1, -1, - -1, -1, 68, 69, -1, -1, -1, -1, -1, -1, - 76, -1, -1, -1, 43, -1, -1, -1, 47, 16, - 17, 18, 19, -1, -1, -1, 23, -1, -1, -1, - -1, 28, 61, 30, -1, 32, 33, 34, -1, 68, - -1, -1, 39, 40, 41, -1, 43, 76, 45, -1, - -1, -1, -1, 50, 51, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 61, -1, -1, -1, -1, -1, - -1, -1, -1, 70, 71, 72, 73, 74, 75, 76, - 16, 17, 18, 19, -1, -1, -1, 23, -1, -1, - -1, -1, -1, -1, 30, -1, 32, 33, 34, -1, - -1, -1, -1, 39, 40, 41, -1, 43, -1, 45, - -1, -1, -1, -1, -1, 51, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 61, -1, -1, -1, -1, - -1, -1, -1, -1, 70, 71, 72, 73, 74, 75, - 76, 16, 17, 18, 19, -1, -1, -1, 23, -1, - -1, -1, -1, -1, -1, 30, -1, 32, 33, 34, - -1, -1, -1, -1, 39, 40, 41, -1, 43, 17, - 45, -1, -1, -1, -1, -1, 51, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 61, 35, 36, 37, - 38, -1, 40, 41, 42, 70, 71, 72, 73, 74, - 75, 76, 17, -1, -1, 53, 54, 55, 56, 57, - 58, -1, -1, -1, -1, 63, -1, 65, 66, 67, - 35, 36, 37, 38, -1, 40, 41, 42, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 53, 54, - 55, 56, 57, 58, 21, -1, -1, -1, 63, -1, - 65, 66, 67, -1, -1, -1, -1, -1, 35, 36, - 37, 38, -1, 40, 41, 42, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 53, 54, 55, 56, - 57, 58, 21, -1, -1, -1, 63, -1, 65, 66, - 67, -1, -1, -1, -1, -1, 35, 36, 37, 38, - -1, 40, 41, 42, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 53, 54, 55, 56, 57, 58, - 21, -1, -1, -1, 63, -1, 65, 66, 67, -1, - -1, -1, -1, -1, 35, 36, 37, 38, -1, 40, - 41, 42, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 53, 54, 55, 56, 57, 58, 24, -1, - -1, -1, 63, -1, 65, 66, 67, -1, -1, 35, - 36, 37, 38, -1, 40, 41, 42, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 53, 54, 55, - 56, 57, 58, 24, -1, -1, -1, 63, -1, 65, - 66, 67, -1, -1, 35, 36, 37, 38, -1, 40, - 41, 42, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 53, 54, 55, 56, 57, 58, 25, -1, - -1, -1, 63, -1, 65, 66, 67, -1, 35, 36, - 37, 38, -1, 40, 41, 42, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 53, 54, 55, 56, - 57, 58, -1, 27, -1, -1, 63, -1, 65, 66, - 67, 35, 36, 37, 38, -1, 40, 41, 42, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 53, - 54, 55, 56, 57, 58, -1, -1, -1, 29, 63, - -1, 65, 66, 67, 35, 36, 37, 38, -1, 40, - 41, 42, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 53, 54, 55, 56, 57, 58, -1, -1, - -1, -1, 63, 31, 65, 66, 67, 35, 36, 37, - 38, -1, 40, 41, 42, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 53, 54, 55, 56, 57, - 58, -1, -1, -1, -1, 63, -1, 65, 66, 67, - 35, 36, 37, 38, -1, 40, 41, 42, -1, 44, - -1, -1, -1, -1, -1, -1, -1, 52, 53, 54, - 55, 56, 57, 58, -1, -1, -1, -1, 63, -1, - 65, 66, 67, 35, 36, 37, 38, -1, 40, 41, - 42, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 53, 54, 55, 56, 57, 58, -1, -1, -1, - 62, 63, -1, 65, 66, 67, 35, 36, 37, 38, - -1, 40, 41, 42, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 53, 54, 55, 56, 57, 58, - -1, 60, -1, -1, 63, -1, 65, 66, 67, 35, - 36, 37, 38, -1, 40, 41, 42, -1, 44, -1, - -1, -1, -1, -1, -1, -1, -1, 53, 54, 55, - 56, 57, 58, -1, -1, -1, -1, 63, -1, 65, - 66, 67, 35, 36, 37, 38, -1, 40, 41, 42, - -1, 44, -1, -1, -1, -1, -1, -1, -1, -1, - 53, 54, 55, 56, 57, 58, -1, -1, -1, -1, - 63, -1, 65, 66, 67, 35, 36, 37, 38, -1, - 40, 41, 42, -1, -1, -1, 46, -1, -1, -1, - -1, -1, -1, 53, 54, 55, 56, 57, 58, -1, - -1, -1, -1, 63, -1, 65, 66, 67, 35, 36, - 37, 38, -1, 40, 41, 42, -1, -1, -1, -1, - -1, -1, 49, -1, -1, -1, 53, 54, 55, 56, - 57, 58, -1, -1, -1, -1, 63, -1, 65, 66, - 67, 35, 36, 37, 38, -1, 40, 41, 42, -1, - -1, -1, -1, -1, 48, -1, -1, -1, -1, 53, - 54, 55, 56, 57, 58, -1, -1, -1, -1, 63, - -1, 65, 66, 67, 35, 36, 37, 38, -1, 40, - 41, 42, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 53, 54, 55, 56, 57, 58, -1, -1, - -1, -1, 63, -1, 65, 66, 67, 35, 36, 37, - -1, -1, 40, 41, 42, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 53, 54, 55, 56, 57, - 58, -1, -1, -1, -1, -1, -1, 65, 66, 67, - 35, -1, 37, -1, -1, 40, 41, 42, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 53, 54, - 55, 56, 57, 58, -1, -1, -1, -1, -1, -1, - 65, 66, 67, 35, 36, 37, 38, -1, 40, 41, + 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, 53, 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, + -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, 37, 38, -1, -1, 41, 42, 43, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 53, 35, -1, 56, 57, 58, 40, 41, 42, - -1, 63, -1, 65, 66, 67, -1, -1, -1, -1, - 53, 54, 55, 56, 57, 58, -1, -1, -1, -1, - -1, -1, 65, 66, 67 + 54, 55, 56, 57, 58, 59, -1, -1, -1, -1, + -1, -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, 36, -1, 66, 67, 68, 41, 42, + 43, -1, -1, -1, 41, 42, 43, -1, -1, -1, + -1, 54, 55, 56, 57, 58, 59, 54, 55, 56, + 57, 58, 59, 66, 67, 68, 41, 42, -1, 66, + 67, 68, -1, -1, -1, -1, -1, -1, -1, 54, + 55, 56, 57, 58, 59, -1, -1, -1, -1, -1, + -1, -1, 67, 68 }; const unsigned char Parser::yystos_[] = { - 0, 3, 82, 1, 4, 5, 6, 7, 8, 45, - 83, 84, 85, 86, 91, 95, 96, 134, 0, 17, - 47, 61, 76, 97, 99, 100, 97, 97, 97, 97, - 97, 150, 151, 152, 153, 84, 16, 18, 19, 23, - 30, 32, 33, 34, 39, 40, 41, 43, 45, 51, - 70, 71, 72, 73, 74, 75, 92, 93, 94, 100, - 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, - 121, 122, 123, 126, 127, 128, 129, 130, 131, 132, - 133, 99, 61, 43, 104, 42, 104, 49, 43, 120, - 46, 52, 45, 97, 101, 102, 102, 102, 120, 102, - 120, 120, 120, 1, 55, 120, 1, 46, 120, 124, - 100, 52, 48, 43, 125, 35, 36, 37, 38, 40, - 41, 42, 53, 54, 55, 56, 57, 58, 62, 63, - 65, 66, 67, 62, 97, 1, 102, 103, 62, 47, - 42, 62, 89, 90, 100, 105, 106, 107, 108, 109, - 120, 83, 150, 151, 49, 42, 17, 17, 24, 17, - 44, 120, 44, 52, 46, 60, 46, 52, 92, 1, - 44, 120, 124, 120, 120, 120, 120, 120, 120, 120, - 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, - 120, 120, 44, 44, 52, 105, 97, 98, 11, 13, - 15, 16, 18, 19, 20, 22, 23, 26, 43, 47, - 68, 127, 128, 135, 137, 138, 139, 142, 143, 144, - 145, 146, 147, 148, 149, 105, 55, 62, 53, 59, - 46, 105, 120, 120, 120, 120, 120, 44, 124, 120, - 120, 44, 44, 102, 42, 48, 52, 1, 135, 136, - 1, 136, 102, 102, 102, 135, 127, 128, 120, 120, - 1, 136, 1, 136, 64, 42, 105, 105, 90, 105, - 110, 120, 101, 17, 29, 21, 25, 31, 125, 44, - 46, 120, 97, 12, 12, 135, 14, 14, 42, 17, - 17, 24, 27, 48, 48, 69, 69, 120, 135, 10, - 88, 62, 52, 54, 120, 120, 120, 120, 120, 120, - 120, 120, 135, 47, 47, 9, 87, 105, 105, 17, - 21, 21, 25, 1, 28, 50, 120, 140, 141, 120, - 47, 54, 135, 135, 135, 135, 48, 49, 49, 49, - 141, 48, 48, 94, 135, 135, 135, 48 + 0, 3, 83, 1, 4, 5, 6, 7, 8, 9, + 46, 84, 85, 86, 87, 92, 96, 97, 98, 136, + 0, 18, 48, 62, 77, 99, 101, 102, 99, 99, + 99, 99, 99, 99, 152, 153, 154, 155, 85, 17, + 19, 20, 24, 31, 33, 34, 35, 40, 41, 42, + 44, 46, 52, 71, 72, 73, 74, 75, 76, 93, + 94, 95, 102, 113, 114, 115, 116, 117, 118, 119, + 120, 121, 122, 123, 124, 125, 128, 129, 130, 131, + 132, 133, 134, 135, 101, 62, 44, 106, 43, 106, + 43, 50, 44, 122, 47, 53, 46, 99, 103, 104, + 104, 104, 122, 104, 122, 122, 122, 1, 56, 122, + 1, 47, 122, 126, 102, 53, 49, 44, 127, 36, + 37, 38, 39, 41, 42, 43, 54, 55, 56, 57, + 58, 59, 63, 64, 66, 67, 68, 63, 99, 1, + 104, 105, 63, 48, 43, 63, 102, 107, 108, 109, + 110, 111, 90, 91, 107, 122, 84, 152, 153, 50, + 43, 18, 18, 25, 18, 45, 122, 45, 53, 47, + 61, 47, 53, 93, 1, 45, 122, 126, 122, 122, + 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, + 122, 122, 122, 122, 122, 122, 122, 45, 45, 53, + 107, 99, 100, 12, 14, 16, 17, 19, 20, 21, + 23, 24, 27, 44, 48, 69, 129, 130, 137, 139, + 140, 141, 144, 145, 146, 147, 148, 149, 150, 151, + 107, 54, 60, 56, 63, 47, 107, 122, 122, 122, + 122, 122, 45, 126, 122, 122, 45, 45, 104, 43, + 49, 53, 1, 137, 138, 1, 138, 104, 104, 104, + 137, 129, 130, 122, 122, 1, 138, 1, 138, 65, + 43, 91, 107, 112, 122, 107, 107, 103, 18, 30, + 22, 26, 32, 127, 45, 47, 122, 99, 13, 13, + 137, 15, 15, 43, 18, 18, 25, 28, 49, 49, + 70, 70, 122, 137, 63, 53, 55, 11, 89, 122, + 122, 122, 122, 122, 122, 122, 122, 137, 48, 107, + 107, 48, 10, 88, 18, 22, 22, 26, 1, 29, + 51, 122, 142, 143, 55, 122, 48, 137, 137, 137, + 137, 49, 50, 50, 50, 143, 49, 49, 95, 137, + 137, 137, 49 }; const unsigned char Parser::yyr1_[] = { - 0, 81, 82, 83, 83, 83, 83, 83, 84, 84, - 85, 85, 86, 86, 87, 87, 88, 88, 89, 89, - 90, 90, 91, 91, 92, 92, 92, 93, 93, 94, - 94, 95, 96, 97, 97, 98, 98, 99, 99, 100, - 100, 101, 101, 102, 102, 103, 103, 104, 104, 104, - 105, 105, 105, 105, 106, 107, 108, 109, 110, 110, - 111, 111, 111, 111, 111, 111, 111, 111, 112, 113, - 113, 114, 115, 115, 116, 117, 118, 119, 120, 120, - 120, 120, 120, 120, 120, 120, 120, 120, 120, 121, - 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, - 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, - 121, 122, 123, 123, 123, 124, 124, 125, 125, 125, - 126, 127, 127, 128, 129, 130, 131, 132, 133, 134, - 134, 135, 135, 135, 135, 135, 135, 135, 135, 135, - 135, 135, 136, 136, 137, 138, 138, 139, 139, 140, - 140, 140, 141, 141, 142, 143, 144, 145, 146, 146, - 146, 146, 147, 147, 147, 147, 148, 149, 149, 149, - 149, 150, 150, 151, 151, 152, 153 + 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, 93, 94, 94, + 95, 95, 96, 97, 98, 99, 99, 100, 100, 101, + 101, 102, 102, 103, 103, 104, 104, 105, 105, 106, + 106, 106, 107, 107, 107, 107, 108, 109, 110, 111, + 112, 112, 113, 113, 113, 113, 113, 113, 113, 113, + 114, 115, 115, 116, 117, 117, 118, 119, 120, 121, + 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, + 122, 123, 123, 123, 123, 123, 123, 123, 123, 123, + 123, 123, 123, 123, 123, 123, 123, 123, 123, 123, + 123, 123, 123, 124, 125, 125, 125, 126, 126, 127, + 127, 127, 128, 129, 129, 130, 131, 132, 133, 134, + 135, 136, 136, 137, 137, 137, 137, 137, 137, 137, + 137, 137, 137, 137, 138, 138, 139, 140, 140, 141, + 141, 142, 142, 142, 143, 143, 144, 145, 146, 147, + 148, 148, 148, 148, 149, 149, 149, 149, 150, 151, + 151, 151, 151, 152, 152, 153, 153, 154, 155 }; const unsigned char Parser::yyr2_[] = { - 0, 2, 2, 1, 1, 1, 1, 1, 4, 1, - 2, 1, 8, 1, 4, 0, 4, 0, 3, 1, - 1, 0, 2, 4, 1, 3, 3, 3, 1, 1, - 0, 7, 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, + 0, 2, 2, 1, 1, 1, 1, 1, 1, 4, + 1, 2, 1, 8, 1, 4, 0, 4, 0, 3, + 1, 1, 0, 2, 4, 1, 3, 3, 3, 1, + 1, 0, 7, 6, 4, 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, 2, 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, 3, 3, 3, 3, + 1, 3, 3, 2, 2, 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, 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 }; @@ -3732,25 +3765,25 @@ namespace libcasm_fe { const Parser::yytname_[] = { "\"end of file\"", "error", "$undefined", "\"CASM\"", "\"init\"", - "\"derived\"", "\"enum\"", "\"rule\"", "\"function\"", "\"initially\"", - "\"defined\"", "\"seq\"", "\"endseq\"", "\"par\"", "\"endpar\"", - "\"skip\"", "\"let\"", "\"in\"", "\"forall\"", "\"choose\"", - "\"iterate\"", "\"do\"", "\"call\"", "\"if\"", "\"then\"", "\"else\"", - "\"case\"", "\"of\"", "\"default\"", "\"holds\"", "\"exists\"", - "\"with\"", "\"undef\"", "\"false\"", "\"true\"", "\"and\"", "\"or\"", - "\"xor\"", "\"implies\"", "\"not\"", "\"+\"", "\"-\"", "\"=\"", "\"(\"", - "\")\"", "\"[\"", "\"]\"", "\"{\"", "\"}\"", "\":\"", "\"_\"", "\"@\"", - "\",\"", "\"<\"", "\">\"", "\"*\"", "\"/\"", "\"%\"", "\"^\"", "\"'\"", - "\"..\"", "\".\"", "\"->\"", "\"=>\"", "\":=\"", "\"!=\"", "\"<=\"", - "\">=\"", "\"{|\"", "\"|}\"", "\"binary\"", "\"hexadecimal\"", - "\"integer\"", "\"rational\"", "\"floating\"", "\"string\"", - "\"identifier\"", "ABSOLUTE_PATH", "UPLUS", "UMINUS", + "\"derived\"", "\"enum\"", "\"rule\"", "\"type\"", "\"function\"", + "\"initially\"", "\"defined\"", "\"seq\"", "\"endseq\"", "\"par\"", + "\"endpar\"", "\"skip\"", "\"let\"", "\"in\"", "\"forall\"", + "\"choose\"", "\"iterate\"", "\"do\"", "\"call\"", "\"if\"", "\"then\"", + "\"else\"", "\"case\"", "\"of\"", "\"default\"", "\"holds\"", + "\"exists\"", "\"with\"", "\"undef\"", "\"false\"", "\"true\"", + "\"and\"", "\"or\"", "\"xor\"", "\"implies\"", "\"not\"", "\"+\"", + "\"-\"", "\"=\"", "\"(\"", "\")\"", "\"[\"", "\"]\"", "\"{\"", "\"}\"", + "\":\"", "\"_\"", "\"@\"", "\",\"", "\"<\"", "\">\"", "\"*\"", "\"/\"", + "\"%\"", "\"^\"", "\"'\"", "\"..\"", "\".\"", "\"->\"", "\"=>\"", + "\":=\"", "\"!=\"", "\"<=\"", "\">=\"", "\"{|\"", "\"|}\"", "\"binary\"", + "\"hexadecimal\"", "\"integer\"", "\"rational\"", "\"floating\"", + "\"string\"", "\"identifier\"", "ABSOLUTE_PATH", "UPLUS", "UMINUS", "CALL_WITHOUT_ARGS", "$accept", "Specification", "Definition", "AttributedDefinition", "Definitions", "FunctionDefinition", "MaybeInitially", "MaybeDefined", "FunctionParameters", "MaybeFunctionParameters", "ProgramFunctionDefinition", "Initializer", "Initializers", "MaybeInitializers", "DerivedDefinition", - "EnumerationDefinition", "Identifier", "Identifiers", + "EnumerationDefinition", "TypeDefinition", "Identifier", "Identifiers", "DotSeparatedIdentifiers", "IdentifierPath", "Variable", "AttributedVariable", "Parameters", "MaybeParameters", "Type", "BasicType", "ComposedType", "RelationType", "FixedSizedType", "Types", @@ -3771,24 +3804,24 @@ namespace libcasm_fe { const unsigned short int Parser::yyrline_[] = { - 0, 350, 350, 362, 366, 370, 374, 378, 386, 392, - 400, 406, 416, 432, 440, 444, 452, 456, 464, 470, - 480, 484, 492, 515, 533, 541, 551, 562, 568, 578, - 582, 590, 598, 606, 610, 618, 624, 634, 640, 650, - 654, 662, 666, 675, 681, 689, 695, 705, 709, 713, - 721, 725, 729, 733, 741, 749, 757, 765, 773, 779, - 789, 793, 797, 801, 805, 809, 813, 817, 825, 833, - 838, 847, 863, 875, 891, 907, 923, 939, 947, 951, - 955, 959, 963, 967, 971, 975, 979, 983, 987, 995, - 999, 1003, 1007, 1011, 1015, 1019, 1023, 1027, 1031, 1035, - 1039, 1043, 1047, 1051, 1055, 1059, 1063, 1067, 1071, 1075, - 1079, 1087, 1095, 1100, 1104, 1112, 1118, 1128, 1132, 1136, - 1145, 1155, 1160, 1168, 1176, 1184, 1192, 1200, 1208, 1216, - 1221, 1230, 1234, 1238, 1242, 1246, 1250, 1254, 1258, 1262, - 1266, 1270, 1278, 1284, 1294, 1302, 1306, 1314, 1318, 1326, - 1330, 1334, 1342, 1348, 1358, 1366, 1374, 1382, 1390, 1394, - 1398, 1403, 1412, 1416, 1420, 1425, 1434, 1444, 1450, 1457, - 1463, 1474, 1478, 1486, 1492, 1502, 1510 + 0, 352, 352, 364, 368, 372, 376, 380, 384, 392, + 398, 406, 412, 422, 438, 446, 450, 458, 462, 470, + 476, 486, 490, 498, 521, 539, 547, 557, 568, 574, + 584, 588, 596, 604, 612, 620, 624, 632, 638, 648, + 654, 664, 668, 676, 680, 689, 695, 703, 709, 719, + 723, 727, 735, 739, 743, 747, 755, 763, 771, 779, + 787, 793, 803, 807, 811, 815, 819, 823, 827, 831, + 839, 847, 852, 861, 877, 889, 905, 921, 937, 953, + 961, 965, 969, 973, 977, 981, 985, 989, 993, 997, + 1001, 1009, 1013, 1017, 1021, 1025, 1029, 1033, 1037, 1041, + 1045, 1049, 1053, 1057, 1061, 1065, 1069, 1073, 1077, 1081, + 1085, 1089, 1093, 1101, 1109, 1114, 1118, 1126, 1132, 1142, + 1146, 1150, 1159, 1169, 1174, 1182, 1190, 1198, 1206, 1214, + 1222, 1230, 1235, 1244, 1248, 1252, 1256, 1260, 1264, 1268, + 1272, 1276, 1280, 1284, 1292, 1298, 1308, 1316, 1320, 1328, + 1332, 1340, 1344, 1348, 1356, 1362, 1372, 1380, 1388, 1396, + 1404, 1408, 1412, 1417, 1426, 1430, 1434, 1439, 1448, 1458, + 1464, 1471, 1477, 1488, 1492, 1500, 1506, 1516, 1524 }; // Print the state stack on the debug stream. @@ -3823,8 +3856,8 @@ namespace libcasm_fe { #line 31 "../../obj/src/GrammarParser.yy" // lalr1.cc:1167 } // libcasm_fe -#line 3827 "GrammarParser.cpp" // lalr1.cc:1167 -#line 1516 "../../obj/src/GrammarParser.yy" // lalr1.cc:1168 +#line 3860 "GrammarParser.cpp" // lalr1.cc:1167 +#line 1530 "../../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 2a90554ce..eef8ce75e 100644 --- a/src/various/GrammarParser.output +++ b/src/various/GrammarParser.output @@ -8,486 +8,492 @@ Grammar 3 | DerivedDefinition 4 | RuleDefinition 5 | EnumerationDefinition - 6 | error + 6 | TypeDefinition + 7 | error - 7 AttributedDefinition: "[" Attributes "]" Definition - 8 | Definition + 8 AttributedDefinition: "[" Attributes "]" Definition + 9 | Definition - 9 Definitions: Definitions AttributedDefinition - 10 | AttributedDefinition + 10 Definitions: Definitions AttributedDefinition + 11 | AttributedDefinition - 11 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially - 12 | ProgramFunctionDefinition + 12 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially + 13 | ProgramFunctionDefinition - 13 MaybeInitially: "initially" "{" MaybeInitializers "}" - 14 | %empty + 14 MaybeInitially: "initially" "{" MaybeInitializers "}" + 15 | %empty - 15 MaybeDefined: "defined" "{" Term "}" - 16 | %empty + 16 MaybeDefined: "defined" "{" Term "}" + 17 | %empty - 17 FunctionParameters: FunctionParameters "*" Type - 18 | Type + 18 FunctionParameters: FunctionParameters "*" Type + 19 | Type - 19 MaybeFunctionParameters: FunctionParameters - 20 | %empty + 20 MaybeFunctionParameters: FunctionParameters + 21 | %empty - 21 ProgramFunctionDefinition: "init" IdentifierPath - 22 | "init" "{" MaybeInitializers "}" + 22 ProgramFunctionDefinition: "init" IdentifierPath + 23 | "init" "{" MaybeInitializers "}" - 23 Initializer: Term - 24 | Term "->" Term - 25 | TwoOrMoreArguments "->" Term + 24 Initializer: Term + 25 | Term "->" Term + 26 | TwoOrMoreArguments "->" Term - 26 Initializers: Initializers "," Initializer - 27 | Initializer + 27 Initializers: Initializers "," Initializer + 28 | Initializer - 28 MaybeInitializers: Initializers - 29 | %empty + 29 MaybeInitializers: Initializers + 30 | %empty - 30 DerivedDefinition: "derived" Identifier MaybeParameters "->" Type "=" Term + 31 DerivedDefinition: "derived" Identifier MaybeParameters "->" Type "=" Term - 31 EnumerationDefinition: "enum" Identifier "=" "{" Identifiers "}" + 32 EnumerationDefinition: "enum" Identifier "=" "{" Identifiers "}" - 32 Identifier: "identifier" - 33 | "in" + 33 TypeDefinition: "type" Identifier "=" Type - 34 Identifiers: Identifiers "," Identifier - 35 | Identifier + 34 Identifier: "identifier" + 35 | "in" - 36 DotSeparatedIdentifiers: DotSeparatedIdentifiers "." Identifier - 37 | Identifier + 36 Identifiers: Identifiers "," Identifier + 37 | Identifier - 38 IdentifierPath: DotSeparatedIdentifiers - 39 | "." DotSeparatedIdentifiers + 38 DotSeparatedIdentifiers: DotSeparatedIdentifiers "." Identifier + 39 | Identifier - 40 Variable: Identifier ":" Type - 41 | Identifier + 40 IdentifierPath: DotSeparatedIdentifiers + 41 | "." DotSeparatedIdentifiers - 42 AttributedVariable: "[" Attributes "]" Variable - 43 | Variable + 42 Variable: Identifier ":" Type + 43 | Identifier - 44 Parameters: Parameters "," AttributedVariable - 45 | AttributedVariable + 44 AttributedVariable: "[" Attributes "]" Variable + 45 | Variable - 46 MaybeParameters: "(" Parameters ")" - 47 | "(" error ")" - 48 | %empty + 46 Parameters: Parameters "," AttributedVariable + 47 | AttributedVariable - 49 Type: BasicType - 50 | ComposedType - 51 | RelationType - 52 | FixedSizedType + 48 MaybeParameters: "(" Parameters ")" + 49 | "(" error ")" + 50 | %empty - 53 BasicType: IdentifierPath + 51 Type: BasicType + 52 | ComposedType + 53 | RelationType + 54 | FixedSizedType - 54 ComposedType: IdentifierPath "<" Types ">" + 55 BasicType: IdentifierPath - 55 RelationType: IdentifierPath "<" MaybeFunctionParameters "->" Type ">" + 56 ComposedType: IdentifierPath "<" Types ">" - 56 FixedSizedType: IdentifierPath "'" Term + 57 RelationType: IdentifierPath "<" MaybeFunctionParameters "->" Type ">" - 57 Types: Types "," Type - 58 | Type + 58 FixedSizedType: IdentifierPath "'" Term - 59 Atom: Reference - 60 | BitNumber - 61 | IntegerNumber - 62 | FloatingNumber - 63 | RationalNumber - 64 | String - 65 | Undefined - 66 | Boolean + 59 Types: Types "," Type + 60 | Type - 67 Undefined: "undef" + 61 Atom: Reference + 62 | BitNumber + 63 | IntegerNumber + 64 | FloatingNumber + 65 | RationalNumber + 66 | String + 67 | Undefined + 68 | Boolean - 68 Boolean: "true" - 69 | "false" + 69 Undefined: "undef" - 70 String: "string" + 70 Boolean: "true" + 71 | "false" - 71 BitNumber: "binary" - 72 | "hexadecimal" + 72 String: "string" - 73 IntegerNumber: "integer" + 73 BitNumber: "binary" + 74 | "hexadecimal" - 74 FloatingNumber: "floating" + 75 IntegerNumber: "integer" - 75 RationalNumber: "rational" + 76 FloatingNumber: "floating" - 76 Reference: "@" IdentifierPath + 77 RationalNumber: "rational" - 77 Term: DirectCallExpression - 78 | IndirectCallExpression - 79 | LetExpression - 80 | ConditionalExpression - 81 | ChooseExpression - 82 | UniversalQuantifierExpression - 83 | ExistentialQuantifierExpression - 84 | Expression - 85 | List - 86 | Range - 87 | Atom + 78 Reference: "@" IdentifierPath - 88 Expression: "(" Term ")" - 89 | "(" error ")" - 90 | "+" Term - 91 | "-" Term - 92 | Term "+" Term - 93 | Term "-" Term - 94 | Term "*" Term - 95 | 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 "or" Term - 105 | Term "xor" Term - 106 | Term "and" Term - 107 | Term "=>" Term - 108 | Term "implies" Term - 109 | "not" Term + 79 Term: DirectCallExpression + 80 | IndirectCallExpression + 81 | LetExpression + 82 | ConditionalExpression + 83 | ChooseExpression + 84 | UniversalQuantifierExpression + 85 | ExistentialQuantifierExpression + 86 | Expression + 87 | List + 88 | Range + 89 | Atom - 110 Range: "[" Term ".." Term "]" + 90 Expression: "(" Term ")" + 91 | "(" error ")" + 92 | "+" Term + 93 | "-" Term + 94 | Term "+" Term + 95 | 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 "or" Term + 107 | Term "xor" Term + 108 | Term "and" Term + 109 | Term "=>" Term + 110 | Term "implies" Term + 111 | "not" Term - 111 List: "[" "]" - 112 | "[" Terms "]" - 113 | "[" error "]" + 112 Range: "[" Term ".." Term "]" - 114 Terms: Terms "," Term - 115 | Term + 113 List: "[" "]" + 114 | "[" Terms "]" + 115 | "[" error "]" - 116 Arguments: "(" Terms ")" - 117 | "(" error ")" - 118 | "(" ")" + 116 Terms: Terms "," Term + 117 | Term - 119 TwoOrMoreArguments: "(" Term "," Terms ")" + 118 Arguments: "(" Terms ")" + 119 | "(" error ")" + 120 | "(" ")" - 120 DirectCallExpression: IdentifierPath - 121 | IdentifierPath Arguments + 121 TwoOrMoreArguments: "(" Term "," Terms ")" - 122 IndirectCallExpression: "(" "*" Term ")" Arguments + 122 DirectCallExpression: IdentifierPath + 123 | IdentifierPath Arguments - 123 LetExpression: "let" AttributedVariable "=" Term "in" Term + 124 IndirectCallExpression: "(" "*" Term ")" Arguments - 124 ConditionalExpression: "if" Term "then" Term "else" Term + 125 LetExpression: "let" AttributedVariable "=" Term "in" Term - 125 ChooseExpression: "choose" AttributedVariable "in" Term "do" Term + 126 ConditionalExpression: "if" Term "then" Term "else" Term - 126 UniversalQuantifierExpression: "forall" AttributedVariable "in" Term "holds" Term + 127 ChooseExpression: "choose" AttributedVariable "in" Term "do" Term - 127 ExistentialQuantifierExpression: "exists" AttributedVariable "in" Term "with" Term + 128 UniversalQuantifierExpression: "forall" AttributedVariable "in" Term "holds" Term - 128 RuleDefinition: "rule" Identifier MaybeParameters "=" Rule - 129 | "rule" Identifier MaybeParameters "->" Type "=" Rule + 129 ExistentialQuantifierExpression: "exists" AttributedVariable "in" Term "with" Term - 130 Rule: SkipRule - 131 | ConditionalRule - 132 | CaseRule - 133 | LetRule - 134 | ForallRule - 135 | ChooseRule - 136 | IterateRule - 137 | BlockRule - 138 | SequenceRule - 139 | UpdateRule - 140 | CallRule + 130 RuleDefinition: "rule" Identifier MaybeParameters "=" Rule + 131 | "rule" Identifier MaybeParameters "->" Type "=" Rule - 141 Rules: Rules Rule - 142 | Rule + 132 Rule: SkipRule + 133 | ConditionalRule + 134 | CaseRule + 135 | LetRule + 136 | ForallRule + 137 | ChooseRule + 138 | IterateRule + 139 | BlockRule + 140 | SequenceRule + 141 | UpdateRule + 142 | CallRule - 143 SkipRule: "skip" + 143 Rules: Rules Rule + 144 | Rule - 144 ConditionalRule: "if" Term "then" Rule - 145 | "if" Term "then" Rule "else" Rule + 145 SkipRule: "skip" - 146 CaseRule: "case" Term "of" "{" CaseLabels "}" - 147 | "case" Term "of" "{" error "}" + 146 ConditionalRule: "if" Term "then" Rule + 147 | "if" Term "then" Rule "else" Rule - 148 CaseLabel: "default" ":" Rule - 149 | "_" ":" Rule - 150 | Term ":" Rule + 148 CaseRule: "case" Term "of" "{" CaseLabels "}" + 149 | "case" Term "of" "{" error "}" - 151 CaseLabels: CaseLabel CaseLabels - 152 | CaseLabel + 150 CaseLabel: "default" ":" Rule + 151 | "_" ":" Rule + 152 | Term ":" Rule - 153 LetRule: "let" AttributedVariable "=" Term "in" Rule + 153 CaseLabels: CaseLabel CaseLabels + 154 | CaseLabel - 154 ForallRule: "forall" AttributedVariable "in" Term "do" Rule + 155 LetRule: "let" AttributedVariable "=" Term "in" Rule - 155 ChooseRule: "choose" AttributedVariable "in" Term "do" Rule + 156 ForallRule: "forall" AttributedVariable "in" Term "do" Rule - 156 IterateRule: "iterate" Rule + 157 ChooseRule: "choose" AttributedVariable "in" Term "do" Rule - 157 BlockRule: "{" Rules "}" - 158 | "par" Rules "endpar" - 159 | "{" error "}" - 160 | "par" error "endpar" + 158 IterateRule: "iterate" Rule - 161 SequenceRule: "{|" Rules "|}" - 162 | "seq" Rules "endseq" - 163 | "{|" error "|}" - 164 | "seq" error "endseq" + 159 BlockRule: "{" Rules "}" + 160 | "par" Rules "endpar" + 161 | "{" error "}" + 162 | "par" error "endpar" - 165 UpdateRule: DirectCallExpression ":=" Term + 163 SequenceRule: "{|" Rules "|}" + 164 | "seq" Rules "endseq" + 165 | "{|" error "|}" + 166 | "seq" error "endseq" - 166 CallRule: "call" DirectCallExpression - 167 | DirectCallExpression - 168 | "call" IndirectCallExpression - 169 | IndirectCallExpression + 167 UpdateRule: DirectCallExpression ":=" Term - 170 Attribute: BasicAttribute - 171 | ExpressionAttribute + 168 CallRule: "call" DirectCallExpression + 169 | DirectCallExpression + 170 | "call" IndirectCallExpression + 171 | IndirectCallExpression - 172 Attributes: Attributes "," Attribute - 173 | Attribute + 172 Attribute: BasicAttribute + 173 | ExpressionAttribute - 174 BasicAttribute: Identifier + 174 Attributes: Attributes "," Attribute + 175 | Attribute - 175 ExpressionAttribute: Identifier Term + 176 BasicAttribute: Identifier + + 177 ExpressionAttribute: Identifier Term Terminals, with rules where they appear "end of file" (0) 0 -error (256) 6 47 89 113 117 147 159 160 163 164 +error (256) 7 49 91 115 119 149 161 162 165 166 "CASM" (258) 1 -"init" (259) 21 22 -"derived" (260) 30 -"enum" (261) 31 -"rule" (262) 128 129 -"function" (263) 11 -"initially" (264) 13 -"defined" (265) 15 -"seq" (266) 162 164 -"endseq" (267) 162 164 -"par" (268) 158 160 -"endpar" (269) 158 160 -"skip" (270) 143 -"let" (271) 123 153 -"in" (272) 33 123 125 126 127 153 154 155 -"forall" (273) 126 154 -"choose" (274) 125 155 -"iterate" (275) 156 -"do" (276) 125 154 155 -"call" (277) 166 168 -"if" (278) 124 144 145 -"then" (279) 124 144 145 -"else" (280) 124 145 -"case" (281) 146 147 -"of" (282) 146 147 -"default" (283) 148 -"holds" (284) 126 -"exists" (285) 127 -"with" (286) 127 -"undef" (287) 67 -"false" (288) 69 -"true" (289) 68 -"and" (290) 106 -"or" (291) 104 -"xor" (292) 105 -"implies" (293) 108 -"not" (294) 109 -"+" (295) 90 92 -"-" (296) 91 93 -"=" (297) 30 31 99 123 128 129 153 -"(" (298) 46 47 88 89 116 117 118 119 122 -")" (299) 46 47 88 89 116 117 118 119 122 -"[" (300) 7 42 110 111 112 113 -"]" (301) 7 42 110 111 112 113 -"{" (302) 13 15 22 31 146 147 157 159 -"}" (303) 13 15 22 31 146 147 157 159 -":" (304) 11 40 148 149 150 -"_" (305) 149 -"@" (306) 76 -"," (307) 26 34 44 57 114 119 172 -"<" (308) 54 55 100 -">" (309) 54 55 101 -"*" (310) 17 94 122 -"/" (311) 95 -"%" (312) 96 -"^" (313) 97 -"'" (314) 56 -".." (315) 110 -"." (316) 36 39 -"->" (317) 11 24 25 30 55 129 -"=>" (318) 107 -":=" (319) 165 -"!=" (320) 98 -"<=" (321) 102 -">=" (322) 103 -"{|" (323) 161 163 -"|}" (324) 161 163 -"binary" (325) 71 -"hexadecimal" (326) 72 -"integer" (327) 73 -"rational" (328) 75 -"floating" (329) 74 -"string" (330) 70 -"identifier" (331) 32 -ABSOLUTE_PATH (332) -UPLUS (333) -UMINUS (334) -CALL_WITHOUT_ARGS (335) +"init" (259) 22 23 +"derived" (260) 31 +"enum" (261) 32 +"rule" (262) 130 131 +"type" (263) 33 +"function" (264) 12 +"initially" (265) 14 +"defined" (266) 16 +"seq" (267) 164 166 +"endseq" (268) 164 166 +"par" (269) 160 162 +"endpar" (270) 160 162 +"skip" (271) 145 +"let" (272) 125 155 +"in" (273) 35 125 127 128 129 155 156 157 +"forall" (274) 128 156 +"choose" (275) 127 157 +"iterate" (276) 158 +"do" (277) 127 156 157 +"call" (278) 168 170 +"if" (279) 126 146 147 +"then" (280) 126 146 147 +"else" (281) 126 147 +"case" (282) 148 149 +"of" (283) 148 149 +"default" (284) 150 +"holds" (285) 128 +"exists" (286) 129 +"with" (287) 129 +"undef" (288) 69 +"false" (289) 71 +"true" (290) 70 +"and" (291) 108 +"or" (292) 106 +"xor" (293) 107 +"implies" (294) 110 +"not" (295) 111 +"+" (296) 92 94 +"-" (297) 93 95 +"=" (298) 31 32 33 101 125 130 131 155 +"(" (299) 48 49 90 91 118 119 120 121 124 +")" (300) 48 49 90 91 118 119 120 121 124 +"[" (301) 8 44 112 113 114 115 +"]" (302) 8 44 112 113 114 115 +"{" (303) 14 16 23 32 148 149 159 161 +"}" (304) 14 16 23 32 148 149 159 161 +":" (305) 12 42 150 151 152 +"_" (306) 151 +"@" (307) 78 +"," (308) 27 36 46 59 116 121 174 +"<" (309) 56 57 102 +">" (310) 56 57 103 +"*" (311) 18 96 124 +"/" (312) 97 +"%" (313) 98 +"^" (314) 99 +"'" (315) 58 +".." (316) 112 +"." (317) 38 41 +"->" (318) 12 25 26 31 57 131 +"=>" (319) 109 +":=" (320) 167 +"!=" (321) 100 +"<=" (322) 104 +">=" (323) 105 +"{|" (324) 163 165 +"|}" (325) 163 165 +"binary" (326) 73 +"hexadecimal" (327) 74 +"integer" (328) 75 +"rational" (329) 77 +"floating" (330) 76 +"string" (331) 72 +"identifier" (332) 34 +ABSOLUTE_PATH (333) +UPLUS (334) +UMINUS (335) +CALL_WITHOUT_ARGS (336) Nonterminals, with rules where they appear -$accept (81) +$accept (82) on left: 0 -Specification (82) +Specification (83) on left: 1, on right: 0 -Definition (83) - on left: 2 3 4 5 6, on right: 7 8 -AttributedDefinition (84) - on left: 7 8, on right: 9 10 -Definitions (85) - on left: 9 10, on right: 1 9 -FunctionDefinition (86) - on left: 11 12, on right: 2 -MaybeInitially (87) - on left: 13 14, on right: 11 -MaybeDefined (88) - on left: 15 16, on right: 11 -FunctionParameters (89) - on left: 17 18, on right: 17 19 -MaybeFunctionParameters (90) - on left: 19 20, on right: 11 55 -ProgramFunctionDefinition (91) - on left: 21 22, on right: 12 -Initializer (92) - on left: 23 24 25, on right: 26 27 -Initializers (93) - on left: 26 27, on right: 26 28 -MaybeInitializers (94) - on left: 28 29, on right: 13 22 -DerivedDefinition (95) - on left: 30, on right: 3 -EnumerationDefinition (96) - on left: 31, on right: 5 -Identifier (97) - on left: 32 33, on right: 11 30 31 34 35 36 37 40 41 128 129 174 - 175 -Identifiers (98) - on left: 34 35, on right: 31 34 -DotSeparatedIdentifiers (99) - on left: 36 37, on right: 36 38 39 -IdentifierPath (100) - on left: 38 39, on right: 21 53 54 55 56 76 120 121 -Variable (101) - on left: 40 41, on right: 42 43 -AttributedVariable (102) - on left: 42 43, on right: 44 45 123 125 126 127 153 154 155 -Parameters (103) - on left: 44 45, on right: 44 46 -MaybeParameters (104) - on left: 46 47 48, on right: 30 128 129 -Type (105) - on left: 49 50 51 52, on right: 11 17 18 30 40 55 57 58 129 -BasicType (106) - on left: 53, on right: 49 -ComposedType (107) - on left: 54, on right: 50 -RelationType (108) +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 +MaybeInitially (88) + on left: 14 15, on right: 12 +MaybeDefined (89) + on left: 16 17, on right: 12 +FunctionParameters (90) + on left: 18 19, on right: 18 20 +MaybeFunctionParameters (91) + on left: 20 21, on right: 12 57 +ProgramFunctionDefinition (92) + on left: 22 23, on right: 13 +Initializer (93) + on left: 24 25 26, on right: 27 28 +Initializers (94) + on left: 27 28, on right: 27 29 +MaybeInitializers (95) + on left: 29 30, on right: 14 23 +DerivedDefinition (96) + on left: 31, on right: 3 +EnumerationDefinition (97) + on left: 32, on right: 5 +TypeDefinition (98) + on left: 33, on right: 6 +Identifier (99) + on left: 34 35, on right: 12 31 32 33 36 37 38 39 42 43 130 131 + 176 177 +Identifiers (100) + on left: 36 37, on right: 32 36 +DotSeparatedIdentifiers (101) + on left: 38 39, on right: 38 40 41 +IdentifierPath (102) + on left: 40 41, on right: 22 55 56 57 58 78 122 123 +Variable (103) + on left: 42 43, on right: 44 45 +AttributedVariable (104) + on left: 44 45, on right: 46 47 125 127 128 129 155 156 157 +Parameters (105) + on left: 46 47, on right: 46 48 +MaybeParameters (106) + on left: 48 49 50, on right: 31 130 131 +Type (107) + on left: 51 52 53 54, on right: 12 18 19 31 33 42 57 59 60 131 +BasicType (108) on left: 55, on right: 51 -FixedSizedType (109) +ComposedType (109) on left: 56, on right: 52 -Types (110) - on left: 57 58, on right: 54 57 -Atom (111) - on left: 59 60 61 62 63 64 65 66, on right: 87 -Undefined (112) - on left: 67, on right: 65 -Boolean (113) - on left: 68 69, on right: 66 -String (114) - on left: 70, on right: 64 -BitNumber (115) - on left: 71 72, on right: 60 -IntegerNumber (116) - on left: 73, on right: 61 -FloatingNumber (117) - on left: 74, on right: 62 -RationalNumber (118) +RelationType (110) + on left: 57, on right: 53 +FixedSizedType (111) + on left: 58, on right: 54 +Types (112) + on left: 59 60, on right: 56 59 +Atom (113) + on left: 61 62 63 64 65 66 67 68, on right: 89 +Undefined (114) + on left: 69, on right: 67 +Boolean (115) + on left: 70 71, on right: 68 +String (116) + on left: 72, on right: 66 +BitNumber (117) + on left: 73 74, on right: 62 +IntegerNumber (118) on left: 75, on right: 63 -Reference (119) - on left: 76, on right: 59 -Term (120) - on left: 77 78 79 80 81 82 83 84 85 86 87, on right: 15 23 24 25 - 30 56 88 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 - 106 107 108 109 110 114 115 119 122 123 124 125 126 127 144 145 - 146 147 150 153 154 155 165 175 -Expression (121) - on left: 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 - 105 106 107 108 109, on right: 84 -Range (122) - on left: 110, on right: 86 -List (123) - on left: 111 112 113, on right: 85 -Terms (124) - on left: 114 115, on right: 112 114 116 119 -Arguments (125) - on left: 116 117 118, on right: 121 122 -TwoOrMoreArguments (126) - on left: 119, on right: 25 -DirectCallExpression (127) - on left: 120 121, on right: 77 165 166 167 -IndirectCallExpression (128) - on left: 122, on right: 78 168 169 -LetExpression (129) - on left: 123, on right: 79 -ConditionalExpression (130) - on left: 124, on right: 80 -ChooseExpression (131) +FloatingNumber (119) + on left: 76, on right: 64 +RationalNumber (120) + on left: 77, on right: 65 +Reference (121) + on left: 78, on right: 61 +Term (122) + on left: 79 80 81 82 83 84 85 86 87 88 89, on right: 16 24 25 26 + 31 58 90 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 + 108 109 110 111 112 116 117 121 124 125 126 127 128 129 146 147 + 148 149 152 155 156 157 167 177 +Expression (123) + on left: 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 + 106 107 108 109 110 111, on right: 86 +Range (124) + on left: 112, on right: 88 +List (125) + on left: 113 114 115, on right: 87 +Terms (126) + on left: 116 117, on right: 114 116 118 121 +Arguments (127) + on left: 118 119 120, on right: 123 124 +TwoOrMoreArguments (128) + on left: 121, on right: 26 +DirectCallExpression (129) + on left: 122 123, on right: 79 167 168 169 +IndirectCallExpression (130) + on left: 124, on right: 80 170 171 +LetExpression (131) on left: 125, on right: 81 -UniversalQuantifierExpression (132) +ConditionalExpression (132) on left: 126, on right: 82 -ExistentialQuantifierExpression (133) +ChooseExpression (133) on left: 127, on right: 83 -RuleDefinition (134) - on left: 128 129, on right: 4 -Rule (135) - on left: 130 131 132 133 134 135 136 137 138 139 140, on right: - 128 129 141 142 144 145 148 149 150 153 154 155 156 -Rules (136) - on left: 141 142, on right: 141 157 158 161 162 -SkipRule (137) - on left: 143, on right: 130 -ConditionalRule (138) - on left: 144 145, on right: 131 -CaseRule (139) - on left: 146 147, on right: 132 -CaseLabel (140) - on left: 148 149 150, on right: 151 152 -CaseLabels (141) - on left: 151 152, on right: 146 151 -LetRule (142) - on left: 153, on right: 133 -ForallRule (143) - on left: 154, on right: 134 -ChooseRule (144) +UniversalQuantifierExpression (134) + on left: 128, on right: 84 +ExistentialQuantifierExpression (135) + on left: 129, on right: 85 +RuleDefinition (136) + on left: 130 131, on right: 4 +Rule (137) + on left: 132 133 134 135 136 137 138 139 140 141 142, on right: + 130 131 143 144 146 147 150 151 152 155 156 157 158 +Rules (138) + on left: 143 144, on right: 143 159 160 163 164 +SkipRule (139) + on left: 145, on right: 132 +ConditionalRule (140) + on left: 146 147, on right: 133 +CaseRule (141) + on left: 148 149, on right: 134 +CaseLabel (142) + on left: 150 151 152, on right: 153 154 +CaseLabels (143) + on left: 153 154, on right: 148 153 +LetRule (144) on left: 155, on right: 135 -IterateRule (145) +ForallRule (145) on left: 156, on right: 136 -BlockRule (146) - on left: 157 158 159 160, on right: 137 -SequenceRule (147) - on left: 161 162 163 164, on right: 138 -UpdateRule (148) - on left: 165, on right: 139 -CallRule (149) - on left: 166 167 168 169, on right: 140 -Attribute (150) - on left: 170 171, on right: 172 173 -Attributes (151) - on left: 172 173, on right: 7 42 172 -BasicAttribute (152) - on left: 174, on right: 170 -ExpressionAttribute (153) - on left: 175, on right: 171 +ChooseRule (146) + on left: 157, on right: 137 +IterateRule (147) + on left: 158, on right: 138 +BlockRule (148) + on left: 159 160 161 162, on right: 139 +SequenceRule (149) + on left: 163 164 165 166, on right: 140 +UpdateRule (150) + on left: 167, on right: 141 +CallRule (151) + on left: 168 169 170 171, on right: 142 +Attribute (152) + on left: 172 173, on right: 174 175 +Attributes (153) + on left: 174 175, on right: 8 44 174 +BasicAttribute (154) + on left: 176, on right: 172 +ExpressionAttribute (155) + on left: 177, on right: 173 State 0 @@ -508,7606 +514,7661 @@ State 1 "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 - "[" shift, and go to state 9 + "type" shift, and go to state 8 + "function" shift, and go to state 9 + "[" shift, and go to state 10 - Definition go to state 10 - AttributedDefinition go to state 11 - Definitions go to state 12 - FunctionDefinition go to state 13 - ProgramFunctionDefinition go to state 14 - DerivedDefinition go to state 15 - EnumerationDefinition go to state 16 - RuleDefinition go to state 17 + 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 + TypeDefinition go to state 18 + RuleDefinition go to state 19 State 2 0 $accept: Specification . "end of file" - "end of file" shift, and go to state 18 + "end of file" shift, and go to state 20 State 3 - 6 Definition: error . + 7 Definition: error . - $default reduce using rule 6 (Definition) + $default reduce using rule 7 (Definition) State 4 - 21 ProgramFunctionDefinition: "init" . IdentifierPath - 22 | "init" . "{" MaybeInitializers "}" + 22 ProgramFunctionDefinition: "init" . IdentifierPath + 23 | "init" . "{" MaybeInitializers "}" - "in" shift, and go to state 19 - "{" shift, and go to state 20 - "." shift, and go to state 21 - "identifier" shift, and go to state 22 + "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 - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 25 + Identifier go to state 25 + DotSeparatedIdentifiers go to state 26 + IdentifierPath go to state 27 State 5 - 30 DerivedDefinition: "derived" . Identifier MaybeParameters "->" Type "=" Term + 31 DerivedDefinition: "derived" . Identifier MaybeParameters "->" Type "=" Term - "in" shift, and go to state 19 - "identifier" shift, and go to state 22 + "in" shift, and go to state 21 + "identifier" shift, and go to state 24 - Identifier go to state 26 + Identifier go to state 28 State 6 - 31 EnumerationDefinition: "enum" . Identifier "=" "{" Identifiers "}" + 32 EnumerationDefinition: "enum" . Identifier "=" "{" Identifiers "}" - "in" shift, and go to state 19 - "identifier" shift, and go to state 22 + "in" shift, and go to state 21 + "identifier" shift, and go to state 24 - Identifier go to state 27 + Identifier go to state 29 State 7 - 128 RuleDefinition: "rule" . Identifier MaybeParameters "=" Rule - 129 | "rule" . Identifier MaybeParameters "->" Type "=" Rule + 130 RuleDefinition: "rule" . Identifier MaybeParameters "=" Rule + 131 | "rule" . Identifier MaybeParameters "->" Type "=" Rule - "in" shift, and go to state 19 - "identifier" shift, and go to state 22 + "in" shift, and go to state 21 + "identifier" shift, and go to state 24 - Identifier go to state 28 + Identifier go to state 30 State 8 - 11 FunctionDefinition: "function" . Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially + 33 TypeDefinition: "type" . Identifier "=" Type - "in" shift, and go to state 19 - "identifier" shift, and go to state 22 + "in" shift, and go to state 21 + "identifier" shift, and go to state 24 - Identifier go to state 29 + Identifier go to state 31 State 9 - 7 AttributedDefinition: "[" . Attributes "]" Definition + 12 FunctionDefinition: "function" . Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially - "in" shift, and go to state 19 - "identifier" shift, and go to state 22 + "in" shift, and go to state 21 + "identifier" shift, and go to state 24 - Identifier go to state 30 - Attribute go to state 31 - Attributes go to state 32 - BasicAttribute go to state 33 - ExpressionAttribute go to state 34 + Identifier go to state 32 State 10 - 8 AttributedDefinition: Definition . + 8 AttributedDefinition: "[" . Attributes "]" Definition - $default reduce using rule 8 (AttributedDefinition) + "in" shift, and go to state 21 + "identifier" shift, and go to state 24 + + 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 State 11 - 10 Definitions: AttributedDefinition . + 9 AttributedDefinition: Definition . - $default reduce using rule 10 (Definitions) + $default reduce using rule 9 (AttributedDefinition) State 12 + 11 Definitions: AttributedDefinition . + + $default reduce using rule 11 (Definitions) + + +State 13 + 1 Specification: "CASM" Definitions . - 9 Definitions: Definitions . AttributedDefinition + 10 Definitions: Definitions . AttributedDefinition error shift, and go to state 3 "init" shift, and go to state 4 "derived" shift, and go to state 5 "enum" shift, and go to state 6 "rule" shift, and go to state 7 - "function" shift, and go to state 8 - "[" shift, and go to state 9 + "type" shift, and go to state 8 + "function" shift, and go to state 9 + "[" shift, and go to state 10 "end of file" reduce using rule 1 (Specification) - Definition go to state 10 - AttributedDefinition go to state 35 - FunctionDefinition go to state 13 - ProgramFunctionDefinition go to state 14 - DerivedDefinition go to state 15 - EnumerationDefinition go to state 16 - RuleDefinition go to state 17 + 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 + TypeDefinition go to state 18 + RuleDefinition go to state 19 -State 13 +State 14 2 Definition: FunctionDefinition . $default reduce using rule 2 (Definition) -State 14 +State 15 - 12 FunctionDefinition: ProgramFunctionDefinition . + 13 FunctionDefinition: ProgramFunctionDefinition . - $default reduce using rule 12 (FunctionDefinition) + $default reduce using rule 13 (FunctionDefinition) -State 15 +State 16 3 Definition: DerivedDefinition . $default reduce using rule 3 (Definition) -State 16 +State 17 5 Definition: EnumerationDefinition . $default reduce using rule 5 (Definition) -State 17 - - 4 Definition: RuleDefinition . - - $default reduce using rule 4 (Definition) - - State 18 - 0 $accept: Specification "end of file" . + 6 Definition: TypeDefinition . - $default accept + $default reduce using rule 6 (Definition) State 19 - 33 Identifier: "in" . + 4 Definition: RuleDefinition . - $default reduce using rule 33 (Identifier) + $default reduce using rule 4 (Definition) State 20 - 22 ProgramFunctionDefinition: "init" "{" . MaybeInitializers "}" - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 47 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - $default reduce using rule 29 (MaybeInitializers) + 0 $accept: Specification "end of file" . - Initializer go to state 56 - Initializers go to state 57 - MaybeInitializers go to state 58 - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 69 - Expression go to state 70 - Range go to state 71 - List go to state 72 - TwoOrMoreArguments go to state 73 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + $default accept State 21 - 39 IdentifierPath: "." . DotSeparatedIdentifiers + 35 Identifier: "in" . - "in" shift, and go to state 19 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 81 + $default reduce using rule 35 (Identifier) State 22 - 32 Identifier: "identifier" . - - $default reduce using rule 32 (Identifier) + 23 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 30 (MaybeInitializers) + + 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 State 23 - 37 DotSeparatedIdentifiers: Identifier . + 41 IdentifierPath: "." . DotSeparatedIdentifiers - $default reduce using rule 37 (DotSeparatedIdentifiers) + "in" shift, and go to state 21 + "identifier" shift, and go to state 24 + Identifier go to state 25 + DotSeparatedIdentifiers go to state 84 -State 24 - 36 DotSeparatedIdentifiers: DotSeparatedIdentifiers . "." Identifier - 38 IdentifierPath: DotSeparatedIdentifiers . +State 24 - "." shift, and go to state 82 + 34 Identifier: "identifier" . - $default reduce using rule 38 (IdentifierPath) + $default reduce using rule 34 (Identifier) State 25 - 21 ProgramFunctionDefinition: "init" IdentifierPath . + 39 DotSeparatedIdentifiers: Identifier . - $default reduce using rule 21 (ProgramFunctionDefinition) + $default reduce using rule 39 (DotSeparatedIdentifiers) State 26 - 30 DerivedDefinition: "derived" Identifier . MaybeParameters "->" Type "=" Term - - "(" shift, and go to state 83 + 38 DotSeparatedIdentifiers: DotSeparatedIdentifiers . "." Identifier + 40 IdentifierPath: DotSeparatedIdentifiers . - $default reduce using rule 48 (MaybeParameters) + "." shift, and go to state 85 - MaybeParameters go to state 84 + $default reduce using rule 40 (IdentifierPath) State 27 - 31 EnumerationDefinition: "enum" Identifier . "=" "{" Identifiers "}" + 22 ProgramFunctionDefinition: "init" IdentifierPath . - "=" shift, and go to state 85 + $default reduce using rule 22 (ProgramFunctionDefinition) State 28 - 128 RuleDefinition: "rule" Identifier . MaybeParameters "=" Rule - 129 | "rule" Identifier . MaybeParameters "->" Type "=" Rule + 31 DerivedDefinition: "derived" Identifier . MaybeParameters "->" Type "=" Term - "(" shift, and go to state 83 + "(" shift, and go to state 86 - $default reduce using rule 48 (MaybeParameters) + $default reduce using rule 50 (MaybeParameters) - MaybeParameters go to state 86 + MaybeParameters go to state 87 State 29 - 11 FunctionDefinition: "function" Identifier . ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially + 32 EnumerationDefinition: "enum" Identifier . "=" "{" Identifiers "}" - ":" shift, and go to state 87 + "=" shift, and go to state 88 State 30 - 174 BasicAttribute: Identifier . - 175 ExpressionAttribute: Identifier . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - $default reduce using rule 174 (BasicAttribute) - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 89 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 130 RuleDefinition: "rule" Identifier . MaybeParameters "=" Rule + 131 | "rule" Identifier . MaybeParameters "->" Type "=" Rule + + "(" shift, and go to state 86 + + $default reduce using rule 50 (MaybeParameters) + + MaybeParameters go to state 89 State 31 - 173 Attributes: Attribute . + 33 TypeDefinition: "type" Identifier . "=" Type - $default reduce using rule 173 (Attributes) + "=" shift, and go to state 90 State 32 - 7 AttributedDefinition: "[" Attributes . "]" Definition - 172 Attributes: Attributes . "," Attribute + 12 FunctionDefinition: "function" Identifier . ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially - "]" shift, and go to state 90 - "," shift, and go to state 91 + ":" shift, and go to state 91 State 33 - 170 Attribute: BasicAttribute . - - $default reduce using rule 170 (Attribute) + 176 BasicAttribute: Identifier . + 177 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 176 (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 State 34 - 171 Attribute: ExpressionAttribute . + 175 Attributes: Attribute . - $default reduce using rule 171 (Attribute) + $default reduce using rule 175 (Attributes) State 35 - 9 Definitions: Definitions AttributedDefinition . + 8 AttributedDefinition: "[" Attributes . "]" Definition + 174 Attributes: Attributes . "," Attribute - $default reduce using rule 9 (Definitions) + "]" shift, and go to state 94 + "," shift, and go to state 95 State 36 - 123 LetExpression: "let" . AttributedVariable "=" Term "in" Term + 172 Attribute: BasicAttribute . - "in" shift, and go to state 19 - "[" shift, and go to state 92 - "identifier" shift, and go to state 22 - - Identifier go to state 93 - Variable go to state 94 - AttributedVariable go to state 95 + $default reduce using rule 172 (Attribute) State 37 - 126 UniversalQuantifierExpression: "forall" . AttributedVariable "in" Term "holds" Term - - "in" shift, and go to state 19 - "[" shift, and go to state 92 - "identifier" shift, and go to state 22 + 173 Attribute: ExpressionAttribute . - Identifier go to state 93 - Variable go to state 94 - AttributedVariable go to state 96 + $default reduce using rule 173 (Attribute) State 38 - 125 ChooseExpression: "choose" . AttributedVariable "in" Term "do" Term + 10 Definitions: Definitions AttributedDefinition . - "in" shift, and go to state 19 - "[" shift, and go to state 92 - "identifier" shift, and go to state 22 - - Identifier go to state 93 - Variable go to state 94 - AttributedVariable go to state 97 + $default reduce using rule 10 (Definitions) State 39 - 124 ConditionalExpression: "if" . Term "then" Term "else" Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 98 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 125 LetExpression: "let" . AttributedVariable "=" Term "in" Term + + "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 State 40 - 127 ExistentialQuantifierExpression: "exists" . AttributedVariable "in" Term "with" Term + 128 UniversalQuantifierExpression: "forall" . AttributedVariable "in" Term "holds" Term - "in" shift, and go to state 19 - "[" shift, and go to state 92 - "identifier" shift, and go to state 22 + "in" shift, and go to state 21 + "[" shift, and go to state 96 + "identifier" shift, and go to state 24 - Identifier go to state 93 - Variable go to state 94 - AttributedVariable go to state 99 + Identifier go to state 97 + Variable go to state 98 + AttributedVariable go to state 100 State 41 - 67 Undefined: "undef" . + 127 ChooseExpression: "choose" . AttributedVariable "in" Term "do" Term - $default reduce using rule 67 (Undefined) + "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 -State 42 - 69 Boolean: "false" . +State 42 - $default reduce using rule 69 (Boolean) + 126 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 State 43 - 68 Boolean: "true" . + 129 ExistentialQuantifierExpression: "exists" . AttributedVariable "in" Term "with" Term + + "in" shift, and go to state 21 + "[" shift, and go to state 96 + "identifier" shift, and go to state 24 - $default reduce using rule 68 (Boolean) + Identifier go to state 97 + Variable go to state 98 + AttributedVariable go to state 103 State 44 - 109 Expression: "not" . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 100 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 69 Undefined: "undef" . + + $default reduce using rule 69 (Undefined) State 45 - 90 Expression: "+" . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 101 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 71 Boolean: "false" . + + $default reduce using rule 71 (Boolean) State 46 - 91 Expression: "-" . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 102 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 70 Boolean: "true" . + + $default reduce using rule 70 (Boolean) State 47 - 88 Expression: "(" . Term ")" - 89 | "(" . error ")" - 119 TwoOrMoreArguments: "(" . Term "," Terms ")" - 122 IndirectCallExpression: "(" . "*" Term ")" Arguments - - error shift, and go to state 103 - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "*" shift, and go to state 104 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 105 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 111 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 State 48 - 110 Range: "[" . Term ".." Term "]" - 111 List: "[" . "]" - 112 | "[" . Terms "]" - 113 | "[" . error "]" - - error shift, and go to state 106 - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "]" shift, and go to state 107 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 108 - Expression go to state 70 - Range go to state 71 - List go to state 72 - Terms go to state 109 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 92 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 State 49 - 76 Reference: "@" . IdentifierPath - - "in" shift, and go to state 19 - "." shift, and go to state 21 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 110 + 93 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 State 50 - 71 BitNumber: "binary" . - - $default reduce using rule 71 (BitNumber) + 90 Expression: "(" . Term ")" + 91 | "(" . error ")" + 121 TwoOrMoreArguments: "(" . Term "," Terms ")" + 124 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 + 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 State 51 - 72 BitNumber: "hexadecimal" . - - $default reduce using rule 72 (BitNumber) + 112 Range: "[" . Term ".." Term "]" + 113 List: "[" . "]" + 114 | "[" . Terms "]" + 115 | "[" . error "]" + + error shift, and go to state 110 + "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 111 + "@" 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 112 + Expression go to state 73 + Range go to state 74 + List go to state 75 + Terms go to state 113 + 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 State 52 - 73 IntegerNumber: "integer" . + 78 Reference: "@" . IdentifierPath + + "in" shift, and go to state 21 + "." shift, and go to state 23 + "identifier" shift, and go to state 24 - $default reduce using rule 73 (IntegerNumber) + Identifier go to state 25 + DotSeparatedIdentifiers go to state 26 + IdentifierPath go to state 114 State 53 - 75 RationalNumber: "rational" . + 73 BitNumber: "binary" . - $default reduce using rule 75 (RationalNumber) + $default reduce using rule 73 (BitNumber) State 54 - 74 FloatingNumber: "floating" . + 74 BitNumber: "hexadecimal" . - $default reduce using rule 74 (FloatingNumber) + $default reduce using rule 74 (BitNumber) State 55 - 70 String: "string" . + 75 IntegerNumber: "integer" . - $default reduce using rule 70 (String) + $default reduce using rule 75 (IntegerNumber) State 56 - 27 Initializers: Initializer . + 77 RationalNumber: "rational" . - $default reduce using rule 27 (Initializers) + $default reduce using rule 77 (RationalNumber) State 57 - 26 Initializers: Initializers . "," Initializer - 28 MaybeInitializers: Initializers . - - "," shift, and go to state 111 + 76 FloatingNumber: "floating" . - $default reduce using rule 28 (MaybeInitializers) + $default reduce using rule 76 (FloatingNumber) State 58 - 22 ProgramFunctionDefinition: "init" "{" MaybeInitializers . "}" + 72 String: "string" . - "}" shift, and go to state 112 + $default reduce using rule 72 (String) State 59 - 120 DirectCallExpression: IdentifierPath . - 121 | IdentifierPath . Arguments - - "(" shift, and go to state 113 + 28 Initializers: Initializer . - $default reduce using rule 120 (DirectCallExpression) - - Arguments go to state 114 + $default reduce using rule 28 (Initializers) State 60 - 87 Term: Atom . + 27 Initializers: Initializers . "," Initializer + 29 MaybeInitializers: Initializers . - $default reduce using rule 87 (Term) + "," shift, and go to state 115 + + $default reduce using rule 29 (MaybeInitializers) State 61 - 65 Atom: Undefined . + 23 ProgramFunctionDefinition: "init" "{" MaybeInitializers . "}" - $default reduce using rule 65 (Atom) + "}" shift, and go to state 116 State 62 - 66 Atom: Boolean . + 122 DirectCallExpression: IdentifierPath . + 123 | IdentifierPath . Arguments - $default reduce using rule 66 (Atom) + "(" shift, and go to state 117 + + $default reduce using rule 122 (DirectCallExpression) + + Arguments go to state 118 State 63 - 64 Atom: String . + 89 Term: Atom . - $default reduce using rule 64 (Atom) + $default reduce using rule 89 (Term) State 64 - 60 Atom: BitNumber . + 67 Atom: Undefined . - $default reduce using rule 60 (Atom) + $default reduce using rule 67 (Atom) State 65 - 61 Atom: IntegerNumber . + 68 Atom: Boolean . - $default reduce using rule 61 (Atom) + $default reduce using rule 68 (Atom) State 66 - 62 Atom: FloatingNumber . + 66 Atom: String . - $default reduce using rule 62 (Atom) + $default reduce using rule 66 (Atom) State 67 - 63 Atom: RationalNumber . + 62 Atom: BitNumber . - $default reduce using rule 63 (Atom) + $default reduce using rule 62 (Atom) State 68 - 59 Atom: Reference . + 63 Atom: IntegerNumber . - $default reduce using rule 59 (Atom) + $default reduce using rule 63 (Atom) State 69 - 23 Initializer: Term . - 24 | Term . "->" Term - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "implies" shift, and go to state 118 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - "<" shift, and go to state 122 - ">" 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 - - $default reduce using rule 23 (Initializer) + 64 Atom: FloatingNumber . + + $default reduce using rule 64 (Atom) State 70 - 84 Term: Expression . + 65 Atom: RationalNumber . - $default reduce using rule 84 (Term) + $default reduce using rule 65 (Atom) State 71 - 86 Term: Range . + 61 Atom: Reference . - $default reduce using rule 86 (Term) + $default reduce using rule 61 (Atom) State 72 - 85 Term: List . + 24 Initializer: Term . + 25 | Term . "->" Term + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "implies" shift, and go to state 122 + "+" 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 - $default reduce using rule 85 (Term) + $default reduce using rule 24 (Initializer) State 73 - 25 Initializer: TwoOrMoreArguments . "->" Term + 86 Term: Expression . - "->" shift, and go to state 133 + $default reduce using rule 86 (Term) State 74 - 77 Term: DirectCallExpression . + 88 Term: Range . - $default reduce using rule 77 (Term) + $default reduce using rule 88 (Term) State 75 - 78 Term: IndirectCallExpression . + 87 Term: List . - $default reduce using rule 78 (Term) + $default reduce using rule 87 (Term) State 76 - 79 Term: LetExpression . + 26 Initializer: TwoOrMoreArguments . "->" Term - $default reduce using rule 79 (Term) + "->" shift, and go to state 137 State 77 - 80 Term: ConditionalExpression . + 79 Term: DirectCallExpression . - $default reduce using rule 80 (Term) + $default reduce using rule 79 (Term) State 78 - 81 Term: ChooseExpression . + 80 Term: IndirectCallExpression . - $default reduce using rule 81 (Term) + $default reduce using rule 80 (Term) State 79 - 82 Term: UniversalQuantifierExpression . + 81 Term: LetExpression . - $default reduce using rule 82 (Term) + $default reduce using rule 81 (Term) State 80 - 83 Term: ExistentialQuantifierExpression . + 82 Term: ConditionalExpression . - $default reduce using rule 83 (Term) + $default reduce using rule 82 (Term) State 81 - 36 DotSeparatedIdentifiers: DotSeparatedIdentifiers . "." Identifier - 39 IdentifierPath: "." DotSeparatedIdentifiers . + 83 Term: ChooseExpression . - $default reduce using rule 39 (IdentifierPath) + $default reduce using rule 83 (Term) State 82 - 36 DotSeparatedIdentifiers: DotSeparatedIdentifiers "." . Identifier + 84 Term: UniversalQuantifierExpression . - "in" shift, and go to state 19 - "identifier" shift, and go to state 22 - - Identifier go to state 134 + $default reduce using rule 84 (Term) State 83 - 46 MaybeParameters: "(" . Parameters ")" - 47 | "(" . error ")" + 85 Term: ExistentialQuantifierExpression . - error shift, and go to state 135 - "in" shift, and go to state 19 - "[" shift, and go to state 92 - "identifier" shift, and go to state 22 - - Identifier go to state 93 - Variable go to state 94 - AttributedVariable go to state 136 - Parameters go to state 137 + $default reduce using rule 85 (Term) State 84 - 30 DerivedDefinition: "derived" Identifier MaybeParameters . "->" Type "=" Term + 38 DotSeparatedIdentifiers: DotSeparatedIdentifiers . "." Identifier + 41 IdentifierPath: "." DotSeparatedIdentifiers . - "->" shift, and go to state 138 + $default reduce using rule 41 (IdentifierPath) State 85 - 31 EnumerationDefinition: "enum" Identifier "=" . "{" Identifiers "}" + 38 DotSeparatedIdentifiers: DotSeparatedIdentifiers "." . Identifier - "{" shift, and go to state 139 + "in" shift, and go to state 21 + "identifier" shift, and go to state 24 + Identifier go to state 138 -State 86 - 128 RuleDefinition: "rule" Identifier MaybeParameters . "=" Rule - 129 | "rule" Identifier MaybeParameters . "->" Type "=" Rule +State 86 - "=" shift, and go to state 140 - "->" shift, and go to state 141 + 48 MaybeParameters: "(" . Parameters ")" + 49 | "(" . error ")" + error shift, and go to state 139 + "in" shift, and go to state 21 + "[" shift, and go to state 96 + "identifier" shift, and go to state 24 -State 87 + Identifier go to state 97 + Variable go to state 98 + AttributedVariable go to state 140 + Parameters go to state 141 - 11 FunctionDefinition: "function" Identifier ":" . MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially - "in" shift, and go to state 19 - "." shift, and go to state 21 - "identifier" shift, and go to state 22 +State 87 - $default reduce using rule 20 (MaybeFunctionParameters) + 31 DerivedDefinition: "derived" Identifier MaybeParameters . "->" Type "=" Term - FunctionParameters go to state 142 - MaybeFunctionParameters go to state 143 - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 144 - Type go to state 145 - BasicType go to state 146 - ComposedType go to state 147 - RelationType go to state 148 - FixedSizedType go to state 149 + "->" shift, and go to state 142 State 88 - 88 Expression: "(" . Term ")" - 89 | "(" . error ")" - 122 IndirectCallExpression: "(" . "*" Term ")" Arguments - - error shift, and go to state 103 - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "*" shift, and go to state 104 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 150 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 32 EnumerationDefinition: "enum" Identifier "=" . "{" Identifiers "}" + + "{" shift, and go to state 143 State 89 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - 175 ExpressionAttribute: Identifier Term . - - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "implies" shift, and go to state 118 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - "<" shift, and go to state 122 - ">" 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 129 - "!=" shift, and go to state 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 - - $default reduce using rule 175 (ExpressionAttribute) + 130 RuleDefinition: "rule" Identifier MaybeParameters . "=" Rule + 131 | "rule" Identifier MaybeParameters . "->" Type "=" Rule + + "=" shift, and go to state 144 + "->" shift, and go to state 145 State 90 - 7 AttributedDefinition: "[" Attributes "]" . Definition + 33 TypeDefinition: "type" Identifier "=" . Type - 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 + "in" shift, and go to state 21 + "." shift, and go to state 23 + "identifier" shift, and go to state 24 - Definition go to state 151 - FunctionDefinition go to state 13 - ProgramFunctionDefinition go to state 14 - DerivedDefinition go to state 15 - EnumerationDefinition go to state 16 - RuleDefinition go to state 17 + Identifier go to state 25 + DotSeparatedIdentifiers go to state 26 + IdentifierPath go to state 146 + Type go to state 147 + BasicType go to state 148 + ComposedType go to state 149 + RelationType go to state 150 + FixedSizedType go to state 151 State 91 - 172 Attributes: Attributes "," . Attribute + 12 FunctionDefinition: "function" Identifier ":" . MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially - "in" shift, and go to state 19 - "identifier" shift, and go to state 22 + "in" shift, and go to state 21 + "." shift, and go to state 23 + "identifier" shift, and go to state 24 - Identifier go to state 30 - Attribute go to state 152 - BasicAttribute go to state 33 - ExpressionAttribute go to state 34 + $default reduce using rule 21 (MaybeFunctionParameters) + FunctionParameters go to state 152 + MaybeFunctionParameters go to state 153 + Identifier go to state 25 + DotSeparatedIdentifiers go to state 26 + IdentifierPath go to state 146 + Type go to state 154 + BasicType go to state 148 + ComposedType go to state 149 + RelationType go to state 150 + FixedSizedType go to state 151 -State 92 - - 42 AttributedVariable: "[" . Attributes "]" Variable - "in" shift, and go to state 19 - "identifier" shift, and go to state 22 +State 92 - Identifier go to state 30 - Attribute go to state 31 - Attributes go to state 153 - BasicAttribute go to state 33 - ExpressionAttribute go to state 34 + 90 Expression: "(" . Term ")" + 91 | "(" . error ")" + 124 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 155 + 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 State 93 - 40 Variable: Identifier . ":" Type - 41 | Identifier . - - ":" shift, and go to state 154 - - $default reduce using rule 41 (Variable) + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + 177 ExpressionAttribute: Identifier Term . + + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "implies" shift, and go to state 122 + "+" 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 133 + "!=" shift, and go to state 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 + + $default reduce using rule 177 (ExpressionAttribute) State 94 - 43 AttributedVariable: Variable . + 8 AttributedDefinition: "[" Attributes "]" . Definition - $default reduce using rule 43 (AttributedVariable) + 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 + "type" shift, and go to state 8 + "function" shift, and go to state 9 + + Definition go to state 156 + FunctionDefinition go to state 14 + ProgramFunctionDefinition go to state 15 + DerivedDefinition go to state 16 + EnumerationDefinition go to state 17 + TypeDefinition go to state 18 + RuleDefinition go to state 19 State 95 - 123 LetExpression: "let" AttributedVariable . "=" Term "in" Term + 174 Attributes: Attributes "," . Attribute + + "in" shift, and go to state 21 + "identifier" shift, and go to state 24 - "=" shift, and go to state 155 + Identifier go to state 33 + Attribute go to state 157 + BasicAttribute go to state 36 + ExpressionAttribute go to state 37 State 96 - 126 UniversalQuantifierExpression: "forall" AttributedVariable . "in" Term "holds" Term + 44 AttributedVariable: "[" . Attributes "]" Variable - "in" shift, and go to state 156 + "in" shift, and go to state 21 + "identifier" shift, and go to state 24 + + Identifier go to state 33 + Attribute go to state 34 + Attributes go to state 158 + BasicAttribute go to state 36 + ExpressionAttribute go to state 37 State 97 - 125 ChooseExpression: "choose" AttributedVariable . "in" Term "do" Term + 42 Variable: Identifier . ":" Type + 43 | Identifier . + + ":" shift, and go to state 159 - "in" shift, and go to state 157 + $default reduce using rule 43 (Variable) State 98 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - 124 ConditionalExpression: "if" Term . "then" Term "else" Term - - "then" shift, and go to state 158 - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "implies" shift, and go to state 118 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - "<" shift, and go to state 122 - ">" 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 129 - "!=" shift, and go to state 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 + 45 AttributedVariable: Variable . + + $default reduce using rule 45 (AttributedVariable) State 99 - 127 ExistentialQuantifierExpression: "exists" AttributedVariable . "in" Term "with" Term + 125 LetExpression: "let" AttributedVariable . "=" Term "in" Term - "in" shift, and go to state 159 + "=" shift, and go to state 160 State 100 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - 109 | "not" Term . + 128 UniversalQuantifierExpression: "forall" AttributedVariable . "in" Term "holds" Term - $default reduce using rule 109 (Expression) + "in" shift, and go to state 161 State 101 - 90 Expression: "+" Term . - 92 | Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term + 127 ChooseExpression: "choose" AttributedVariable . "in" Term "do" Term - $default reduce using rule 90 (Expression) + "in" shift, and go to state 162 State 102 - 91 Expression: "-" Term . - 92 | Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - - $default reduce using rule 91 (Expression) + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + 126 ConditionalExpression: "if" Term . "then" Term "else" Term + + "then" shift, and go to state 163 + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "implies" shift, and go to state 122 + "+" 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 133 + "!=" shift, and go to state 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 State 103 - 89 Expression: "(" error . ")" + 129 ExistentialQuantifierExpression: "exists" AttributedVariable . "in" Term "with" Term - ")" shift, and go to state 160 + "in" shift, and go to state 164 State 104 - 122 IndirectCallExpression: "(" "*" . Term ")" Arguments - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 161 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + 111 | "not" Term . + + $default reduce using rule 111 (Expression) State 105 - 88 Expression: "(" Term . ")" - 92 | Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - 119 TwoOrMoreArguments: "(" Term . "," Terms ")" - - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "implies" shift, and go to state 118 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - ")" shift, and go to state 162 - "," shift, and go to state 163 - "<" shift, and go to state 122 - ">" 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 129 - "!=" shift, and go to state 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 + 92 Expression: "+" Term . + 94 | Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + + $default reduce using rule 92 (Expression) State 106 - 113 List: "[" error . "]" + 93 Expression: "-" Term . + 94 | Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term - "]" shift, and go to state 164 + $default reduce using rule 93 (Expression) State 107 - 111 List: "[" "]" . + 91 Expression: "(" error . ")" - $default reduce using rule 111 (List) + ")" shift, and go to state 165 State 108 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - 110 Range: "[" Term . ".." Term "]" - 115 Terms: Term . - - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "implies" shift, and go to state 118 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - "<" shift, and go to state 122 - ">" 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 165 - "=>" 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 115 (Terms) + 124 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 166 + 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 State 109 - 112 List: "[" Terms . "]" - 114 Terms: Terms . "," Term - - "]" shift, and go to state 166 - "," shift, and go to state 167 + 90 Expression: "(" Term . ")" + 94 | Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + 121 TwoOrMoreArguments: "(" Term . "," Terms ")" + + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "implies" shift, and go to state 122 + "+" shift, and go to state 123 + "-" shift, and go to state 124 + "=" shift, and go to state 125 + ")" shift, and go to state 167 + "," shift, and go to state 168 + "<" 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 133 + "!=" shift, and go to state 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 State 110 - 76 Reference: "@" IdentifierPath . + 115 List: "[" error . "]" - $default reduce using rule 76 (Reference) + "]" shift, and go to state 169 State 111 - 26 Initializers: Initializers "," . Initializer - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 47 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Initializer go to state 168 - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 69 - Expression go to state 70 - Range go to state 71 - List go to state 72 - TwoOrMoreArguments go to state 73 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 113 List: "[" "]" . + $default reduce using rule 113 (List) -State 112 - 22 ProgramFunctionDefinition: "init" "{" MaybeInitializers "}" . +State 112 - $default reduce using rule 22 (ProgramFunctionDefinition) + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + 112 Range: "[" Term . ".." Term "]" + 117 Terms: Term . + + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "implies" shift, and go to state 122 + "+" 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 170 + "=>" 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 117 (Terms) State 113 - 116 Arguments: "(" . Terms ")" - 117 | "(" . error ")" - 118 | "(" . ")" - - error shift, and go to state 169 - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - ")" shift, and go to state 170 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 171 - Expression go to state 70 - Range go to state 71 - List go to state 72 - Terms go to state 172 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 114 List: "[" Terms . "]" + 116 Terms: Terms . "," Term + + "]" shift, and go to state 171 + "," shift, and go to state 172 State 114 - 121 DirectCallExpression: IdentifierPath Arguments . + 78 Reference: "@" IdentifierPath . - $default reduce using rule 121 (DirectCallExpression) + $default reduce using rule 78 (Reference) State 115 - 106 Expression: Term "and" . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 173 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 27 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 173 + 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 State 116 - 104 Expression: Term "or" . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 174 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 23 ProgramFunctionDefinition: "init" "{" MaybeInitializers "}" . + + $default reduce using rule 23 (ProgramFunctionDefinition) State 117 - 105 Expression: Term "xor" . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 175 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 118 Arguments: "(" . Terms ")" + 119 | "(" . error ")" + 120 | "(" . ")" + + error shift, and go to state 174 + "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 175 + "[" 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 176 + Expression go to state 73 + Range go to state 74 + List go to state 75 + Terms go to state 177 + 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 State 118 - 108 Expression: Term "implies" . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 176 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 123 DirectCallExpression: IdentifierPath Arguments . + + $default reduce using rule 123 (DirectCallExpression) State 119 - 92 Expression: Term "+" . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 177 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 108 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 178 + 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 State 120 - 93 Expression: Term "-" . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 178 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 106 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 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 State 121 - 99 Expression: Term "=" . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 179 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 107 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 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 State 122 - 100 Expression: Term "<" . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 180 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 110 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 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 State 123 - 101 Expression: Term ">" . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 181 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 94 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 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 State 124 - 94 Expression: Term "*" . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 182 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 95 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 State 125 - 95 Expression: Term "/" . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 183 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 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 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 State 126 - 96 Expression: Term "%" . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 184 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 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 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 State 127 - 97 Expression: Term "^" . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 185 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 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 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 State 128 - 24 Initializer: Term "->" . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 186 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 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 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 State 129 - 107 Expression: Term "=>" . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 187 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 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 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 State 130 - 98 Expression: Term "!=" . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 188 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 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 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 State 131 - 102 Expression: Term "<=" . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 189 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 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 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 State 132 - 103 Expression: Term ">=" . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 190 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 25 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 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 State 133 - 25 Initializer: TwoOrMoreArguments "->" . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 191 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 109 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 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 State 134 - 36 DotSeparatedIdentifiers: DotSeparatedIdentifiers "." Identifier . - - $default reduce using rule 36 (DotSeparatedIdentifiers) + 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 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 State 135 - 47 MaybeParameters: "(" error . ")" - - ")" shift, and go to state 192 + 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 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 State 136 - 45 Parameters: AttributedVariable . - - $default reduce using rule 45 (Parameters) + 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 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 State 137 - 44 Parameters: Parameters . "," AttributedVariable - 46 MaybeParameters: "(" Parameters . ")" - - ")" shift, and go to state 193 - "," shift, and go to state 194 + 26 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 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 State 138 - 30 DerivedDefinition: "derived" Identifier MaybeParameters "->" . Type "=" Term - - "in" shift, and go to state 19 - "." shift, and go to state 21 - "identifier" shift, and go to state 22 + 38 DotSeparatedIdentifiers: DotSeparatedIdentifiers "." Identifier . - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 144 - Type go to state 195 - BasicType go to state 146 - ComposedType go to state 147 - RelationType go to state 148 - FixedSizedType go to state 149 + $default reduce using rule 38 (DotSeparatedIdentifiers) State 139 - 31 EnumerationDefinition: "enum" Identifier "=" "{" . Identifiers "}" + 49 MaybeParameters: "(" error . ")" - "in" shift, and go to state 19 - "identifier" shift, and go to state 22 - - Identifier go to state 196 - Identifiers go to state 197 + ")" shift, and go to state 197 State 140 - 128 RuleDefinition: "rule" Identifier MaybeParameters "=" . Rule - - "seq" shift, and go to state 198 - "par" shift, and go to state 199 - "skip" shift, and go to state 200 - "let" shift, and go to state 201 - "in" shift, and go to state 19 - "forall" shift, and go to state 202 - "choose" shift, and go to state 203 - "iterate" shift, and go to state 204 - "call" shift, and go to state 205 - "if" shift, and go to state 206 - "case" shift, and go to state 207 - "(" shift, and go to state 208 - "{" shift, and go to state 209 - "." shift, and go to state 21 - "{|" shift, and go to state 210 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - DirectCallExpression go to state 211 - IndirectCallExpression go to state 212 - Rule go to state 213 - SkipRule go to state 214 - ConditionalRule go to state 215 - CaseRule go to state 216 - LetRule go to state 217 - ForallRule go to state 218 - ChooseRule go to state 219 - IterateRule go to state 220 - BlockRule go to state 221 - SequenceRule go to state 222 - UpdateRule go to state 223 - CallRule go to state 224 + 47 Parameters: AttributedVariable . + $default reduce using rule 47 (Parameters) -State 141 - 129 RuleDefinition: "rule" Identifier MaybeParameters "->" . Type "=" Rule +State 141 - "in" shift, and go to state 19 - "." shift, and go to state 21 - "identifier" shift, and go to state 22 + 46 Parameters: Parameters . "," AttributedVariable + 48 MaybeParameters: "(" Parameters . ")" - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 144 - Type go to state 225 - BasicType go to state 146 - ComposedType go to state 147 - RelationType go to state 148 - FixedSizedType go to state 149 + ")" shift, and go to state 198 + "," shift, and go to state 199 State 142 - 17 FunctionParameters: FunctionParameters . "*" Type - 19 MaybeFunctionParameters: FunctionParameters . + 31 DerivedDefinition: "derived" Identifier MaybeParameters "->" . Type "=" Term - "*" shift, and go to state 226 + "in" shift, and go to state 21 + "." shift, and go to state 23 + "identifier" shift, and go to state 24 - $default reduce using rule 19 (MaybeFunctionParameters) + Identifier go to state 25 + DotSeparatedIdentifiers go to state 26 + IdentifierPath go to state 146 + Type go to state 200 + BasicType go to state 148 + ComposedType go to state 149 + RelationType go to state 150 + FixedSizedType go to state 151 State 143 - 11 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters . "->" Type MaybeDefined MaybeInitially + 32 EnumerationDefinition: "enum" Identifier "=" "{" . Identifiers "}" - "->" shift, and go to state 227 + "in" shift, and go to state 21 + "identifier" shift, and go to state 24 + Identifier go to state 201 + Identifiers go to state 202 -State 144 - - 53 BasicType: IdentifierPath . - 54 ComposedType: IdentifierPath . "<" Types ">" - 55 RelationType: IdentifierPath . "<" MaybeFunctionParameters "->" Type ">" - 56 FixedSizedType: IdentifierPath . "'" Term - "<" shift, and go to state 228 - "'" shift, and go to state 229 +State 144 - $default reduce using rule 53 (BasicType) + 130 RuleDefinition: "rule" Identifier MaybeParameters "=" . Rule + + "seq" shift, and go to state 203 + "par" shift, and go to state 204 + "skip" shift, and go to state 205 + "let" shift, and go to state 206 + "in" shift, and go to state 21 + "forall" shift, and go to state 207 + "choose" shift, and go to state 208 + "iterate" shift, and go to state 209 + "call" shift, and go to state 210 + "if" shift, and go to state 211 + "case" shift, and go to state 212 + "(" shift, and go to state 213 + "{" shift, and go to state 214 + "." shift, and go to state 23 + "{|" shift, and go to state 215 + "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 216 + IndirectCallExpression go to state 217 + Rule go to state 218 + SkipRule go to state 219 + ConditionalRule go to state 220 + CaseRule go to state 221 + LetRule go to state 222 + ForallRule go to state 223 + ChooseRule go to state 224 + IterateRule go to state 225 + BlockRule go to state 226 + SequenceRule go to state 227 + UpdateRule go to state 228 + CallRule go to state 229 State 145 - 18 FunctionParameters: Type . + 131 RuleDefinition: "rule" Identifier MaybeParameters "->" . Type "=" Rule - $default reduce using rule 18 (FunctionParameters) + "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 146 + Type go to state 230 + BasicType go to state 148 + ComposedType go to state 149 + RelationType go to state 150 + FixedSizedType go to state 151 State 146 - 49 Type: BasicType . + 55 BasicType: IdentifierPath . + 56 ComposedType: IdentifierPath . "<" Types ">" + 57 RelationType: IdentifierPath . "<" MaybeFunctionParameters "->" Type ">" + 58 FixedSizedType: IdentifierPath . "'" Term + + "<" shift, and go to state 231 + "'" shift, and go to state 232 - $default reduce using rule 49 (Type) + $default reduce using rule 55 (BasicType) State 147 - 50 Type: ComposedType . + 33 TypeDefinition: "type" Identifier "=" Type . - $default reduce using rule 50 (Type) + $default reduce using rule 33 (TypeDefinition) State 148 - 51 Type: RelationType . + 51 Type: BasicType . $default reduce using rule 51 (Type) State 149 - 52 Type: FixedSizedType . + 52 Type: ComposedType . $default reduce using rule 52 (Type) State 150 - 88 Expression: "(" Term . ")" - 92 | Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "implies" shift, and go to state 118 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - ")" shift, and go to state 162 - "<" shift, and go to state 122 - ">" 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 129 - "!=" shift, and go to state 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 + 53 Type: RelationType . + + $default reduce using rule 53 (Type) State 151 - 7 AttributedDefinition: "[" Attributes "]" Definition . + 54 Type: FixedSizedType . - $default reduce using rule 7 (AttributedDefinition) + $default reduce using rule 54 (Type) State 152 - 172 Attributes: Attributes "," Attribute . + 18 FunctionParameters: FunctionParameters . "*" Type + 20 MaybeFunctionParameters: FunctionParameters . - $default reduce using rule 172 (Attributes) + "*" shift, and go to state 233 + + $default reduce using rule 20 (MaybeFunctionParameters) State 153 - 42 AttributedVariable: "[" Attributes . "]" Variable - 172 Attributes: Attributes . "," Attribute + 12 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters . "->" Type MaybeDefined MaybeInitially - "]" shift, and go to state 230 - "," shift, and go to state 91 + "->" shift, and go to state 234 State 154 - 40 Variable: Identifier ":" . Type + 19 FunctionParameters: Type . - "in" shift, and go to state 19 - "." shift, and go to state 21 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 144 - Type go to state 231 - BasicType go to state 146 - ComposedType go to state 147 - RelationType go to state 148 - FixedSizedType go to state 149 + $default reduce using rule 19 (FunctionParameters) State 155 - 123 LetExpression: "let" AttributedVariable "=" . Term "in" Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 232 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 90 Expression: "(" Term . ")" + 94 | Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "implies" shift, and go to state 122 + "+" shift, and go to state 123 + "-" shift, and go to state 124 + "=" shift, and go to state 125 + ")" shift, and go to state 167 + "<" 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 133 + "!=" shift, and go to state 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 State 156 - 126 UniversalQuantifierExpression: "forall" AttributedVariable "in" . Term "holds" Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 233 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 8 AttributedDefinition: "[" Attributes "]" Definition . + + $default reduce using rule 8 (AttributedDefinition) State 157 - 125 ChooseExpression: "choose" AttributedVariable "in" . Term "do" Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 234 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 174 Attributes: Attributes "," Attribute . + + $default reduce using rule 174 (Attributes) State 158 - 124 ConditionalExpression: "if" Term "then" . Term "else" Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 235 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 44 AttributedVariable: "[" Attributes . "]" Variable + 174 Attributes: Attributes . "," Attribute + + "]" shift, and go to state 235 + "," shift, and go to state 95 State 159 - 127 ExistentialQuantifierExpression: "exists" AttributedVariable "in" . Term "with" Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 236 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 42 Variable: Identifier ":" . Type + "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 146 + Type go to state 236 + BasicType go to state 148 + ComposedType go to state 149 + RelationType go to state 150 + FixedSizedType go to state 151 -State 160 - 89 Expression: "(" error ")" . +State 160 - $default reduce using rule 89 (Expression) + 125 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 237 + 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 State 161 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - 122 IndirectCallExpression: "(" "*" Term . ")" Arguments - - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "implies" shift, and go to state 118 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - ")" shift, and go to state 237 - "<" shift, and go to state 122 - ">" 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 129 - "!=" shift, and go to state 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 + 128 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 238 + 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 State 162 - 88 Expression: "(" Term ")" . - - $default reduce using rule 88 (Expression) + 127 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 239 + 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 State 163 - 119 TwoOrMoreArguments: "(" Term "," . Terms ")" - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 171 - Expression go to state 70 - Range go to state 71 - List go to state 72 - Terms go to state 238 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 126 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 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 State 164 - 113 List: "[" error "]" . - - $default reduce using rule 113 (List) + 129 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 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 State 165 - 110 Range: "[" Term ".." . Term "]" - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 239 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 91 Expression: "(" error ")" . + $default reduce using rule 91 (Expression) -State 166 - 112 List: "[" Terms "]" . +State 166 - $default reduce using rule 112 (List) + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + 124 IndirectCallExpression: "(" "*" Term . ")" Arguments + + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "implies" shift, and go to state 122 + "+" shift, and go to state 123 + "-" shift, and go to state 124 + "=" shift, and go to state 125 + ")" shift, and go to state 242 + "<" 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 133 + "!=" shift, and go to state 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 State 167 - 114 Terms: Terms "," . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 240 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 90 Expression: "(" Term ")" . + + $default reduce using rule 90 (Expression) State 168 - 26 Initializers: Initializers "," Initializer . - - $default reduce using rule 26 (Initializers) + 121 TwoOrMoreArguments: "(" Term "," . Terms ")" + + "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 176 + Expression go to state 73 + Range go to state 74 + List go to state 75 + Terms go to state 243 + 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 State 169 - 117 Arguments: "(" error . ")" + 115 List: "[" error "]" . - ")" shift, and go to state 241 + $default reduce using rule 115 (List) State 170 - 118 Arguments: "(" ")" . - - $default reduce using rule 118 (Arguments) + 112 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 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 State 171 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - 115 Terms: Term . - - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "implies" shift, and go to state 118 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - "<" shift, and go to state 122 - ">" 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 129 - "!=" shift, and go to state 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 - - $default reduce using rule 115 (Terms) + 114 List: "[" Terms "]" . + $default reduce using rule 114 (List) -State 172 - 114 Terms: Terms . "," Term - 116 Arguments: "(" Terms . ")" +State 172 - ")" shift, and go to state 242 - "," shift, and go to state 167 + 116 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 245 + 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 State 173 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 106 | Term "and" Term . - 107 | Term . "=>" Term - 108 | Term . "implies" Term - - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - "<" shift, and go to state 122 - ">" 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 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 + 27 Initializers: Initializers "," Initializer . - $default reduce using rule 106 (Expression) + $default reduce using rule 27 (Initializers) State 174 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 104 | Term "or" Term . - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - - "and" shift, and go to state 115 - "xor" shift, and go to state 117 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - "<" shift, and go to state 122 - ">" 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 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 + 119 Arguments: "(" error . ")" - $default reduce using rule 104 (Expression) + ")" shift, and go to state 246 State 175 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 105 | Term "xor" Term . - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - - "and" shift, and go to state 115 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - "<" shift, and go to state 122 - ">" 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 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 + 120 Arguments: "(" ")" . - $default reduce using rule 105 (Expression) + $default reduce using rule 120 (Arguments) State 176 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - 108 | Term "implies" Term . - - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - "<" shift, and go to state 122 - ">" 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 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 - - $default reduce using rule 108 (Expression) + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + 117 Terms: Term . + + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "implies" shift, and go to state 122 + "+" 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 133 + "!=" shift, and go to state 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 + + $default reduce using rule 117 (Terms) State 177 - 92 Expression: Term . "+" Term - 92 | Term "+" Term . - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | 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 + 116 Terms: Terms . "," Term + 118 Arguments: "(" Terms . ")" - $default reduce using rule 92 (Expression) + ")" shift, and go to state 247 + "," shift, and go to state 172 State 178 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 93 | Term "-" Term . - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | 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 + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 108 | Term "and" Term . + 109 | Term . "=>" Term + 110 | Term . "implies" Term + + "+" 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 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 - $default reduce using rule 93 (Expression) + $default reduce using rule 108 (Expression) State 179 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | Term . "/" Term - 96 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "<" shift, and go to state 122 - ">" 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 131 - ">=" shift, and go to state 132 + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 106 | Term "or" Term . + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + + "and" shift, and go to state 119 + "xor" shift, and go to state 121 + "+" 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 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 - $default reduce using rule 99 (Expression) + $default reduce using rule 106 (Expression) State 180 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | Term . "/" Term - 96 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - - "+" shift, and go to state 119 - "-" 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 + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 107 | Term "xor" Term . + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + + "and" shift, and go to state 119 + "+" 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 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 - $default reduce using rule 100 (Expression) + $default reduce using rule 107 (Expression) State 181 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | Term . "/" Term - 96 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - - "+" shift, and go to state 119 - "-" 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 - - $default reduce using rule 101 (Expression) + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + 110 | Term "implies" Term . + + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "+" 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 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 + + $default reduce using rule 110 (Expression) State 182 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 94 | Term "*" Term . - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - - "^" shift, and go to state 127 + 94 Expression: Term . "+" Term + 94 | Term "+" Term . + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | 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 $default reduce using rule 94 (Expression) State 183 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | Term . "/" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - - "^" shift, and go to state 127 + 94 Expression: Term . "+" Term + 95 | Term . "-" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | 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 $default reduce using rule 95 (Expression) State 184 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | Term . "/" Term - 96 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - - "^" shift, and go to state 127 + 94 Expression: Term . "+" Term + 95 | Term . "-" Term + 96 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + + "+" shift, and go to state 123 + "-" shift, and go to state 124 + "<" 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 135 + ">=" shift, and go to state 136 - $default reduce using rule 96 (Expression) + $default reduce using rule 101 (Expression) State 185 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | Term . "/" Term - 96 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term + 94 Expression: Term . "+" Term + 95 | Term . "-" Term + 96 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + + "+" shift, and go to state 123 + "-" 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 - $default reduce using rule 97 (Expression) + $default reduce using rule 102 (Expression) State 186 - 24 Initializer: Term "->" Term . - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "implies" shift, and go to state 118 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - "<" shift, and go to state 122 - ">" 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 129 - "!=" shift, and go to state 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 + 94 Expression: Term . "+" Term + 95 | 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 + 103 | Term ">" Term . + 104 | Term . "<=" Term + 105 | Term . ">=" Term + 106 | Term . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + + "+" shift, and go to state 123 + "-" 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 - $default reduce using rule 24 (Initializer) + $default reduce using rule 103 (Expression) State 187 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 107 | Term "=>" Term . - 108 | Term . "implies" Term - - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - "<" shift, and go to state 122 - ">" 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 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 + 94 Expression: Term . "+" Term + 95 | Term . "-" Term + 96 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + + "^" shift, and go to state 131 - $default reduce using rule 107 (Expression) + $default reduce using rule 96 (Expression) State 188 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | Term . "/" Term - 96 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "<" shift, and go to state 122 - ">" 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 131 - ">=" shift, and go to state 132 + 94 Expression: Term . "+" Term + 95 | Term . "-" Term + 96 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + + "^" shift, and go to state 131 - $default reduce using rule 98 (Expression) + $default reduce using rule 97 (Expression) State 189 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | Term . "/" Term - 96 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - - "+" shift, and go to state 119 - "-" 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 + 94 Expression: Term . "+" Term + 95 | Term . "-" Term + 96 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + + "^" shift, and go to state 131 - $default reduce using rule 102 (Expression) + $default reduce using rule 98 (Expression) State 190 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 - 103 | Term ">=" Term . - 104 | Term . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - - "+" shift, and go to state 119 - "-" 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 + 94 Expression: Term . "+" Term + 95 | Term . "-" Term + 96 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term - $default reduce using rule 103 (Expression) + $default reduce using rule 99 (Expression) State 191 - 25 Initializer: TwoOrMoreArguments "->" Term . - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "implies" shift, and go to state 118 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - "<" shift, and go to state 122 - ">" 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 129 - "!=" shift, and go to state 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 + 25 Initializer: Term "->" Term . + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "implies" shift, and go to state 122 + "+" 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 133 + "!=" shift, and go to state 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 $default reduce using rule 25 (Initializer) State 192 - 47 MaybeParameters: "(" error ")" . + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 109 | Term "=>" Term . + 110 | Term . "implies" Term + + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "+" 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 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 - $default reduce using rule 47 (MaybeParameters) + $default reduce using rule 109 (Expression) State 193 - 46 MaybeParameters: "(" Parameters ")" . + 94 Expression: Term . "+" Term + 95 | Term . "-" Term + 96 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + + "+" shift, and go to state 123 + "-" shift, and go to state 124 + "<" 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 135 + ">=" shift, and go to state 136 - $default reduce using rule 46 (MaybeParameters) + $default reduce using rule 100 (Expression) State 194 - 44 Parameters: Parameters "," . AttributedVariable - - "in" shift, and go to state 19 - "[" shift, and go to state 92 - "identifier" shift, and go to state 22 + 94 Expression: Term . "+" Term + 95 | 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 + 104 | Term "<=" Term . + 105 | Term . ">=" Term + 106 | Term . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + + "+" shift, and go to state 123 + "-" 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 - Identifier go to state 93 - Variable go to state 94 - AttributedVariable go to state 243 + $default reduce using rule 104 (Expression) State 195 - 30 DerivedDefinition: "derived" Identifier MaybeParameters "->" Type . "=" Term + 94 Expression: Term . "+" Term + 95 | 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 + 105 | Term ">=" Term . + 106 | Term . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + + "+" shift, and go to state 123 + "-" 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 244 + $default reduce using rule 105 (Expression) State 196 - 35 Identifiers: Identifier . - - $default reduce using rule 35 (Identifiers) + 26 Initializer: TwoOrMoreArguments "->" Term . + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "implies" shift, and go to state 122 + "+" 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 133 + "!=" shift, and go to state 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 + + $default reduce using rule 26 (Initializer) State 197 - 31 EnumerationDefinition: "enum" Identifier "=" "{" Identifiers . "}" - 34 Identifiers: Identifiers . "," Identifier + 49 MaybeParameters: "(" error ")" . - "}" shift, and go to state 245 - "," shift, and go to state 246 + $default reduce using rule 49 (MaybeParameters) State 198 - 162 SequenceRule: "seq" . Rules "endseq" - 164 | "seq" . error "endseq" - - error shift, and go to state 247 - "seq" shift, and go to state 198 - "par" shift, and go to state 199 - "skip" shift, and go to state 200 - "let" shift, and go to state 201 - "in" shift, and go to state 19 - "forall" shift, and go to state 202 - "choose" shift, and go to state 203 - "iterate" shift, and go to state 204 - "call" shift, and go to state 205 - "if" shift, and go to state 206 - "case" shift, and go to state 207 - "(" shift, and go to state 208 - "{" shift, and go to state 209 - "." shift, and go to state 21 - "{|" shift, and go to state 210 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - DirectCallExpression go to state 211 - IndirectCallExpression go to state 212 - Rule go to state 248 - Rules go to state 249 - SkipRule go to state 214 - ConditionalRule go to state 215 - CaseRule go to state 216 - LetRule go to state 217 - ForallRule go to state 218 - ChooseRule go to state 219 - IterateRule go to state 220 - BlockRule go to state 221 - SequenceRule go to state 222 - UpdateRule go to state 223 - CallRule go to state 224 + 48 MaybeParameters: "(" Parameters ")" . + + $default reduce using rule 48 (MaybeParameters) State 199 - 158 BlockRule: "par" . Rules "endpar" - 160 | "par" . error "endpar" - - error shift, and go to state 250 - "seq" shift, and go to state 198 - "par" shift, and go to state 199 - "skip" shift, and go to state 200 - "let" shift, and go to state 201 - "in" shift, and go to state 19 - "forall" shift, and go to state 202 - "choose" shift, and go to state 203 - "iterate" shift, and go to state 204 - "call" shift, and go to state 205 - "if" shift, and go to state 206 - "case" shift, and go to state 207 - "(" shift, and go to state 208 - "{" shift, and go to state 209 - "." shift, and go to state 21 - "{|" shift, and go to state 210 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - DirectCallExpression go to state 211 - IndirectCallExpression go to state 212 - Rule go to state 248 - Rules go to state 251 - SkipRule go to state 214 - ConditionalRule go to state 215 - CaseRule go to state 216 - LetRule go to state 217 - ForallRule go to state 218 - ChooseRule go to state 219 - IterateRule go to state 220 - BlockRule go to state 221 - SequenceRule go to state 222 - UpdateRule go to state 223 - CallRule go to state 224 + 46 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 248 State 200 - 143 SkipRule: "skip" . + 31 DerivedDefinition: "derived" Identifier MaybeParameters "->" Type . "=" Term - $default reduce using rule 143 (SkipRule) + "=" shift, and go to state 249 State 201 - 153 LetRule: "let" . AttributedVariable "=" Term "in" Rule + 37 Identifiers: Identifier . - "in" shift, and go to state 19 - "[" shift, and go to state 92 - "identifier" shift, and go to state 22 - - Identifier go to state 93 - Variable go to state 94 - AttributedVariable go to state 252 + $default reduce using rule 37 (Identifiers) State 202 - 154 ForallRule: "forall" . AttributedVariable "in" Term "do" Rule - - "in" shift, and go to state 19 - "[" shift, and go to state 92 - "identifier" shift, and go to state 22 + 32 EnumerationDefinition: "enum" Identifier "=" "{" Identifiers . "}" + 36 Identifiers: Identifiers . "," Identifier - Identifier go to state 93 - Variable go to state 94 - AttributedVariable go to state 253 + "}" shift, and go to state 250 + "," shift, and go to state 251 State 203 - 155 ChooseRule: "choose" . AttributedVariable "in" Term "do" Rule - - "in" shift, and go to state 19 - "[" shift, and go to state 92 - "identifier" shift, and go to state 22 - - Identifier go to state 93 - Variable go to state 94 - AttributedVariable go to state 254 + 164 SequenceRule: "seq" . Rules "endseq" + 166 | "seq" . error "endseq" + + error shift, and go to state 252 + "seq" shift, and go to state 203 + "par" shift, and go to state 204 + "skip" shift, and go to state 205 + "let" shift, and go to state 206 + "in" shift, and go to state 21 + "forall" shift, and go to state 207 + "choose" shift, and go to state 208 + "iterate" shift, and go to state 209 + "call" shift, and go to state 210 + "if" shift, and go to state 211 + "case" shift, and go to state 212 + "(" shift, and go to state 213 + "{" shift, and go to state 214 + "." shift, and go to state 23 + "{|" shift, and go to state 215 + "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 216 + IndirectCallExpression go to state 217 + Rule go to state 253 + Rules go to state 254 + SkipRule go to state 219 + ConditionalRule go to state 220 + CaseRule go to state 221 + LetRule go to state 222 + ForallRule go to state 223 + ChooseRule go to state 224 + IterateRule go to state 225 + BlockRule go to state 226 + SequenceRule go to state 227 + UpdateRule go to state 228 + CallRule go to state 229 State 204 - 156 IterateRule: "iterate" . Rule - - "seq" shift, and go to state 198 - "par" shift, and go to state 199 - "skip" shift, and go to state 200 - "let" shift, and go to state 201 - "in" shift, and go to state 19 - "forall" shift, and go to state 202 - "choose" shift, and go to state 203 - "iterate" shift, and go to state 204 - "call" shift, and go to state 205 - "if" shift, and go to state 206 - "case" shift, and go to state 207 - "(" shift, and go to state 208 - "{" shift, and go to state 209 - "." shift, and go to state 21 - "{|" shift, and go to state 210 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - DirectCallExpression go to state 211 - IndirectCallExpression go to state 212 - Rule go to state 255 - SkipRule go to state 214 - ConditionalRule go to state 215 - CaseRule go to state 216 - LetRule go to state 217 - ForallRule go to state 218 - ChooseRule go to state 219 - IterateRule go to state 220 - BlockRule go to state 221 - SequenceRule go to state 222 - UpdateRule go to state 223 - CallRule go to state 224 + 160 BlockRule: "par" . Rules "endpar" + 162 | "par" . error "endpar" + + error shift, and go to state 255 + "seq" shift, and go to state 203 + "par" shift, and go to state 204 + "skip" shift, and go to state 205 + "let" shift, and go to state 206 + "in" shift, and go to state 21 + "forall" shift, and go to state 207 + "choose" shift, and go to state 208 + "iterate" shift, and go to state 209 + "call" shift, and go to state 210 + "if" shift, and go to state 211 + "case" shift, and go to state 212 + "(" shift, and go to state 213 + "{" shift, and go to state 214 + "." shift, and go to state 23 + "{|" shift, and go to state 215 + "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 216 + IndirectCallExpression go to state 217 + Rule go to state 253 + Rules go to state 256 + SkipRule go to state 219 + ConditionalRule go to state 220 + CaseRule go to state 221 + LetRule go to state 222 + ForallRule go to state 223 + ChooseRule go to state 224 + IterateRule go to state 225 + BlockRule go to state 226 + SequenceRule go to state 227 + UpdateRule go to state 228 + CallRule go to state 229 State 205 - 166 CallRule: "call" . DirectCallExpression - 168 | "call" . IndirectCallExpression - - "in" shift, and go to state 19 - "(" shift, and go to state 208 - "." shift, and go to state 21 - "identifier" shift, and go to state 22 + 145 SkipRule: "skip" . - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - DirectCallExpression go to state 256 - IndirectCallExpression go to state 257 + $default reduce using rule 145 (SkipRule) State 206 - 144 ConditionalRule: "if" . Term "then" Rule - 145 | "if" . Term "then" Rule "else" Rule - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 258 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 155 LetRule: "let" . AttributedVariable "=" Term "in" 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 257 State 207 - 146 CaseRule: "case" . Term "of" "{" CaseLabels "}" - 147 | "case" . Term "of" "{" error "}" - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 259 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 156 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 + + Identifier go to state 97 + Variable go to state 98 + AttributedVariable go to state 258 State 208 - 122 IndirectCallExpression: "(" . "*" Term ")" Arguments + 157 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 - "*" shift, and go to state 104 + Identifier go to state 97 + Variable go to state 98 + AttributedVariable go to state 259 State 209 - 157 BlockRule: "{" . Rules "}" - 159 | "{" . error "}" - - error shift, and go to state 260 - "seq" shift, and go to state 198 - "par" shift, and go to state 199 - "skip" shift, and go to state 200 - "let" shift, and go to state 201 - "in" shift, and go to state 19 - "forall" shift, and go to state 202 - "choose" shift, and go to state 203 - "iterate" shift, and go to state 204 - "call" shift, and go to state 205 - "if" shift, and go to state 206 - "case" shift, and go to state 207 - "(" shift, and go to state 208 - "{" shift, and go to state 209 - "." shift, and go to state 21 - "{|" shift, and go to state 210 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - DirectCallExpression go to state 211 - IndirectCallExpression go to state 212 - Rule go to state 248 - Rules go to state 261 - SkipRule go to state 214 - ConditionalRule go to state 215 - CaseRule go to state 216 - LetRule go to state 217 - ForallRule go to state 218 - ChooseRule go to state 219 - IterateRule go to state 220 - BlockRule go to state 221 - SequenceRule go to state 222 - UpdateRule go to state 223 - CallRule go to state 224 + 158 IterateRule: "iterate" . Rule + + "seq" shift, and go to state 203 + "par" shift, and go to state 204 + "skip" shift, and go to state 205 + "let" shift, and go to state 206 + "in" shift, and go to state 21 + "forall" shift, and go to state 207 + "choose" shift, and go to state 208 + "iterate" shift, and go to state 209 + "call" shift, and go to state 210 + "if" shift, and go to state 211 + "case" shift, and go to state 212 + "(" shift, and go to state 213 + "{" shift, and go to state 214 + "." shift, and go to state 23 + "{|" shift, and go to state 215 + "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 216 + IndirectCallExpression go to state 217 + Rule go to state 260 + SkipRule go to state 219 + ConditionalRule go to state 220 + CaseRule go to state 221 + LetRule go to state 222 + ForallRule go to state 223 + ChooseRule go to state 224 + IterateRule go to state 225 + BlockRule go to state 226 + SequenceRule go to state 227 + UpdateRule go to state 228 + CallRule go to state 229 State 210 - 161 SequenceRule: "{|" . Rules "|}" - 163 | "{|" . error "|}" - - error shift, and go to state 262 - "seq" shift, and go to state 198 - "par" shift, and go to state 199 - "skip" shift, and go to state 200 - "let" shift, and go to state 201 - "in" shift, and go to state 19 - "forall" shift, and go to state 202 - "choose" shift, and go to state 203 - "iterate" shift, and go to state 204 - "call" shift, and go to state 205 - "if" shift, and go to state 206 - "case" shift, and go to state 207 - "(" shift, and go to state 208 - "{" shift, and go to state 209 - "." shift, and go to state 21 - "{|" shift, and go to state 210 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - DirectCallExpression go to state 211 - IndirectCallExpression go to state 212 - Rule go to state 248 - Rules go to state 263 - SkipRule go to state 214 - ConditionalRule go to state 215 - CaseRule go to state 216 - LetRule go to state 217 - ForallRule go to state 218 - ChooseRule go to state 219 - IterateRule go to state 220 - BlockRule go to state 221 - SequenceRule go to state 222 - UpdateRule go to state 223 - CallRule go to state 224 + 168 CallRule: "call" . DirectCallExpression + 170 | "call" . IndirectCallExpression + "in" shift, and go to state 21 + "(" shift, and go to state 213 + "." shift, and go to state 23 + "identifier" shift, and go to state 24 -State 211 + Identifier go to state 25 + DotSeparatedIdentifiers go to state 26 + IdentifierPath go to state 62 + DirectCallExpression go to state 261 + IndirectCallExpression go to state 262 - 165 UpdateRule: DirectCallExpression . ":=" Term - 167 CallRule: DirectCallExpression . - ":=" shift, and go to state 264 +State 211 - $default reduce using rule 167 (CallRule) + 146 ConditionalRule: "if" . Term "then" Rule + 147 | "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 263 + 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 State 212 - 169 CallRule: IndirectCallExpression . - - $default reduce using rule 169 (CallRule) + 148 CaseRule: "case" . Term "of" "{" CaseLabels "}" + 149 | "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 264 + 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 State 213 - 128 RuleDefinition: "rule" Identifier MaybeParameters "=" Rule . + 124 IndirectCallExpression: "(" . "*" Term ")" Arguments - $default reduce using rule 128 (RuleDefinition) + "*" shift, and go to state 108 State 214 - 130 Rule: SkipRule . - - $default reduce using rule 130 (Rule) + 159 BlockRule: "{" . Rules "}" + 161 | "{" . error "}" + + error shift, and go to state 265 + "seq" shift, and go to state 203 + "par" shift, and go to state 204 + "skip" shift, and go to state 205 + "let" shift, and go to state 206 + "in" shift, and go to state 21 + "forall" shift, and go to state 207 + "choose" shift, and go to state 208 + "iterate" shift, and go to state 209 + "call" shift, and go to state 210 + "if" shift, and go to state 211 + "case" shift, and go to state 212 + "(" shift, and go to state 213 + "{" shift, and go to state 214 + "." shift, and go to state 23 + "{|" shift, and go to state 215 + "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 216 + IndirectCallExpression go to state 217 + Rule go to state 253 + Rules go to state 266 + SkipRule go to state 219 + ConditionalRule go to state 220 + CaseRule go to state 221 + LetRule go to state 222 + ForallRule go to state 223 + ChooseRule go to state 224 + IterateRule go to state 225 + BlockRule go to state 226 + SequenceRule go to state 227 + UpdateRule go to state 228 + CallRule go to state 229 State 215 - 131 Rule: ConditionalRule . - - $default reduce using rule 131 (Rule) + 163 SequenceRule: "{|" . Rules "|}" + 165 | "{|" . error "|}" + + error shift, and go to state 267 + "seq" shift, and go to state 203 + "par" shift, and go to state 204 + "skip" shift, and go to state 205 + "let" shift, and go to state 206 + "in" shift, and go to state 21 + "forall" shift, and go to state 207 + "choose" shift, and go to state 208 + "iterate" shift, and go to state 209 + "call" shift, and go to state 210 + "if" shift, and go to state 211 + "case" shift, and go to state 212 + "(" shift, and go to state 213 + "{" shift, and go to state 214 + "." shift, and go to state 23 + "{|" shift, and go to state 215 + "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 216 + IndirectCallExpression go to state 217 + Rule go to state 253 + Rules go to state 268 + SkipRule go to state 219 + ConditionalRule go to state 220 + CaseRule go to state 221 + LetRule go to state 222 + ForallRule go to state 223 + ChooseRule go to state 224 + IterateRule go to state 225 + BlockRule go to state 226 + SequenceRule go to state 227 + UpdateRule go to state 228 + CallRule go to state 229 State 216 - 132 Rule: CaseRule . + 167 UpdateRule: DirectCallExpression . ":=" Term + 169 CallRule: DirectCallExpression . - $default reduce using rule 132 (Rule) + ":=" shift, and go to state 269 + + $default reduce using rule 169 (CallRule) State 217 - 133 Rule: LetRule . + 171 CallRule: IndirectCallExpression . - $default reduce using rule 133 (Rule) + $default reduce using rule 171 (CallRule) State 218 - 134 Rule: ForallRule . + 130 RuleDefinition: "rule" Identifier MaybeParameters "=" Rule . - $default reduce using rule 134 (Rule) + $default reduce using rule 130 (RuleDefinition) State 219 - 135 Rule: ChooseRule . + 132 Rule: SkipRule . - $default reduce using rule 135 (Rule) + $default reduce using rule 132 (Rule) State 220 - 136 Rule: IterateRule . + 133 Rule: ConditionalRule . - $default reduce using rule 136 (Rule) + $default reduce using rule 133 (Rule) State 221 - 137 Rule: BlockRule . + 134 Rule: CaseRule . - $default reduce using rule 137 (Rule) + $default reduce using rule 134 (Rule) State 222 - 138 Rule: SequenceRule . + 135 Rule: LetRule . - $default reduce using rule 138 (Rule) + $default reduce using rule 135 (Rule) State 223 - 139 Rule: UpdateRule . + 136 Rule: ForallRule . - $default reduce using rule 139 (Rule) + $default reduce using rule 136 (Rule) State 224 - 140 Rule: CallRule . + 137 Rule: ChooseRule . - $default reduce using rule 140 (Rule) + $default reduce using rule 137 (Rule) State 225 - 129 RuleDefinition: "rule" Identifier MaybeParameters "->" Type . "=" Rule + 138 Rule: IterateRule . - "=" shift, and go to state 265 + $default reduce using rule 138 (Rule) State 226 - 17 FunctionParameters: FunctionParameters "*" . Type - - "in" shift, and go to state 19 - "." shift, and go to state 21 - "identifier" shift, and go to state 22 + 139 Rule: BlockRule . - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 144 - Type go to state 266 - BasicType go to state 146 - ComposedType go to state 147 - RelationType go to state 148 - FixedSizedType go to state 149 + $default reduce using rule 139 (Rule) State 227 - 11 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" . Type MaybeDefined MaybeInitially - - "in" shift, and go to state 19 - "." shift, and go to state 21 - "identifier" shift, and go to state 22 + 140 Rule: SequenceRule . - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 144 - Type go to state 267 - BasicType go to state 146 - ComposedType go to state 147 - RelationType go to state 148 - FixedSizedType go to state 149 + $default reduce using rule 140 (Rule) State 228 - 54 ComposedType: IdentifierPath "<" . Types ">" - 55 RelationType: IdentifierPath "<" . MaybeFunctionParameters "->" Type ">" + 141 Rule: UpdateRule . - "in" shift, and go to state 19 - "." shift, and go to state 21 - "identifier" shift, and go to state 22 - - $default reduce using rule 20 (MaybeFunctionParameters) - - FunctionParameters go to state 142 - MaybeFunctionParameters go to state 268 - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 144 - Type go to state 269 - BasicType go to state 146 - ComposedType go to state 147 - RelationType go to state 148 - FixedSizedType go to state 149 - Types go to state 270 + $default reduce using rule 141 (Rule) State 229 - 56 FixedSizedType: IdentifierPath "'" . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 271 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 142 Rule: CallRule . + $default reduce using rule 142 (Rule) -State 230 - 42 AttributedVariable: "[" Attributes "]" . Variable +State 230 - "in" shift, and go to state 19 - "identifier" shift, and go to state 22 + 131 RuleDefinition: "rule" Identifier MaybeParameters "->" Type . "=" Rule - Identifier go to state 93 - Variable go to state 272 + "=" shift, and go to state 270 State 231 - 40 Variable: Identifier ":" Type . + 56 ComposedType: IdentifierPath "<" . Types ">" + 57 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 21 (MaybeFunctionParameters) - $default reduce using rule 40 (Variable) + FunctionParameters go to state 152 + MaybeFunctionParameters go to state 271 + Identifier go to state 25 + DotSeparatedIdentifiers go to state 26 + IdentifierPath go to state 146 + Type go to state 272 + BasicType go to state 148 + ComposedType go to state 149 + RelationType go to state 150 + FixedSizedType go to state 151 + Types go to state 273 State 232 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - 123 LetExpression: "let" AttributedVariable "=" Term . "in" Term - - "in" shift, and go to state 273 - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "implies" shift, and go to state 118 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - "<" shift, and go to state 122 - ">" 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 129 - "!=" shift, and go to state 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 + 58 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 274 + 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 State 233 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - 126 UniversalQuantifierExpression: "forall" AttributedVariable "in" Term . "holds" Term - - "holds" shift, and go to state 274 - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "implies" shift, and go to state 118 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - "<" shift, and go to state 122 - ">" 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 129 - "!=" shift, and go to state 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 + 18 FunctionParameters: FunctionParameters "*" . Type + + "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 146 + Type go to state 275 + BasicType go to state 148 + ComposedType go to state 149 + RelationType go to state 150 + FixedSizedType go to state 151 State 234 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - 125 ChooseExpression: "choose" AttributedVariable "in" Term . "do" Term - - "do" shift, and go to state 275 - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "implies" shift, and go to state 118 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - "<" shift, and go to state 122 - ">" 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 129 - "!=" shift, and go to state 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 + 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 + + Identifier go to state 25 + DotSeparatedIdentifiers go to state 26 + IdentifierPath go to state 146 + Type go to state 276 + BasicType go to state 148 + ComposedType go to state 149 + RelationType go to state 150 + FixedSizedType go to state 151 State 235 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - 124 ConditionalExpression: "if" Term "then" Term . "else" Term - - "else" shift, and go to state 276 - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "implies" shift, and go to state 118 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - "<" shift, and go to state 122 - ">" 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 129 - "!=" shift, and go to state 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 + 44 AttributedVariable: "[" Attributes "]" . Variable + "in" shift, and go to state 21 + "identifier" shift, and go to state 24 -State 236 + Identifier go to state 97 + Variable go to state 277 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - 127 ExistentialQuantifierExpression: "exists" AttributedVariable "in" Term . "with" Term - - "with" shift, and go to state 277 - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "implies" shift, and go to state 118 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - "<" shift, and go to state 122 - ">" 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 129 - "!=" shift, and go to state 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 +State 236 -State 237 + 42 Variable: Identifier ":" Type . - 122 IndirectCallExpression: "(" "*" Term ")" . Arguments + $default reduce using rule 42 (Variable) - "(" shift, and go to state 113 - Arguments go to state 278 +State 237 + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + 125 LetExpression: "let" AttributedVariable "=" Term . "in" Term + + "in" shift, and go to state 278 + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "implies" shift, and go to state 122 + "+" 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 133 + "!=" shift, and go to state 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 -State 238 - 114 Terms: Terms . "," Term - 119 TwoOrMoreArguments: "(" Term "," Terms . ")" +State 238 - ")" shift, and go to state 279 - "," shift, and go to state 167 + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + 128 UniversalQuantifierExpression: "forall" AttributedVariable "in" Term . "holds" Term + + "holds" shift, and go to state 279 + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "implies" shift, and go to state 122 + "+" 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 133 + "!=" shift, and go to state 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 State 239 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - 110 Range: "[" Term ".." Term . "]" - - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "implies" shift, and go to state 118 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - "]" shift, and go to state 280 - "<" shift, and go to state 122 - ">" 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 129 - "!=" shift, and go to state 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + 127 ChooseExpression: "choose" AttributedVariable "in" Term . "do" Term + + "do" shift, and go to state 280 + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "implies" shift, and go to state 122 + "+" 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 133 + "!=" shift, and go to state 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 State 240 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - 114 Terms: Terms "," Term . - - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "implies" shift, and go to state 118 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - "<" shift, and go to state 122 - ">" 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 129 - "!=" shift, and go to state 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 - - $default reduce using rule 114 (Terms) + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + 126 ConditionalExpression: "if" Term "then" Term . "else" Term + + "else" shift, and go to state 281 + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "implies" shift, and go to state 122 + "+" 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 133 + "!=" shift, and go to state 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 State 241 - 117 Arguments: "(" error ")" . - - $default reduce using rule 117 (Arguments) + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + 129 ExistentialQuantifierExpression: "exists" AttributedVariable "in" Term . "with" Term + + "with" shift, and go to state 282 + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "implies" shift, and go to state 122 + "+" 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 133 + "!=" shift, and go to state 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 State 242 - 116 Arguments: "(" Terms ")" . + 124 IndirectCallExpression: "(" "*" Term ")" . Arguments - $default reduce using rule 116 (Arguments) + "(" shift, and go to state 117 + + Arguments go to state 283 State 243 - 44 Parameters: Parameters "," AttributedVariable . + 116 Terms: Terms . "," Term + 121 TwoOrMoreArguments: "(" Term "," Terms . ")" - $default reduce using rule 44 (Parameters) + ")" shift, and go to state 284 + "," shift, and go to state 172 State 244 - 30 DerivedDefinition: "derived" Identifier MaybeParameters "->" Type "=" . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 281 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + 112 Range: "[" Term ".." Term . "]" + + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "implies" shift, and go to state 122 + "+" shift, and go to state 123 + "-" shift, and go to state 124 + "=" shift, and go to state 125 + "]" shift, and go to state 285 + "<" 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 133 + "!=" shift, and go to state 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 State 245 - 31 EnumerationDefinition: "enum" Identifier "=" "{" Identifiers "}" . - - $default reduce using rule 31 (EnumerationDefinition) + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + 116 Terms: Terms "," Term . + + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "implies" shift, and go to state 122 + "+" 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 133 + "!=" shift, and go to state 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 + + $default reduce using rule 116 (Terms) State 246 - 34 Identifiers: Identifiers "," . Identifier - - "in" shift, and go to state 19 - "identifier" shift, and go to state 22 + 119 Arguments: "(" error ")" . - Identifier go to state 282 + $default reduce using rule 119 (Arguments) State 247 - 164 SequenceRule: "seq" error . "endseq" + 118 Arguments: "(" Terms ")" . - "endseq" shift, and go to state 283 + $default reduce using rule 118 (Arguments) State 248 - 142 Rules: Rule . + 46 Parameters: Parameters "," AttributedVariable . - $default reduce using rule 142 (Rules) + $default reduce using rule 46 (Parameters) State 249 - 141 Rules: Rules . Rule - 162 SequenceRule: "seq" Rules . "endseq" - - "seq" shift, and go to state 198 - "endseq" shift, and go to state 284 - "par" shift, and go to state 199 - "skip" shift, and go to state 200 - "let" shift, and go to state 201 - "in" shift, and go to state 19 - "forall" shift, and go to state 202 - "choose" shift, and go to state 203 - "iterate" shift, and go to state 204 - "call" shift, and go to state 205 - "if" shift, and go to state 206 - "case" shift, and go to state 207 - "(" shift, and go to state 208 - "{" shift, and go to state 209 - "." shift, and go to state 21 - "{|" shift, and go to state 210 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - DirectCallExpression go to state 211 - IndirectCallExpression go to state 212 - Rule go to state 285 - SkipRule go to state 214 - ConditionalRule go to state 215 - CaseRule go to state 216 - LetRule go to state 217 - ForallRule go to state 218 - ChooseRule go to state 219 - IterateRule go to state 220 - BlockRule go to state 221 - SequenceRule go to state 222 - UpdateRule go to state 223 - CallRule go to state 224 + 31 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 286 + 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 State 250 - 160 BlockRule: "par" error . "endpar" + 32 EnumerationDefinition: "enum" Identifier "=" "{" Identifiers "}" . - "endpar" shift, and go to state 286 + $default reduce using rule 32 (EnumerationDefinition) State 251 - 141 Rules: Rules . Rule - 158 BlockRule: "par" Rules . "endpar" - - "seq" shift, and go to state 198 - "par" shift, and go to state 199 - "endpar" shift, and go to state 287 - "skip" shift, and go to state 200 - "let" shift, and go to state 201 - "in" shift, and go to state 19 - "forall" shift, and go to state 202 - "choose" shift, and go to state 203 - "iterate" shift, and go to state 204 - "call" shift, and go to state 205 - "if" shift, and go to state 206 - "case" shift, and go to state 207 - "(" shift, and go to state 208 - "{" shift, and go to state 209 - "." shift, and go to state 21 - "{|" shift, and go to state 210 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - DirectCallExpression go to state 211 - IndirectCallExpression go to state 212 - Rule go to state 285 - SkipRule go to state 214 - ConditionalRule go to state 215 - CaseRule go to state 216 - LetRule go to state 217 - ForallRule go to state 218 - ChooseRule go to state 219 - IterateRule go to state 220 - BlockRule go to state 221 - SequenceRule go to state 222 - UpdateRule go to state 223 - CallRule go to state 224 + 36 Identifiers: Identifiers "," . Identifier + + "in" shift, and go to state 21 + "identifier" shift, and go to state 24 + + Identifier go to state 287 State 252 - 153 LetRule: "let" AttributedVariable . "=" Term "in" Rule + 166 SequenceRule: "seq" error . "endseq" - "=" shift, and go to state 288 + "endseq" shift, and go to state 288 State 253 - 154 ForallRule: "forall" AttributedVariable . "in" Term "do" Rule + 144 Rules: Rule . - "in" shift, and go to state 289 + $default reduce using rule 144 (Rules) State 254 - 155 ChooseRule: "choose" AttributedVariable . "in" Term "do" Rule - - "in" shift, and go to state 290 + 143 Rules: Rules . Rule + 164 SequenceRule: "seq" Rules . "endseq" + + "seq" shift, and go to state 203 + "endseq" shift, and go to state 289 + "par" shift, and go to state 204 + "skip" shift, and go to state 205 + "let" shift, and go to state 206 + "in" shift, and go to state 21 + "forall" shift, and go to state 207 + "choose" shift, and go to state 208 + "iterate" shift, and go to state 209 + "call" shift, and go to state 210 + "if" shift, and go to state 211 + "case" shift, and go to state 212 + "(" shift, and go to state 213 + "{" shift, and go to state 214 + "." shift, and go to state 23 + "{|" shift, and go to state 215 + "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 216 + IndirectCallExpression go to state 217 + Rule go to state 290 + SkipRule go to state 219 + ConditionalRule go to state 220 + CaseRule go to state 221 + LetRule go to state 222 + ForallRule go to state 223 + ChooseRule go to state 224 + IterateRule go to state 225 + BlockRule go to state 226 + SequenceRule go to state 227 + UpdateRule go to state 228 + CallRule go to state 229 State 255 - 156 IterateRule: "iterate" Rule . + 162 BlockRule: "par" error . "endpar" - $default reduce using rule 156 (IterateRule) + "endpar" shift, and go to state 291 State 256 - 166 CallRule: "call" DirectCallExpression . - - $default reduce using rule 166 (CallRule) + 143 Rules: Rules . Rule + 160 BlockRule: "par" Rules . "endpar" + + "seq" shift, and go to state 203 + "par" shift, and go to state 204 + "endpar" shift, and go to state 292 + "skip" shift, and go to state 205 + "let" shift, and go to state 206 + "in" shift, and go to state 21 + "forall" shift, and go to state 207 + "choose" shift, and go to state 208 + "iterate" shift, and go to state 209 + "call" shift, and go to state 210 + "if" shift, and go to state 211 + "case" shift, and go to state 212 + "(" shift, and go to state 213 + "{" shift, and go to state 214 + "." shift, and go to state 23 + "{|" shift, and go to state 215 + "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 216 + IndirectCallExpression go to state 217 + Rule go to state 290 + SkipRule go to state 219 + ConditionalRule go to state 220 + CaseRule go to state 221 + LetRule go to state 222 + ForallRule go to state 223 + ChooseRule go to state 224 + IterateRule go to state 225 + BlockRule go to state 226 + SequenceRule go to state 227 + UpdateRule go to state 228 + CallRule go to state 229 State 257 - 168 CallRule: "call" IndirectCallExpression . + 155 LetRule: "let" AttributedVariable . "=" Term "in" Rule - $default reduce using rule 168 (CallRule) + "=" shift, and go to state 293 State 258 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - 144 ConditionalRule: "if" Term . "then" Rule - 145 | "if" Term . "then" Rule "else" Rule - - "then" shift, and go to state 291 - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "implies" shift, and go to state 118 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - "<" shift, and go to state 122 - ">" 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 129 - "!=" shift, and go to state 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 + 156 ForallRule: "forall" AttributedVariable . "in" Term "do" Rule + + "in" shift, and go to state 294 State 259 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - 146 CaseRule: "case" Term . "of" "{" CaseLabels "}" - 147 | "case" Term . "of" "{" error "}" - - "of" shift, and go to state 292 - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "implies" shift, and go to state 118 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - "<" shift, and go to state 122 - ">" 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 129 - "!=" shift, and go to state 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 + 157 ChooseRule: "choose" AttributedVariable . "in" Term "do" Rule + + "in" shift, and go to state 295 State 260 - 159 BlockRule: "{" error . "}" + 158 IterateRule: "iterate" Rule . - "}" shift, and go to state 293 + $default reduce using rule 158 (IterateRule) State 261 - 141 Rules: Rules . Rule - 157 BlockRule: "{" Rules . "}" - - "seq" shift, and go to state 198 - "par" shift, and go to state 199 - "skip" shift, and go to state 200 - "let" shift, and go to state 201 - "in" shift, and go to state 19 - "forall" shift, and go to state 202 - "choose" shift, and go to state 203 - "iterate" shift, and go to state 204 - "call" shift, and go to state 205 - "if" shift, and go to state 206 - "case" shift, and go to state 207 - "(" shift, and go to state 208 - "{" shift, and go to state 209 - "}" shift, and go to state 294 - "." shift, and go to state 21 - "{|" shift, and go to state 210 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - DirectCallExpression go to state 211 - IndirectCallExpression go to state 212 - Rule go to state 285 - SkipRule go to state 214 - ConditionalRule go to state 215 - CaseRule go to state 216 - LetRule go to state 217 - ForallRule go to state 218 - ChooseRule go to state 219 - IterateRule go to state 220 - BlockRule go to state 221 - SequenceRule go to state 222 - UpdateRule go to state 223 - CallRule go to state 224 + 168 CallRule: "call" DirectCallExpression . + + $default reduce using rule 168 (CallRule) State 262 - 163 SequenceRule: "{|" error . "|}" + 170 CallRule: "call" IndirectCallExpression . - "|}" shift, and go to state 295 + $default reduce using rule 170 (CallRule) State 263 - 141 Rules: Rules . Rule - 161 SequenceRule: "{|" Rules . "|}" - - "seq" shift, and go to state 198 - "par" shift, and go to state 199 - "skip" shift, and go to state 200 - "let" shift, and go to state 201 - "in" shift, and go to state 19 - "forall" shift, and go to state 202 - "choose" shift, and go to state 203 - "iterate" shift, and go to state 204 - "call" shift, and go to state 205 - "if" shift, and go to state 206 - "case" shift, and go to state 207 - "(" shift, and go to state 208 - "{" shift, and go to state 209 - "." shift, and go to state 21 - "{|" shift, and go to state 210 - "|}" shift, and go to state 296 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - DirectCallExpression go to state 211 - IndirectCallExpression go to state 212 - Rule go to state 285 - SkipRule go to state 214 - ConditionalRule go to state 215 - CaseRule go to state 216 - LetRule go to state 217 - ForallRule go to state 218 - ChooseRule go to state 219 - IterateRule go to state 220 - BlockRule go to state 221 - SequenceRule go to state 222 - UpdateRule go to state 223 - CallRule go to state 224 + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + 146 ConditionalRule: "if" Term . "then" Rule + 147 | "if" Term . "then" Rule "else" Rule + + "then" shift, and go to state 296 + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "implies" shift, and go to state 122 + "+" 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 133 + "!=" shift, and go to state 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 State 264 - 165 UpdateRule: DirectCallExpression ":=" . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 297 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + 148 CaseRule: "case" Term . "of" "{" CaseLabels "}" + 149 | "case" Term . "of" "{" error "}" + + "of" shift, and go to state 297 + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "implies" shift, and go to state 122 + "+" 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 133 + "!=" shift, and go to state 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 State 265 - 129 RuleDefinition: "rule" Identifier MaybeParameters "->" Type "=" . Rule - - "seq" shift, and go to state 198 - "par" shift, and go to state 199 - "skip" shift, and go to state 200 - "let" shift, and go to state 201 - "in" shift, and go to state 19 - "forall" shift, and go to state 202 - "choose" shift, and go to state 203 - "iterate" shift, and go to state 204 - "call" shift, and go to state 205 - "if" shift, and go to state 206 - "case" shift, and go to state 207 - "(" shift, and go to state 208 - "{" shift, and go to state 209 - "." shift, and go to state 21 - "{|" shift, and go to state 210 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - DirectCallExpression go to state 211 - IndirectCallExpression go to state 212 - Rule go to state 298 - SkipRule go to state 214 - ConditionalRule go to state 215 - CaseRule go to state 216 - LetRule go to state 217 - ForallRule go to state 218 - ChooseRule go to state 219 - IterateRule go to state 220 - BlockRule go to state 221 - SequenceRule go to state 222 - UpdateRule go to state 223 - CallRule go to state 224 + 161 BlockRule: "{" error . "}" + "}" shift, and go to state 298 -State 266 - 17 FunctionParameters: FunctionParameters "*" Type . +State 266 - $default reduce using rule 17 (FunctionParameters) + 143 Rules: Rules . Rule + 159 BlockRule: "{" Rules . "}" + + "seq" shift, and go to state 203 + "par" shift, and go to state 204 + "skip" shift, and go to state 205 + "let" shift, and go to state 206 + "in" shift, and go to state 21 + "forall" shift, and go to state 207 + "choose" shift, and go to state 208 + "iterate" shift, and go to state 209 + "call" shift, and go to state 210 + "if" shift, and go to state 211 + "case" shift, and go to state 212 + "(" shift, and go to state 213 + "{" shift, and go to state 214 + "}" shift, and go to state 299 + "." shift, and go to state 23 + "{|" shift, and go to state 215 + "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 216 + IndirectCallExpression go to state 217 + Rule go to state 290 + SkipRule go to state 219 + ConditionalRule go to state 220 + CaseRule go to state 221 + LetRule go to state 222 + ForallRule go to state 223 + ChooseRule go to state 224 + IterateRule go to state 225 + BlockRule go to state 226 + SequenceRule go to state 227 + UpdateRule go to state 228 + CallRule go to state 229 State 267 - 11 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" Type . MaybeDefined MaybeInitially - - "defined" shift, and go to state 299 - - $default reduce using rule 16 (MaybeDefined) + 165 SequenceRule: "{|" error . "|}" - MaybeDefined go to state 300 + "|}" shift, and go to state 300 State 268 - 55 RelationType: IdentifierPath "<" MaybeFunctionParameters . "->" Type ">" - - "->" shift, and go to state 301 + 143 Rules: Rules . Rule + 163 SequenceRule: "{|" Rules . "|}" + + "seq" shift, and go to state 203 + "par" shift, and go to state 204 + "skip" shift, and go to state 205 + "let" shift, and go to state 206 + "in" shift, and go to state 21 + "forall" shift, and go to state 207 + "choose" shift, and go to state 208 + "iterate" shift, and go to state 209 + "call" shift, and go to state 210 + "if" shift, and go to state 211 + "case" shift, and go to state 212 + "(" shift, and go to state 213 + "{" shift, and go to state 214 + "." shift, and go to state 23 + "{|" shift, and go to state 215 + "|}" shift, and go to state 301 + "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 216 + IndirectCallExpression go to state 217 + Rule go to state 290 + SkipRule go to state 219 + ConditionalRule go to state 220 + CaseRule go to state 221 + LetRule go to state 222 + ForallRule go to state 223 + ChooseRule go to state 224 + IterateRule go to state 225 + BlockRule go to state 226 + SequenceRule go to state 227 + UpdateRule go to state 228 + CallRule go to state 229 State 269 - 18 FunctionParameters: Type . - 58 Types: Type . - - "," reduce using rule 58 (Types) - ">" reduce using rule 58 (Types) - $default reduce using rule 18 (FunctionParameters) + 167 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 302 + 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 State 270 - 54 ComposedType: IdentifierPath "<" Types . ">" - 57 Types: Types . "," Type - - "," shift, and go to state 302 - ">" shift, and go to state 303 + 131 RuleDefinition: "rule" Identifier MaybeParameters "->" Type "=" . Rule + + "seq" shift, and go to state 203 + "par" shift, and go to state 204 + "skip" shift, and go to state 205 + "let" shift, and go to state 206 + "in" shift, and go to state 21 + "forall" shift, and go to state 207 + "choose" shift, and go to state 208 + "iterate" shift, and go to state 209 + "call" shift, and go to state 210 + "if" shift, and go to state 211 + "case" shift, and go to state 212 + "(" shift, and go to state 213 + "{" shift, and go to state 214 + "." shift, and go to state 23 + "{|" shift, and go to state 215 + "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 216 + IndirectCallExpression go to state 217 + Rule go to state 303 + SkipRule go to state 219 + ConditionalRule go to state 220 + CaseRule go to state 221 + LetRule go to state 222 + ForallRule go to state 223 + ChooseRule go to state 224 + IterateRule go to state 225 + BlockRule go to state 226 + SequenceRule go to state 227 + UpdateRule go to state 228 + CallRule go to state 229 State 271 - 56 FixedSizedType: IdentifierPath "'" Term . - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "implies" shift, and go to state 118 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "<" shift, and go to state 122 - "/" shift, and go to state 125 - "%" shift, and go to state 126 - "^" shift, and go to state 127 - "=>" 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 56 (FixedSizedType) + 57 RelationType: IdentifierPath "<" MaybeFunctionParameters . "->" Type ">" + + "->" shift, and go to state 304 State 272 - 42 AttributedVariable: "[" Attributes "]" Variable . + 19 FunctionParameters: Type . + 60 Types: Type . - $default reduce using rule 42 (AttributedVariable) + "," reduce using rule 60 (Types) + ">" reduce using rule 60 (Types) + $default reduce using rule 19 (FunctionParameters) State 273 - 123 LetExpression: "let" AttributedVariable "=" Term "in" . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 304 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 56 ComposedType: IdentifierPath "<" Types . ">" + 59 Types: Types . "," Type + + "," shift, and go to state 305 + ">" shift, and go to state 306 State 274 - 126 UniversalQuantifierExpression: "forall" AttributedVariable "in" Term "holds" . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 305 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 58 FixedSizedType: IdentifierPath "'" Term . + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "implies" shift, and go to state 122 + "+" shift, and go to state 123 + "-" shift, and go to state 124 + "<" shift, and go to state 126 + "/" shift, and go to state 129 + "%" shift, and go to state 130 + "^" shift, and go to state 131 + "=>" 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 58 (FixedSizedType) State 275 - 125 ChooseExpression: "choose" AttributedVariable "in" Term "do" . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 306 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 18 FunctionParameters: FunctionParameters "*" Type . + + $default reduce using rule 18 (FunctionParameters) State 276 - 124 ConditionalExpression: "if" Term "then" Term "else" . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 307 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 12 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" Type . MaybeDefined MaybeInitially + + "defined" shift, and go to state 307 + + $default reduce using rule 17 (MaybeDefined) + + MaybeDefined go to state 308 State 277 - 127 ExistentialQuantifierExpression: "exists" AttributedVariable "in" Term "with" . Term - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 308 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 44 AttributedVariable: "[" Attributes "]" Variable . + $default reduce using rule 44 (AttributedVariable) -State 278 - 122 IndirectCallExpression: "(" "*" Term ")" Arguments . +State 278 - $default reduce using rule 122 (IndirectCallExpression) + 125 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 309 + 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 State 279 - 119 TwoOrMoreArguments: "(" Term "," Terms ")" . - - $default reduce using rule 119 (TwoOrMoreArguments) + 128 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 310 + 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 State 280 - 110 Range: "[" Term ".." Term "]" . - - $default reduce using rule 110 (Range) + 127 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 311 + 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 State 281 - 30 DerivedDefinition: "derived" Identifier MaybeParameters "->" Type "=" Term . - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "implies" shift, and go to state 118 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - "<" shift, and go to state 122 - ">" 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 129 - "!=" shift, and go to state 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 - - $default reduce using rule 30 (DerivedDefinition) + 126 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 312 + 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 State 282 - 34 Identifiers: Identifiers "," Identifier . - - $default reduce using rule 34 (Identifiers) + 129 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 313 + 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 State 283 - 164 SequenceRule: "seq" error "endseq" . + 124 IndirectCallExpression: "(" "*" Term ")" Arguments . - $default reduce using rule 164 (SequenceRule) + $default reduce using rule 124 (IndirectCallExpression) State 284 - 162 SequenceRule: "seq" Rules "endseq" . + 121 TwoOrMoreArguments: "(" Term "," Terms ")" . - $default reduce using rule 162 (SequenceRule) + $default reduce using rule 121 (TwoOrMoreArguments) State 285 - 141 Rules: Rules Rule . + 112 Range: "[" Term ".." Term "]" . - $default reduce using rule 141 (Rules) + $default reduce using rule 112 (Range) State 286 - 160 BlockRule: "par" error "endpar" . - - $default reduce using rule 160 (BlockRule) + 31 DerivedDefinition: "derived" Identifier MaybeParameters "->" Type "=" Term . + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "implies" shift, and go to state 122 + "+" 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 133 + "!=" shift, and go to state 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 + + $default reduce using rule 31 (DerivedDefinition) State 287 - 158 BlockRule: "par" Rules "endpar" . + 36 Identifiers: Identifiers "," Identifier . - $default reduce using rule 158 (BlockRule) + $default reduce using rule 36 (Identifiers) State 288 - 153 LetRule: "let" AttributedVariable "=" . Term "in" Rule - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 309 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 166 SequenceRule: "seq" error "endseq" . + + $default reduce using rule 166 (SequenceRule) State 289 - 154 ForallRule: "forall" AttributedVariable "in" . Term "do" Rule - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 310 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 164 SequenceRule: "seq" Rules "endseq" . + + $default reduce using rule 164 (SequenceRule) State 290 - 155 ChooseRule: "choose" AttributedVariable "in" . Term "do" Rule - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 311 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 143 Rules: Rules Rule . + + $default reduce using rule 143 (Rules) State 291 - 144 ConditionalRule: "if" Term "then" . Rule - 145 | "if" Term "then" . Rule "else" Rule - - "seq" shift, and go to state 198 - "par" shift, and go to state 199 - "skip" shift, and go to state 200 - "let" shift, and go to state 201 - "in" shift, and go to state 19 - "forall" shift, and go to state 202 - "choose" shift, and go to state 203 - "iterate" shift, and go to state 204 - "call" shift, and go to state 205 - "if" shift, and go to state 206 - "case" shift, and go to state 207 - "(" shift, and go to state 208 - "{" shift, and go to state 209 - "." shift, and go to state 21 - "{|" shift, and go to state 210 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - DirectCallExpression go to state 211 - IndirectCallExpression go to state 212 - Rule go to state 312 - SkipRule go to state 214 - ConditionalRule go to state 215 - CaseRule go to state 216 - LetRule go to state 217 - ForallRule go to state 218 - ChooseRule go to state 219 - IterateRule go to state 220 - BlockRule go to state 221 - SequenceRule go to state 222 - UpdateRule go to state 223 - CallRule go to state 224 + 162 BlockRule: "par" error "endpar" . + + $default reduce using rule 162 (BlockRule) State 292 - 146 CaseRule: "case" Term "of" . "{" CaseLabels "}" - 147 | "case" Term "of" . "{" error "}" + 160 BlockRule: "par" Rules "endpar" . - "{" shift, and go to state 313 + $default reduce using rule 160 (BlockRule) State 293 - 159 BlockRule: "{" error "}" . - - $default reduce using rule 159 (BlockRule) + 155 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 314 + 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 State 294 - 157 BlockRule: "{" Rules "}" . - - $default reduce using rule 157 (BlockRule) + 156 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 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 State 295 - 163 SequenceRule: "{|" error "|}" . - - $default reduce using rule 163 (SequenceRule) + 157 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 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 State 296 - 161 SequenceRule: "{|" Rules "|}" . - - $default reduce using rule 161 (SequenceRule) + 146 ConditionalRule: "if" Term "then" . Rule + 147 | "if" Term "then" . Rule "else" Rule + + "seq" shift, and go to state 203 + "par" shift, and go to state 204 + "skip" shift, and go to state 205 + "let" shift, and go to state 206 + "in" shift, and go to state 21 + "forall" shift, and go to state 207 + "choose" shift, and go to state 208 + "iterate" shift, and go to state 209 + "call" shift, and go to state 210 + "if" shift, and go to state 211 + "case" shift, and go to state 212 + "(" shift, and go to state 213 + "{" shift, and go to state 214 + "." shift, and go to state 23 + "{|" shift, and go to state 215 + "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 216 + IndirectCallExpression go to state 217 + Rule go to state 317 + SkipRule go to state 219 + ConditionalRule go to state 220 + CaseRule go to state 221 + LetRule go to state 222 + ForallRule go to state 223 + ChooseRule go to state 224 + IterateRule go to state 225 + BlockRule go to state 226 + SequenceRule go to state 227 + UpdateRule go to state 228 + CallRule go to state 229 State 297 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - 165 UpdateRule: DirectCallExpression ":=" Term . - - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "implies" shift, and go to state 118 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - "<" shift, and go to state 122 - ">" 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 129 - "!=" shift, and go to state 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 - - $default reduce using rule 165 (UpdateRule) + 148 CaseRule: "case" Term "of" . "{" CaseLabels "}" + 149 | "case" Term "of" . "{" error "}" + + "{" shift, and go to state 318 State 298 - 129 RuleDefinition: "rule" Identifier MaybeParameters "->" Type "=" Rule . + 161 BlockRule: "{" error "}" . - $default reduce using rule 129 (RuleDefinition) + $default reduce using rule 161 (BlockRule) State 299 - 15 MaybeDefined: "defined" . "{" Term "}" + 159 BlockRule: "{" Rules "}" . - "{" shift, and go to state 314 + $default reduce using rule 159 (BlockRule) State 300 - 11 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined . MaybeInitially - - "initially" shift, and go to state 315 - - $default reduce using rule 14 (MaybeInitially) + 165 SequenceRule: "{|" error "|}" . - MaybeInitially go to state 316 + $default reduce using rule 165 (SequenceRule) State 301 - 55 RelationType: IdentifierPath "<" MaybeFunctionParameters "->" . Type ">" - - "in" shift, and go to state 19 - "." shift, and go to state 21 - "identifier" shift, and go to state 22 + 163 SequenceRule: "{|" Rules "|}" . - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 144 - Type go to state 317 - BasicType go to state 146 - ComposedType go to state 147 - RelationType go to state 148 - FixedSizedType go to state 149 + $default reduce using rule 163 (SequenceRule) State 302 - 57 Types: Types "," . Type - - "in" shift, and go to state 19 - "." shift, and go to state 21 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 144 - Type go to state 318 - BasicType go to state 146 - ComposedType go to state 147 - RelationType go to state 148 - FixedSizedType go to state 149 + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + 167 UpdateRule: DirectCallExpression ":=" Term . + + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "implies" shift, and go to state 122 + "+" 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 133 + "!=" shift, and go to state 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 + + $default reduce using rule 167 (UpdateRule) State 303 - 54 ComposedType: IdentifierPath "<" Types ">" . + 131 RuleDefinition: "rule" Identifier MaybeParameters "->" Type "=" Rule . - $default reduce using rule 54 (ComposedType) + $default reduce using rule 131 (RuleDefinition) State 304 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - 123 LetExpression: "let" AttributedVariable "=" Term "in" Term . - - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "implies" shift, and go to state 118 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - "<" shift, and go to state 122 - ">" 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 129 - "!=" shift, and go to state 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 - - $default reduce using rule 123 (LetExpression) + 57 RelationType: IdentifierPath "<" MaybeFunctionParameters "->" . Type ">" + + "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 146 + Type go to state 319 + BasicType go to state 148 + ComposedType go to state 149 + RelationType go to state 150 + FixedSizedType go to state 151 State 305 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - 126 UniversalQuantifierExpression: "forall" AttributedVariable "in" Term "holds" Term . - - $default reduce using rule 126 (UniversalQuantifierExpression) + 59 Types: Types "," . Type + + "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 146 + Type go to state 320 + BasicType go to state 148 + ComposedType go to state 149 + RelationType go to state 150 + FixedSizedType go to state 151 State 306 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - 125 ChooseExpression: "choose" AttributedVariable "in" Term "do" Term . - - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "implies" shift, and go to state 118 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - "<" shift, and go to state 122 - ">" 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 129 - "!=" shift, and go to state 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 - - $default reduce using rule 125 (ChooseExpression) + 56 ComposedType: IdentifierPath "<" Types ">" . + + $default reduce using rule 56 (ComposedType) State 307 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - 124 ConditionalExpression: "if" Term "then" Term "else" Term . - - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "implies" shift, and go to state 118 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - "<" shift, and go to state 122 - ">" 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 129 - "!=" shift, and go to state 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 - - $default reduce using rule 124 (ConditionalExpression) + 16 MaybeDefined: "defined" . "{" Term "}" + + "{" shift, and go to state 321 State 308 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - 127 ExistentialQuantifierExpression: "exists" AttributedVariable "in" Term "with" Term . - - $default reduce using rule 127 (ExistentialQuantifierExpression) + 12 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined . MaybeInitially + + "initially" shift, and go to state 322 + + $default reduce using rule 15 (MaybeInitially) + + MaybeInitially go to state 323 State 309 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - 153 LetRule: "let" AttributedVariable "=" Term . "in" Rule - - "in" shift, and go to state 319 - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "implies" shift, and go to state 118 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - "<" shift, and go to state 122 - ">" 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 129 - "!=" shift, and go to state 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + 125 LetExpression: "let" AttributedVariable "=" Term "in" Term . + + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "implies" shift, and go to state 122 + "+" 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 133 + "!=" shift, and go to state 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 + + $default reduce using rule 125 (LetExpression) State 310 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - 154 ForallRule: "forall" AttributedVariable "in" Term . "do" Rule - - "do" shift, and go to state 320 - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "implies" shift, and go to state 118 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - "<" shift, and go to state 122 - ">" 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 129 - "!=" shift, and go to state 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + 128 UniversalQuantifierExpression: "forall" AttributedVariable "in" Term "holds" Term . + + $default reduce using rule 128 (UniversalQuantifierExpression) State 311 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - 155 ChooseRule: "choose" AttributedVariable "in" Term . "do" Rule - - "do" shift, and go to state 321 - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "implies" shift, and go to state 118 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - "<" shift, and go to state 122 - ">" 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 129 - "!=" shift, and go to state 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + 127 ChooseExpression: "choose" AttributedVariable "in" Term "do" Term . + + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "implies" shift, and go to state 122 + "+" 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 133 + "!=" shift, and go to state 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 + + $default reduce using rule 127 (ChooseExpression) State 312 - 144 ConditionalRule: "if" Term "then" Rule . - 145 | "if" Term "then" Rule . "else" Rule - - "else" shift, and go to state 322 - - $default reduce using rule 144 (ConditionalRule) + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + 126 ConditionalExpression: "if" Term "then" Term "else" Term . + + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "implies" shift, and go to state 122 + "+" 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 133 + "!=" shift, and go to state 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 + + $default reduce using rule 126 (ConditionalExpression) State 313 - 146 CaseRule: "case" Term "of" "{" . CaseLabels "}" - 147 | "case" Term "of" "{" . error "}" - - error shift, and go to state 323 - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "default" shift, and go to state 324 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "_" shift, and go to state 325 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 326 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 - CaseLabel go to state 327 - CaseLabels go to state 328 + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + 129 ExistentialQuantifierExpression: "exists" AttributedVariable "in" Term "with" Term . + + $default reduce using rule 129 (ExistentialQuantifierExpression) State 314 - 15 MaybeDefined: "defined" "{" . Term "}" - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 329 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + 155 LetRule: "let" AttributedVariable "=" Term . "in" Rule + + "in" shift, and go to state 324 + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "implies" shift, and go to state 122 + "+" 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 133 + "!=" shift, and go to state 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 State 315 - 13 MaybeInitially: "initially" . "{" MaybeInitializers "}" - - "{" shift, and go to state 330 + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + 156 ForallRule: "forall" AttributedVariable "in" Term . "do" Rule + + "do" shift, and go to state 325 + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "implies" shift, and go to state 122 + "+" 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 133 + "!=" shift, and go to state 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 State 316 - 11 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially . - - $default reduce using rule 11 (FunctionDefinition) + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + 157 ChooseRule: "choose" AttributedVariable "in" Term . "do" Rule + + "do" shift, and go to state 326 + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "implies" shift, and go to state 122 + "+" 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 133 + "!=" shift, and go to state 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 State 317 - 55 RelationType: IdentifierPath "<" MaybeFunctionParameters "->" Type . ">" + 146 ConditionalRule: "if" Term "then" Rule . + 147 | "if" Term "then" Rule . "else" Rule - ">" shift, and go to state 331 + "else" shift, and go to state 327 + $default reduce using rule 146 (ConditionalRule) -State 318 - 57 Types: Types "," Type . +State 318 - $default reduce using rule 57 (Types) + 148 CaseRule: "case" Term "of" "{" . CaseLabels "}" + 149 | "case" Term "of" "{" . error "}" + + error shift, and go to state 328 + "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 329 + "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 330 + "@" 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 331 + 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 332 + CaseLabels go to state 333 State 319 - 153 LetRule: "let" AttributedVariable "=" Term "in" . Rule - - "seq" shift, and go to state 198 - "par" shift, and go to state 199 - "skip" shift, and go to state 200 - "let" shift, and go to state 201 - "in" shift, and go to state 19 - "forall" shift, and go to state 202 - "choose" shift, and go to state 203 - "iterate" shift, and go to state 204 - "call" shift, and go to state 205 - "if" shift, and go to state 206 - "case" shift, and go to state 207 - "(" shift, and go to state 208 - "{" shift, and go to state 209 - "." shift, and go to state 21 - "{|" shift, and go to state 210 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - DirectCallExpression go to state 211 - IndirectCallExpression go to state 212 - Rule go to state 332 - SkipRule go to state 214 - ConditionalRule go to state 215 - CaseRule go to state 216 - LetRule go to state 217 - ForallRule go to state 218 - ChooseRule go to state 219 - IterateRule go to state 220 - BlockRule go to state 221 - SequenceRule go to state 222 - UpdateRule go to state 223 - CallRule go to state 224 + 57 RelationType: IdentifierPath "<" MaybeFunctionParameters "->" Type . ">" + + ">" shift, and go to state 334 State 320 - 154 ForallRule: "forall" AttributedVariable "in" Term "do" . Rule - - "seq" shift, and go to state 198 - "par" shift, and go to state 199 - "skip" shift, and go to state 200 - "let" shift, and go to state 201 - "in" shift, and go to state 19 - "forall" shift, and go to state 202 - "choose" shift, and go to state 203 - "iterate" shift, and go to state 204 - "call" shift, and go to state 205 - "if" shift, and go to state 206 - "case" shift, and go to state 207 - "(" shift, and go to state 208 - "{" shift, and go to state 209 - "." shift, and go to state 21 - "{|" shift, and go to state 210 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - DirectCallExpression go to state 211 - IndirectCallExpression go to state 212 - Rule go to state 333 - SkipRule go to state 214 - ConditionalRule go to state 215 - CaseRule go to state 216 - LetRule go to state 217 - ForallRule go to state 218 - ChooseRule go to state 219 - IterateRule go to state 220 - BlockRule go to state 221 - SequenceRule go to state 222 - UpdateRule go to state 223 - CallRule go to state 224 + 59 Types: Types "," Type . + + $default reduce using rule 59 (Types) State 321 - 155 ChooseRule: "choose" AttributedVariable "in" Term "do" . Rule - - "seq" shift, and go to state 198 - "par" shift, and go to state 199 - "skip" shift, and go to state 200 - "let" shift, and go to state 201 - "in" shift, and go to state 19 - "forall" shift, and go to state 202 - "choose" shift, and go to state 203 - "iterate" shift, and go to state 204 - "call" shift, and go to state 205 - "if" shift, and go to state 206 - "case" shift, and go to state 207 - "(" shift, and go to state 208 - "{" shift, and go to state 209 - "." shift, and go to state 21 - "{|" shift, and go to state 210 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - DirectCallExpression go to state 211 - IndirectCallExpression go to state 212 - Rule go to state 334 - SkipRule go to state 214 - ConditionalRule go to state 215 - CaseRule go to state 216 - LetRule go to state 217 - ForallRule go to state 218 - ChooseRule go to state 219 - IterateRule go to state 220 - BlockRule go to state 221 - SequenceRule go to state 222 - UpdateRule go to state 223 - CallRule go to state 224 + 16 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 335 + 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 State 322 - 145 ConditionalRule: "if" Term "then" Rule "else" . Rule - - "seq" shift, and go to state 198 - "par" shift, and go to state 199 - "skip" shift, and go to state 200 - "let" shift, and go to state 201 - "in" shift, and go to state 19 - "forall" shift, and go to state 202 - "choose" shift, and go to state 203 - "iterate" shift, and go to state 204 - "call" shift, and go to state 205 - "if" shift, and go to state 206 - "case" shift, and go to state 207 - "(" shift, and go to state 208 - "{" shift, and go to state 209 - "." shift, and go to state 21 - "{|" shift, and go to state 210 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - DirectCallExpression go to state 211 - IndirectCallExpression go to state 212 - Rule go to state 335 - SkipRule go to state 214 - ConditionalRule go to state 215 - CaseRule go to state 216 - LetRule go to state 217 - ForallRule go to state 218 - ChooseRule go to state 219 - IterateRule go to state 220 - BlockRule go to state 221 - SequenceRule go to state 222 - UpdateRule go to state 223 - CallRule go to state 224 + 14 MaybeInitially: "initially" . "{" MaybeInitializers "}" + + "{" shift, and go to state 336 State 323 - 147 CaseRule: "case" Term "of" "{" error . "}" + 12 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially . - "}" shift, and go to state 336 + $default reduce using rule 12 (FunctionDefinition) State 324 - 148 CaseLabel: "default" . ":" Rule - - ":" shift, and go to state 337 + 155 LetRule: "let" AttributedVariable "=" Term "in" . Rule + + "seq" shift, and go to state 203 + "par" shift, and go to state 204 + "skip" shift, and go to state 205 + "let" shift, and go to state 206 + "in" shift, and go to state 21 + "forall" shift, and go to state 207 + "choose" shift, and go to state 208 + "iterate" shift, and go to state 209 + "call" shift, and go to state 210 + "if" shift, and go to state 211 + "case" shift, and go to state 212 + "(" shift, and go to state 213 + "{" shift, and go to state 214 + "." shift, and go to state 23 + "{|" shift, and go to state 215 + "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 216 + IndirectCallExpression go to state 217 + Rule go to state 337 + SkipRule go to state 219 + ConditionalRule go to state 220 + CaseRule go to state 221 + LetRule go to state 222 + ForallRule go to state 223 + ChooseRule go to state 224 + IterateRule go to state 225 + BlockRule go to state 226 + SequenceRule go to state 227 + UpdateRule go to state 228 + CallRule go to state 229 State 325 - 149 CaseLabel: "_" . ":" Rule - - ":" shift, and go to state 338 + 156 ForallRule: "forall" AttributedVariable "in" Term "do" . Rule + + "seq" shift, and go to state 203 + "par" shift, and go to state 204 + "skip" shift, and go to state 205 + "let" shift, and go to state 206 + "in" shift, and go to state 21 + "forall" shift, and go to state 207 + "choose" shift, and go to state 208 + "iterate" shift, and go to state 209 + "call" shift, and go to state 210 + "if" shift, and go to state 211 + "case" shift, and go to state 212 + "(" shift, and go to state 213 + "{" shift, and go to state 214 + "." shift, and go to state 23 + "{|" shift, and go to state 215 + "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 216 + IndirectCallExpression go to state 217 + Rule go to state 338 + SkipRule go to state 219 + ConditionalRule go to state 220 + CaseRule go to state 221 + LetRule go to state 222 + ForallRule go to state 223 + ChooseRule go to state 224 + IterateRule go to state 225 + BlockRule go to state 226 + SequenceRule go to state 227 + UpdateRule go to state 228 + CallRule go to state 229 State 326 - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - 150 CaseLabel: Term . ":" Rule - - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "implies" shift, and go to state 118 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - ":" shift, and go to state 339 - "<" shift, and go to state 122 - ">" 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 129 - "!=" shift, and go to state 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 + 157 ChooseRule: "choose" AttributedVariable "in" Term "do" . Rule + + "seq" shift, and go to state 203 + "par" shift, and go to state 204 + "skip" shift, and go to state 205 + "let" shift, and go to state 206 + "in" shift, and go to state 21 + "forall" shift, and go to state 207 + "choose" shift, and go to state 208 + "iterate" shift, and go to state 209 + "call" shift, and go to state 210 + "if" shift, and go to state 211 + "case" shift, and go to state 212 + "(" shift, and go to state 213 + "{" shift, and go to state 214 + "." shift, and go to state 23 + "{|" shift, and go to state 215 + "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 216 + IndirectCallExpression go to state 217 + Rule go to state 339 + SkipRule go to state 219 + ConditionalRule go to state 220 + CaseRule go to state 221 + LetRule go to state 222 + ForallRule go to state 223 + ChooseRule go to state 224 + IterateRule go to state 225 + BlockRule go to state 226 + SequenceRule go to state 227 + UpdateRule go to state 228 + CallRule go to state 229 State 327 - 151 CaseLabels: CaseLabel . CaseLabels - 152 | CaseLabel . - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "default" shift, and go to state 324 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 88 - "[" shift, and go to state 48 - "_" shift, and go to state 325 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 - - $default reduce using rule 152 (CaseLabels) - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 326 - Expression go to state 70 - Range go to state 71 - List go to state 72 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 - CaseLabel go to state 327 - CaseLabels go to state 340 + 147 ConditionalRule: "if" Term "then" Rule "else" . Rule + + "seq" shift, and go to state 203 + "par" shift, and go to state 204 + "skip" shift, and go to state 205 + "let" shift, and go to state 206 + "in" shift, and go to state 21 + "forall" shift, and go to state 207 + "choose" shift, and go to state 208 + "iterate" shift, and go to state 209 + "call" shift, and go to state 210 + "if" shift, and go to state 211 + "case" shift, and go to state 212 + "(" shift, and go to state 213 + "{" shift, and go to state 214 + "." shift, and go to state 23 + "{|" shift, and go to state 215 + "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 216 + IndirectCallExpression go to state 217 + Rule go to state 340 + SkipRule go to state 219 + ConditionalRule go to state 220 + CaseRule go to state 221 + LetRule go to state 222 + ForallRule go to state 223 + ChooseRule go to state 224 + IterateRule go to state 225 + BlockRule go to state 226 + SequenceRule go to state 227 + UpdateRule go to state 228 + CallRule go to state 229 State 328 - 146 CaseRule: "case" Term "of" "{" CaseLabels . "}" + 149 CaseRule: "case" Term "of" "{" error . "}" "}" shift, and go to state 341 State 329 - 15 MaybeDefined: "defined" "{" Term . "}" - 92 Expression: Term . "+" Term - 93 | Term . "-" Term - 94 | Term . "*" Term - 95 | 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 . "or" Term - 105 | Term . "xor" Term - 106 | Term . "and" Term - 107 | Term . "=>" Term - 108 | Term . "implies" Term - - "and" shift, and go to state 115 - "or" shift, and go to state 116 - "xor" shift, and go to state 117 - "implies" shift, and go to state 118 - "+" shift, and go to state 119 - "-" shift, and go to state 120 - "=" shift, and go to state 121 - "}" shift, and go to state 342 - "<" shift, and go to state 122 - ">" 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 129 - "!=" shift, and go to state 130 - "<=" shift, and go to state 131 - ">=" shift, and go to state 132 + 150 CaseLabel: "default" . ":" Rule + ":" shift, and go to state 342 -State 330 - 13 MaybeInitially: "initially" "{" . MaybeInitializers "}" - - "let" shift, and go to state 36 - "in" shift, and go to state 19 - "forall" shift, and go to state 37 - "choose" shift, and go to state 38 - "if" shift, and go to state 39 - "exists" shift, and go to state 40 - "undef" shift, and go to state 41 - "false" shift, and go to state 42 - "true" shift, and go to state 43 - "not" shift, and go to state 44 - "+" shift, and go to state 45 - "-" shift, and go to state 46 - "(" shift, and go to state 47 - "[" shift, and go to state 48 - "@" shift, and go to state 49 - "." shift, and go to state 21 - "binary" shift, and go to state 50 - "hexadecimal" shift, and go to state 51 - "integer" shift, and go to state 52 - "rational" shift, and go to state 53 - "floating" shift, and go to state 54 - "string" shift, and go to state 55 - "identifier" shift, and go to state 22 +State 330 - $default reduce using rule 29 (MaybeInitializers) + 151 CaseLabel: "_" . ":" Rule - Initializer go to state 56 - Initializers go to state 57 - MaybeInitializers go to state 343 - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - Atom go to state 60 - Undefined go to state 61 - Boolean go to state 62 - String go to state 63 - BitNumber go to state 64 - IntegerNumber go to state 65 - FloatingNumber go to state 66 - RationalNumber go to state 67 - Reference go to state 68 - Term go to state 69 - Expression go to state 70 - Range go to state 71 - List go to state 72 - TwoOrMoreArguments go to state 73 - DirectCallExpression go to state 74 - IndirectCallExpression go to state 75 - LetExpression go to state 76 - ConditionalExpression go to state 77 - ChooseExpression go to state 78 - UniversalQuantifierExpression go to state 79 - ExistentialQuantifierExpression go to state 80 + ":" shift, and go to state 343 State 331 - 55 RelationType: IdentifierPath "<" MaybeFunctionParameters "->" Type ">" . - - $default reduce using rule 55 (RelationType) + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + 152 CaseLabel: Term . ":" Rule + + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "implies" shift, and go to state 122 + "+" shift, and go to state 123 + "-" shift, and go to state 124 + "=" shift, and go to state 125 + ":" shift, and go to state 344 + "<" 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 133 + "!=" shift, and go to state 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 State 332 - 153 LetRule: "let" AttributedVariable "=" Term "in" Rule . - - $default reduce using rule 153 (LetRule) + 153 CaseLabels: CaseLabel . CaseLabels + 154 | 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 329 + "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 330 + "@" 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 154 (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 331 + 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 332 + CaseLabels go to state 345 State 333 - 154 ForallRule: "forall" AttributedVariable "in" Term "do" Rule . + 148 CaseRule: "case" Term "of" "{" CaseLabels . "}" - $default reduce using rule 154 (ForallRule) + "}" shift, and go to state 346 State 334 - 155 ChooseRule: "choose" AttributedVariable "in" Term "do" Rule . + 57 RelationType: IdentifierPath "<" MaybeFunctionParameters "->" Type ">" . - $default reduce using rule 155 (ChooseRule) + $default reduce using rule 57 (RelationType) State 335 - 145 ConditionalRule: "if" Term "then" Rule "else" Rule . - - $default reduce using rule 145 (ConditionalRule) + 16 MaybeDefined: "defined" "{" Term . "}" + 94 Expression: Term . "+" Term + 95 | 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 . "or" Term + 107 | Term . "xor" Term + 108 | Term . "and" Term + 109 | Term . "=>" Term + 110 | Term . "implies" Term + + "and" shift, and go to state 119 + "or" shift, and go to state 120 + "xor" shift, and go to state 121 + "implies" shift, and go to state 122 + "+" shift, and go to state 123 + "-" shift, and go to state 124 + "=" shift, and go to state 125 + "}" shift, and go to state 347 + "<" 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 133 + "!=" shift, and go to state 134 + "<=" shift, and go to state 135 + ">=" shift, and go to state 136 State 336 - 147 CaseRule: "case" Term "of" "{" error "}" . - - $default reduce using rule 147 (CaseRule) + 14 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 30 (MaybeInitializers) + + Initializer go to state 59 + Initializers go to state 60 + MaybeInitializers go to state 348 + 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 State 337 - 148 CaseLabel: "default" ":" . Rule - - "seq" shift, and go to state 198 - "par" shift, and go to state 199 - "skip" shift, and go to state 200 - "let" shift, and go to state 201 - "in" shift, and go to state 19 - "forall" shift, and go to state 202 - "choose" shift, and go to state 203 - "iterate" shift, and go to state 204 - "call" shift, and go to state 205 - "if" shift, and go to state 206 - "case" shift, and go to state 207 - "(" shift, and go to state 208 - "{" shift, and go to state 209 - "." shift, and go to state 21 - "{|" shift, and go to state 210 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - DirectCallExpression go to state 211 - IndirectCallExpression go to state 212 - Rule go to state 344 - SkipRule go to state 214 - ConditionalRule go to state 215 - CaseRule go to state 216 - LetRule go to state 217 - ForallRule go to state 218 - ChooseRule go to state 219 - IterateRule go to state 220 - BlockRule go to state 221 - SequenceRule go to state 222 - UpdateRule go to state 223 - CallRule go to state 224 + 155 LetRule: "let" AttributedVariable "=" Term "in" Rule . + + $default reduce using rule 155 (LetRule) State 338 - 149 CaseLabel: "_" ":" . Rule - - "seq" shift, and go to state 198 - "par" shift, and go to state 199 - "skip" shift, and go to state 200 - "let" shift, and go to state 201 - "in" shift, and go to state 19 - "forall" shift, and go to state 202 - "choose" shift, and go to state 203 - "iterate" shift, and go to state 204 - "call" shift, and go to state 205 - "if" shift, and go to state 206 - "case" shift, and go to state 207 - "(" shift, and go to state 208 - "{" shift, and go to state 209 - "." shift, and go to state 21 - "{|" shift, and go to state 210 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - DirectCallExpression go to state 211 - IndirectCallExpression go to state 212 - Rule go to state 345 - SkipRule go to state 214 - ConditionalRule go to state 215 - CaseRule go to state 216 - LetRule go to state 217 - ForallRule go to state 218 - ChooseRule go to state 219 - IterateRule go to state 220 - BlockRule go to state 221 - SequenceRule go to state 222 - UpdateRule go to state 223 - CallRule go to state 224 + 156 ForallRule: "forall" AttributedVariable "in" Term "do" Rule . + + $default reduce using rule 156 (ForallRule) State 339 - 150 CaseLabel: Term ":" . Rule - - "seq" shift, and go to state 198 - "par" shift, and go to state 199 - "skip" shift, and go to state 200 - "let" shift, and go to state 201 - "in" shift, and go to state 19 - "forall" shift, and go to state 202 - "choose" shift, and go to state 203 - "iterate" shift, and go to state 204 - "call" shift, and go to state 205 - "if" shift, and go to state 206 - "case" shift, and go to state 207 - "(" shift, and go to state 208 - "{" shift, and go to state 209 - "." shift, and go to state 21 - "{|" shift, and go to state 210 - "identifier" shift, and go to state 22 - - Identifier go to state 23 - DotSeparatedIdentifiers go to state 24 - IdentifierPath go to state 59 - DirectCallExpression go to state 211 - IndirectCallExpression go to state 212 - Rule go to state 346 - SkipRule go to state 214 - ConditionalRule go to state 215 - CaseRule go to state 216 - LetRule go to state 217 - ForallRule go to state 218 - ChooseRule go to state 219 - IterateRule go to state 220 - BlockRule go to state 221 - SequenceRule go to state 222 - UpdateRule go to state 223 - CallRule go to state 224 + 157 ChooseRule: "choose" AttributedVariable "in" Term "do" Rule . + + $default reduce using rule 157 (ChooseRule) State 340 - 151 CaseLabels: CaseLabel CaseLabels . + 147 ConditionalRule: "if" Term "then" Rule "else" Rule . - $default reduce using rule 151 (CaseLabels) + $default reduce using rule 147 (ConditionalRule) State 341 - 146 CaseRule: "case" Term "of" "{" CaseLabels "}" . + 149 CaseRule: "case" Term "of" "{" error "}" . - $default reduce using rule 146 (CaseRule) + $default reduce using rule 149 (CaseRule) State 342 - 15 MaybeDefined: "defined" "{" Term "}" . - - $default reduce using rule 15 (MaybeDefined) + 150 CaseLabel: "default" ":" . Rule + + "seq" shift, and go to state 203 + "par" shift, and go to state 204 + "skip" shift, and go to state 205 + "let" shift, and go to state 206 + "in" shift, and go to state 21 + "forall" shift, and go to state 207 + "choose" shift, and go to state 208 + "iterate" shift, and go to state 209 + "call" shift, and go to state 210 + "if" shift, and go to state 211 + "case" shift, and go to state 212 + "(" shift, and go to state 213 + "{" shift, and go to state 214 + "." shift, and go to state 23 + "{|" shift, and go to state 215 + "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 216 + IndirectCallExpression go to state 217 + Rule go to state 349 + SkipRule go to state 219 + ConditionalRule go to state 220 + CaseRule go to state 221 + LetRule go to state 222 + ForallRule go to state 223 + ChooseRule go to state 224 + IterateRule go to state 225 + BlockRule go to state 226 + SequenceRule go to state 227 + UpdateRule go to state 228 + CallRule go to state 229 State 343 - 13 MaybeInitially: "initially" "{" MaybeInitializers . "}" - - "}" shift, and go to state 347 + 151 CaseLabel: "_" ":" . Rule + + "seq" shift, and go to state 203 + "par" shift, and go to state 204 + "skip" shift, and go to state 205 + "let" shift, and go to state 206 + "in" shift, and go to state 21 + "forall" shift, and go to state 207 + "choose" shift, and go to state 208 + "iterate" shift, and go to state 209 + "call" shift, and go to state 210 + "if" shift, and go to state 211 + "case" shift, and go to state 212 + "(" shift, and go to state 213 + "{" shift, and go to state 214 + "." shift, and go to state 23 + "{|" shift, and go to state 215 + "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 216 + IndirectCallExpression go to state 217 + Rule go to state 350 + SkipRule go to state 219 + ConditionalRule go to state 220 + CaseRule go to state 221 + LetRule go to state 222 + ForallRule go to state 223 + ChooseRule go to state 224 + IterateRule go to state 225 + BlockRule go to state 226 + SequenceRule go to state 227 + UpdateRule go to state 228 + CallRule go to state 229 State 344 - 148 CaseLabel: "default" ":" Rule . - - $default reduce using rule 148 (CaseLabel) + 152 CaseLabel: Term ":" . Rule + + "seq" shift, and go to state 203 + "par" shift, and go to state 204 + "skip" shift, and go to state 205 + "let" shift, and go to state 206 + "in" shift, and go to state 21 + "forall" shift, and go to state 207 + "choose" shift, and go to state 208 + "iterate" shift, and go to state 209 + "call" shift, and go to state 210 + "if" shift, and go to state 211 + "case" shift, and go to state 212 + "(" shift, and go to state 213 + "{" shift, and go to state 214 + "." shift, and go to state 23 + "{|" shift, and go to state 215 + "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 216 + IndirectCallExpression go to state 217 + Rule go to state 351 + SkipRule go to state 219 + ConditionalRule go to state 220 + CaseRule go to state 221 + LetRule go to state 222 + ForallRule go to state 223 + ChooseRule go to state 224 + IterateRule go to state 225 + BlockRule go to state 226 + SequenceRule go to state 227 + UpdateRule go to state 228 + CallRule go to state 229 State 345 - 149 CaseLabel: "_" ":" Rule . + 153 CaseLabels: CaseLabel CaseLabels . - $default reduce using rule 149 (CaseLabel) + $default reduce using rule 153 (CaseLabels) State 346 - 150 CaseLabel: Term ":" Rule . + 148 CaseRule: "case" Term "of" "{" CaseLabels "}" . - $default reduce using rule 150 (CaseLabel) + $default reduce using rule 148 (CaseRule) State 347 - 13 MaybeInitially: "initially" "{" MaybeInitializers "}" . + 16 MaybeDefined: "defined" "{" Term "}" . + + $default reduce using rule 16 (MaybeDefined) + + +State 348 + + 14 MaybeInitially: "initially" "{" MaybeInitializers . "}" + + "}" shift, and go to state 352 + + +State 349 + + 150 CaseLabel: "default" ":" Rule . - $default reduce using rule 13 (MaybeInitially) + $default reduce using rule 150 (CaseLabel) + + +State 350 + + 151 CaseLabel: "_" ":" Rule . + + $default reduce using rule 151 (CaseLabel) + + +State 351 + + 152 CaseLabel: Term ":" Rule . + + $default reduce using rule 152 (CaseLabel) + + +State 352 + + 14 MaybeInitially: "initially" "{" MaybeInitializers "}" . + + $default reduce using rule 14 (MaybeInitially) diff --git a/src/various/GrammarParser.tab.h b/src/various/GrammarParser.tab.h index b392d0ecc..1e0e99004 100644 --- a/src/various/GrammarParser.tab.h +++ b/src/various/GrammarParser.tab.h @@ -449,20 +449,23 @@ namespace libcasm_fe { // Type char dummy46[sizeof(Type::Ptr)]; + // TypeDefinition + char dummy47[sizeof(TypeDefinition::Ptr)]; + // FunctionParameters // MaybeFunctionParameters // Types - char dummy47[sizeof(Types::Ptr)]; + char dummy48[sizeof(Types::Ptr)]; // Undefined - char dummy48[sizeof(UndefAtom::Ptr)]; + char dummy49[sizeof(UndefAtom::Ptr)]; // UniversalQuantifierExpression - char dummy49[sizeof(UniversalQuantifierExpression::Ptr)]; + char dummy50[sizeof(UniversalQuantifierExpression::Ptr)]; // Initializer // UpdateRule - char dummy50[sizeof(UpdateRule::Ptr)]; + char dummy51[sizeof(UpdateRule::Ptr)]; // Boolean // String @@ -470,11 +473,11 @@ namespace libcasm_fe { // IntegerNumber // FloatingNumber // RationalNumber - char dummy51[sizeof(ValueAtom::Ptr)]; + char dummy52[sizeof(ValueAtom::Ptr)]; // Variable // AttributedVariable - char dummy52[sizeof(VariableDefinition::Ptr)]; + char dummy53[sizeof(VariableDefinition::Ptr)]; // "binary" // "hexadecimal" @@ -483,7 +486,7 @@ namespace libcasm_fe { // "floating" // "string" // "identifier" - char dummy53[sizeof(std::string)]; + char dummy54[sizeof(std::string)]; }; /// Symbol semantic values. @@ -512,79 +515,80 @@ namespace libcasm_fe { DERIVED = 260, ENUM = 261, RULE = 262, - FUNCTION = 263, - INITIALLY = 264, - DEFINED = 265, - SEQ = 266, - ENDSEQ = 267, - PAR = 268, - ENDPAR = 269, - SKIP = 270, - LET = 271, - IN = 272, - FORALL = 273, - CHOOSE = 274, - ITERATE = 275, - DO = 276, - CALL = 277, - IF = 278, - THEN = 279, - ELSE = 280, - CASE = 281, - OF = 282, - DEFAULT = 283, - HOLDS = 284, - EXISTS = 285, - WITH = 286, - UNDEF = 287, - FALSE = 288, - TRUE = 289, - AND = 290, - OR = 291, - XOR = 292, - IMPLIES = 293, - NOT = 294, - PLUS = 295, - MINUS = 296, - EQUAL = 297, - LPAREN = 298, - RPAREN = 299, - LSQPAREN = 300, - RSQPAREN = 301, - LCURPAREN = 302, - RCURPAREN = 303, - COLON = 304, - UNDERLINE = 305, - AT = 306, - COMMA = 307, - LESSER = 308, - GREATER = 309, - ASTERIX = 310, - SLASH = 311, - PERCENT = 312, - CARET = 313, - MARK = 314, - DOTDOT = 315, - DOT = 316, - MAPS = 317, - ARROW = 318, - UPDATE = 319, - NEQUAL = 320, - LESSEQ = 321, - GREATEREQ = 322, - SEQ_BRACKET = 323, - ENDSEQ_BRACKET = 324, - BINARY = 325, - HEXADECIMAL = 326, - INTEGER = 327, - RATIONAL = 328, - FLOATING = 329, - STRING = 330, - IDENTIFIER = 331, - ABSOLUTE_PATH = 332, - UPLUS = 333, - UMINUS = 334, - CALL_WITHOUT_ARGS = 335 + TYPE = 263, + FUNCTION = 264, + INITIALLY = 265, + DEFINED = 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 }; }; @@ -714,6 +718,8 @@ namespace libcasm_fe { basic_symbol (typename Base::kind_type t, const Type::Ptr v, const location_type& l); + basic_symbol (typename Base::kind_type t, const TypeDefinition::Ptr v, const location_type& l); + basic_symbol (typename Base::kind_type t, const Types::Ptr v, const location_type& l); basic_symbol (typename Base::kind_type t, const UndefAtom::Ptr v, const location_type& l); @@ -819,6 +825,10 @@ namespace libcasm_fe { symbol_type make_RULE (const location_type& l); + static inline + symbol_type + make_TYPE (const location_type& l); + static inline symbol_type make_FUNCTION (const location_type& l); @@ -1316,12 +1326,12 @@ namespace libcasm_fe { enum { yyeof_ = 0, - yylast_ = 1894, ///< Last index in yytable_. - yynnts_ = 73, ///< Number of nonterminal symbols. - yyfinal_ = 18, ///< Termination state number. + yylast_ = 1903, ///< Last index in yytable_. + yynnts_ = 74, ///< Number of nonterminal symbols. + yyfinal_ = 20, ///< Termination state number. yyterror_ = 1, yyerrcode_ = 256, - yyntokens_ = 81 ///< Number of tokens. + yyntokens_ = 82 ///< Number of tokens. }; @@ -1374,9 +1384,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 + 75, 76, 77, 78, 79, 80, 81 }; - const unsigned int user_token_number_max_ = 335; + const unsigned int user_token_number_max_ = 336; const token_number_type undef_token_ = 2; if (static_cast(t) <= yyeof_) @@ -1409,241 +1419,245 @@ namespace libcasm_fe { { switch (other.type_get ()) { - case 150: // Attribute + case 152: // Attribute value.copy< Attribute::Ptr > (other.value); break; - case 151: // Attributes + case 153: // Attributes value.copy< Attributes::Ptr > (other.value); break; - case 152: // BasicAttribute + case 154: // BasicAttribute value.copy< BasicAttribute::Ptr > (other.value); break; - case 106: // BasicType + case 108: // BasicType value.copy< BasicType::Ptr > (other.value); break; - case 146: // BlockRule + case 148: // BlockRule value.copy< BlockRule::Ptr > (other.value); break; - case 149: // CallRule + case 151: // CallRule value.copy< CallRule::Ptr > (other.value); break; - case 140: // CaseLabel + case 142: // CaseLabel value.copy< Case::Ptr > (other.value); break; - case 139: // CaseRule + case 141: // CaseRule value.copy< CaseRule::Ptr > (other.value); break; - case 141: // CaseLabels + case 143: // CaseLabels value.copy< Cases::Ptr > (other.value); break; - case 131: // ChooseExpression + case 133: // ChooseExpression value.copy< ChooseExpression::Ptr > (other.value); break; - case 144: // ChooseRule + case 146: // ChooseRule value.copy< ChooseRule::Ptr > (other.value); break; - case 107: // ComposedType + case 109: // ComposedType value.copy< ComposedType::Ptr > (other.value); break; - case 130: // ConditionalExpression + case 132: // ConditionalExpression value.copy< ConditionalExpression::Ptr > (other.value); break; - case 138: // ConditionalRule + case 140: // ConditionalRule value.copy< ConditionalRule::Ptr > (other.value); break; - case 83: // Definition - case 84: // AttributedDefinition + case 84: // Definition + case 85: // AttributedDefinition value.copy< Definition::Ptr > (other.value); break; - case 85: // Definitions + case 86: // Definitions value.copy< Definitions::Ptr > (other.value); break; - case 95: // DerivedDefinition + case 96: // DerivedDefinition value.copy< DerivedDefinition::Ptr > (other.value); break; - case 127: // DirectCallExpression + case 129: // DirectCallExpression value.copy< DirectCallExpression::Ptr > (other.value); break; - case 96: // EnumerationDefinition + case 97: // EnumerationDefinition value.copy< EnumerationDefinition::Ptr > (other.value); break; - case 133: // ExistentialQuantifierExpression + case 135: // ExistentialQuantifierExpression value.copy< ExistentialQuantifierExpression::Ptr > (other.value); break; - case 88: // MaybeDefined - case 111: // Atom - case 120: // Term - case 121: // Expression + case 89: // MaybeDefined + case 113: // Atom + case 122: // Term + case 123: // Expression value.copy< Expression::Ptr > (other.value); break; - case 153: // ExpressionAttribute + case 155: // ExpressionAttribute value.copy< ExpressionAttribute::Ptr > (other.value); break; - case 124: // Terms - case 125: // Arguments - case 126: // TwoOrMoreArguments + case 126: // Terms + case 127: // Arguments + case 128: // TwoOrMoreArguments value.copy< Expressions::Ptr > (other.value); break; - case 109: // FixedSizedType + case 111: // FixedSizedType value.copy< FixedSizedType::Ptr > (other.value); break; - case 143: // ForallRule + case 145: // ForallRule value.copy< ForallRule::Ptr > (other.value); break; - case 86: // FunctionDefinition - case 91: // ProgramFunctionDefinition + case 87: // FunctionDefinition + case 92: // ProgramFunctionDefinition value.copy< FunctionDefinition::Ptr > (other.value); break; - case 97: // Identifier + case 99: // Identifier value.copy< Identifier::Ptr > (other.value); break; - case 100: // IdentifierPath + case 102: // IdentifierPath value.copy< IdentifierPath::Ptr > (other.value); break; - case 98: // Identifiers - case 99: // DotSeparatedIdentifiers + case 100: // Identifiers + case 101: // DotSeparatedIdentifiers value.copy< Identifiers::Ptr > (other.value); break; - case 128: // IndirectCallExpression + case 130: // IndirectCallExpression value.copy< IndirectCallExpression::Ptr > (other.value); break; - case 145: // IterateRule + case 147: // IterateRule value.copy< IterateRule::Ptr > (other.value); break; - case 129: // LetExpression + case 131: // LetExpression value.copy< LetExpression::Ptr > (other.value); break; - case 142: // LetRule + case 144: // LetRule value.copy< LetRule::Ptr > (other.value); break; - case 123: // List + case 125: // List value.copy< ListExpression::Ptr > (other.value); break; - case 87: // MaybeInitially - case 93: // Initializers - case 94: // MaybeInitializers + case 88: // MaybeInitially + case 94: // Initializers + case 95: // MaybeInitializers value.copy< NodeList< UpdateRule >::Ptr > (other.value); break; - case 103: // Parameters - case 104: // MaybeParameters + case 105: // Parameters + case 106: // MaybeParameters value.copy< NodeList< VariableDefinition >::Ptr > (other.value); break; - case 122: // Range + case 124: // Range value.copy< RangeExpression::Ptr > (other.value); break; - case 119: // Reference + case 121: // Reference value.copy< ReferenceAtom::Ptr > (other.value); break; - case 108: // RelationType + case 110: // RelationType value.copy< RelationType::Ptr > (other.value); break; - case 135: // Rule + case 137: // Rule value.copy< Rule::Ptr > (other.value); break; - case 134: // RuleDefinition + case 136: // RuleDefinition value.copy< RuleDefinition::Ptr > (other.value); break; - case 136: // Rules + case 138: // Rules value.copy< Rules::Ptr > (other.value); break; - case 147: // SequenceRule + case 149: // SequenceRule value.copy< SequenceRule::Ptr > (other.value); break; - case 137: // SkipRule + case 139: // SkipRule value.copy< SkipRule::Ptr > (other.value); break; - case 82: // Specification + case 83: // Specification value.copy< Specification::Ptr > (other.value); break; - case 105: // Type + case 107: // Type value.copy< Type::Ptr > (other.value); break; - case 89: // FunctionParameters - case 90: // MaybeFunctionParameters - case 110: // Types + case 98: // TypeDefinition + value.copy< TypeDefinition::Ptr > (other.value); + break; + + case 90: // FunctionParameters + case 91: // MaybeFunctionParameters + case 112: // Types value.copy< Types::Ptr > (other.value); break; - case 112: // Undefined + case 114: // Undefined value.copy< UndefAtom::Ptr > (other.value); break; - case 132: // UniversalQuantifierExpression + case 134: // UniversalQuantifierExpression value.copy< UniversalQuantifierExpression::Ptr > (other.value); break; - case 92: // Initializer - case 148: // UpdateRule + case 93: // Initializer + case 150: // UpdateRule value.copy< UpdateRule::Ptr > (other.value); break; - case 113: // Boolean - case 114: // String - case 115: // BitNumber - case 116: // IntegerNumber - case 117: // FloatingNumber - case 118: // RationalNumber + case 115: // Boolean + case 116: // String + case 117: // BitNumber + case 118: // IntegerNumber + case 119: // FloatingNumber + case 120: // RationalNumber value.copy< ValueAtom::Ptr > (other.value); break; - case 101: // Variable - case 102: // AttributedVariable + case 103: // Variable + case 104: // AttributedVariable value.copy< VariableDefinition::Ptr > (other.value); break; - case 70: // "binary" - case 71: // "hexadecimal" - case 72: // "integer" - case 73: // "rational" - case 74: // "floating" - case 75: // "string" - case 76: // "identifier" + case 71: // "binary" + case 72: // "hexadecimal" + case 73: // "integer" + case 74: // "rational" + case 75: // "floating" + case 76: // "string" + case 77: // "identifier" value.copy< std::string > (other.value); break; @@ -1664,241 +1678,245 @@ namespace libcasm_fe { (void) v; switch (this->type_get ()) { - case 150: // Attribute + case 152: // Attribute value.copy< Attribute::Ptr > (v); break; - case 151: // Attributes + case 153: // Attributes value.copy< Attributes::Ptr > (v); break; - case 152: // BasicAttribute + case 154: // BasicAttribute value.copy< BasicAttribute::Ptr > (v); break; - case 106: // BasicType + case 108: // BasicType value.copy< BasicType::Ptr > (v); break; - case 146: // BlockRule + case 148: // BlockRule value.copy< BlockRule::Ptr > (v); break; - case 149: // CallRule + case 151: // CallRule value.copy< CallRule::Ptr > (v); break; - case 140: // CaseLabel + case 142: // CaseLabel value.copy< Case::Ptr > (v); break; - case 139: // CaseRule + case 141: // CaseRule value.copy< CaseRule::Ptr > (v); break; - case 141: // CaseLabels + case 143: // CaseLabels value.copy< Cases::Ptr > (v); break; - case 131: // ChooseExpression + case 133: // ChooseExpression value.copy< ChooseExpression::Ptr > (v); break; - case 144: // ChooseRule + case 146: // ChooseRule value.copy< ChooseRule::Ptr > (v); break; - case 107: // ComposedType + case 109: // ComposedType value.copy< ComposedType::Ptr > (v); break; - case 130: // ConditionalExpression + case 132: // ConditionalExpression value.copy< ConditionalExpression::Ptr > (v); break; - case 138: // ConditionalRule + case 140: // ConditionalRule value.copy< ConditionalRule::Ptr > (v); break; - case 83: // Definition - case 84: // AttributedDefinition + case 84: // Definition + case 85: // AttributedDefinition value.copy< Definition::Ptr > (v); break; - case 85: // Definitions + case 86: // Definitions value.copy< Definitions::Ptr > (v); break; - case 95: // DerivedDefinition + case 96: // DerivedDefinition value.copy< DerivedDefinition::Ptr > (v); break; - case 127: // DirectCallExpression + case 129: // DirectCallExpression value.copy< DirectCallExpression::Ptr > (v); break; - case 96: // EnumerationDefinition + case 97: // EnumerationDefinition value.copy< EnumerationDefinition::Ptr > (v); break; - case 133: // ExistentialQuantifierExpression + case 135: // ExistentialQuantifierExpression value.copy< ExistentialQuantifierExpression::Ptr > (v); break; - case 88: // MaybeDefined - case 111: // Atom - case 120: // Term - case 121: // Expression + case 89: // MaybeDefined + case 113: // Atom + case 122: // Term + case 123: // Expression value.copy< Expression::Ptr > (v); break; - case 153: // ExpressionAttribute + case 155: // ExpressionAttribute value.copy< ExpressionAttribute::Ptr > (v); break; - case 124: // Terms - case 125: // Arguments - case 126: // TwoOrMoreArguments + case 126: // Terms + case 127: // Arguments + case 128: // TwoOrMoreArguments value.copy< Expressions::Ptr > (v); break; - case 109: // FixedSizedType + case 111: // FixedSizedType value.copy< FixedSizedType::Ptr > (v); break; - case 143: // ForallRule + case 145: // ForallRule value.copy< ForallRule::Ptr > (v); break; - case 86: // FunctionDefinition - case 91: // ProgramFunctionDefinition + case 87: // FunctionDefinition + case 92: // ProgramFunctionDefinition value.copy< FunctionDefinition::Ptr > (v); break; - case 97: // Identifier + case 99: // Identifier value.copy< Identifier::Ptr > (v); break; - case 100: // IdentifierPath + case 102: // IdentifierPath value.copy< IdentifierPath::Ptr > (v); break; - case 98: // Identifiers - case 99: // DotSeparatedIdentifiers + case 100: // Identifiers + case 101: // DotSeparatedIdentifiers value.copy< Identifiers::Ptr > (v); break; - case 128: // IndirectCallExpression + case 130: // IndirectCallExpression value.copy< IndirectCallExpression::Ptr > (v); break; - case 145: // IterateRule + case 147: // IterateRule value.copy< IterateRule::Ptr > (v); break; - case 129: // LetExpression + case 131: // LetExpression value.copy< LetExpression::Ptr > (v); break; - case 142: // LetRule + case 144: // LetRule value.copy< LetRule::Ptr > (v); break; - case 123: // List + case 125: // List value.copy< ListExpression::Ptr > (v); break; - case 87: // MaybeInitially - case 93: // Initializers - case 94: // MaybeInitializers + case 88: // MaybeInitially + case 94: // Initializers + case 95: // MaybeInitializers value.copy< NodeList< UpdateRule >::Ptr > (v); break; - case 103: // Parameters - case 104: // MaybeParameters + case 105: // Parameters + case 106: // MaybeParameters value.copy< NodeList< VariableDefinition >::Ptr > (v); break; - case 122: // Range + case 124: // Range value.copy< RangeExpression::Ptr > (v); break; - case 119: // Reference + case 121: // Reference value.copy< ReferenceAtom::Ptr > (v); break; - case 108: // RelationType + case 110: // RelationType value.copy< RelationType::Ptr > (v); break; - case 135: // Rule + case 137: // Rule value.copy< Rule::Ptr > (v); break; - case 134: // RuleDefinition + case 136: // RuleDefinition value.copy< RuleDefinition::Ptr > (v); break; - case 136: // Rules + case 138: // Rules value.copy< Rules::Ptr > (v); break; - case 147: // SequenceRule + case 149: // SequenceRule value.copy< SequenceRule::Ptr > (v); break; - case 137: // SkipRule + case 139: // SkipRule value.copy< SkipRule::Ptr > (v); break; - case 82: // Specification + case 83: // Specification value.copy< Specification::Ptr > (v); break; - case 105: // Type + case 107: // Type value.copy< Type::Ptr > (v); break; - case 89: // FunctionParameters - case 90: // MaybeFunctionParameters - case 110: // Types + case 98: // TypeDefinition + value.copy< TypeDefinition::Ptr > (v); + break; + + case 90: // FunctionParameters + case 91: // MaybeFunctionParameters + case 112: // Types value.copy< Types::Ptr > (v); break; - case 112: // Undefined + case 114: // Undefined value.copy< UndefAtom::Ptr > (v); break; - case 132: // UniversalQuantifierExpression + case 134: // UniversalQuantifierExpression value.copy< UniversalQuantifierExpression::Ptr > (v); break; - case 92: // Initializer - case 148: // UpdateRule + case 93: // Initializer + case 150: // UpdateRule value.copy< UpdateRule::Ptr > (v); break; - case 113: // Boolean - case 114: // String - case 115: // BitNumber - case 116: // IntegerNumber - case 117: // FloatingNumber - case 118: // RationalNumber + case 115: // Boolean + case 116: // String + case 117: // BitNumber + case 118: // IntegerNumber + case 119: // FloatingNumber + case 120: // RationalNumber value.copy< ValueAtom::Ptr > (v); break; - case 101: // Variable - case 102: // AttributedVariable + case 103: // Variable + case 104: // AttributedVariable value.copy< VariableDefinition::Ptr > (v); break; - case 70: // "binary" - case 71: // "hexadecimal" - case 72: // "integer" - case 73: // "rational" - case 74: // "floating" - case 75: // "string" - case 76: // "identifier" + case 71: // "binary" + case 72: // "hexadecimal" + case 73: // "integer" + case 74: // "rational" + case 75: // "floating" + case 76: // "string" + case 77: // "identifier" value.copy< std::string > (v); break; @@ -2239,6 +2257,13 @@ namespace libcasm_fe { , location (l) {} + template + Parser::basic_symbol::basic_symbol (typename Base::kind_type t, const TypeDefinition::Ptr v, const location_type& l) + : Base (t) + , value (v) + , location (l) + {} + template Parser::basic_symbol::basic_symbol (typename Base::kind_type t, const Types::Ptr v, const location_type& l) : Base (t) @@ -2314,241 +2339,245 @@ namespace libcasm_fe { // Type destructor. switch (yytype) { - case 150: // Attribute + case 152: // Attribute value.template destroy< Attribute::Ptr > (); break; - case 151: // Attributes + case 153: // Attributes value.template destroy< Attributes::Ptr > (); break; - case 152: // BasicAttribute + case 154: // BasicAttribute value.template destroy< BasicAttribute::Ptr > (); break; - case 106: // BasicType + case 108: // BasicType value.template destroy< BasicType::Ptr > (); break; - case 146: // BlockRule + case 148: // BlockRule value.template destroy< BlockRule::Ptr > (); break; - case 149: // CallRule + case 151: // CallRule value.template destroy< CallRule::Ptr > (); break; - case 140: // CaseLabel + case 142: // CaseLabel value.template destroy< Case::Ptr > (); break; - case 139: // CaseRule + case 141: // CaseRule value.template destroy< CaseRule::Ptr > (); break; - case 141: // CaseLabels + case 143: // CaseLabels value.template destroy< Cases::Ptr > (); break; - case 131: // ChooseExpression + case 133: // ChooseExpression value.template destroy< ChooseExpression::Ptr > (); break; - case 144: // ChooseRule + case 146: // ChooseRule value.template destroy< ChooseRule::Ptr > (); break; - case 107: // ComposedType + case 109: // ComposedType value.template destroy< ComposedType::Ptr > (); break; - case 130: // ConditionalExpression + case 132: // ConditionalExpression value.template destroy< ConditionalExpression::Ptr > (); break; - case 138: // ConditionalRule + case 140: // ConditionalRule value.template destroy< ConditionalRule::Ptr > (); break; - case 83: // Definition - case 84: // AttributedDefinition + case 84: // Definition + case 85: // AttributedDefinition value.template destroy< Definition::Ptr > (); break; - case 85: // Definitions + case 86: // Definitions value.template destroy< Definitions::Ptr > (); break; - case 95: // DerivedDefinition + case 96: // DerivedDefinition value.template destroy< DerivedDefinition::Ptr > (); break; - case 127: // DirectCallExpression + case 129: // DirectCallExpression value.template destroy< DirectCallExpression::Ptr > (); break; - case 96: // EnumerationDefinition + case 97: // EnumerationDefinition value.template destroy< EnumerationDefinition::Ptr > (); break; - case 133: // ExistentialQuantifierExpression + case 135: // ExistentialQuantifierExpression value.template destroy< ExistentialQuantifierExpression::Ptr > (); break; - case 88: // MaybeDefined - case 111: // Atom - case 120: // Term - case 121: // Expression + case 89: // MaybeDefined + case 113: // Atom + case 122: // Term + case 123: // Expression value.template destroy< Expression::Ptr > (); break; - case 153: // ExpressionAttribute + case 155: // ExpressionAttribute value.template destroy< ExpressionAttribute::Ptr > (); break; - case 124: // Terms - case 125: // Arguments - case 126: // TwoOrMoreArguments + case 126: // Terms + case 127: // Arguments + case 128: // TwoOrMoreArguments value.template destroy< Expressions::Ptr > (); break; - case 109: // FixedSizedType + case 111: // FixedSizedType value.template destroy< FixedSizedType::Ptr > (); break; - case 143: // ForallRule + case 145: // ForallRule value.template destroy< ForallRule::Ptr > (); break; - case 86: // FunctionDefinition - case 91: // ProgramFunctionDefinition + case 87: // FunctionDefinition + case 92: // ProgramFunctionDefinition value.template destroy< FunctionDefinition::Ptr > (); break; - case 97: // Identifier + case 99: // Identifier value.template destroy< Identifier::Ptr > (); break; - case 100: // IdentifierPath + case 102: // IdentifierPath value.template destroy< IdentifierPath::Ptr > (); break; - case 98: // Identifiers - case 99: // DotSeparatedIdentifiers + case 100: // Identifiers + case 101: // DotSeparatedIdentifiers value.template destroy< Identifiers::Ptr > (); break; - case 128: // IndirectCallExpression + case 130: // IndirectCallExpression value.template destroy< IndirectCallExpression::Ptr > (); break; - case 145: // IterateRule + case 147: // IterateRule value.template destroy< IterateRule::Ptr > (); break; - case 129: // LetExpression + case 131: // LetExpression value.template destroy< LetExpression::Ptr > (); break; - case 142: // LetRule + case 144: // LetRule value.template destroy< LetRule::Ptr > (); break; - case 123: // List + case 125: // List value.template destroy< ListExpression::Ptr > (); break; - case 87: // MaybeInitially - case 93: // Initializers - case 94: // MaybeInitializers + case 88: // MaybeInitially + case 94: // Initializers + case 95: // MaybeInitializers value.template destroy< NodeList< UpdateRule >::Ptr > (); break; - case 103: // Parameters - case 104: // MaybeParameters + case 105: // Parameters + case 106: // MaybeParameters value.template destroy< NodeList< VariableDefinition >::Ptr > (); break; - case 122: // Range + case 124: // Range value.template destroy< RangeExpression::Ptr > (); break; - case 119: // Reference + case 121: // Reference value.template destroy< ReferenceAtom::Ptr > (); break; - case 108: // RelationType + case 110: // RelationType value.template destroy< RelationType::Ptr > (); break; - case 135: // Rule + case 137: // Rule value.template destroy< Rule::Ptr > (); break; - case 134: // RuleDefinition + case 136: // RuleDefinition value.template destroy< RuleDefinition::Ptr > (); break; - case 136: // Rules + case 138: // Rules value.template destroy< Rules::Ptr > (); break; - case 147: // SequenceRule + case 149: // SequenceRule value.template destroy< SequenceRule::Ptr > (); break; - case 137: // SkipRule + case 139: // SkipRule value.template destroy< SkipRule::Ptr > (); break; - case 82: // Specification + case 83: // Specification value.template destroy< Specification::Ptr > (); break; - case 105: // Type + case 107: // Type value.template destroy< Type::Ptr > (); break; - case 89: // FunctionParameters - case 90: // MaybeFunctionParameters - case 110: // Types + case 98: // TypeDefinition + value.template destroy< TypeDefinition::Ptr > (); + break; + + case 90: // FunctionParameters + case 91: // MaybeFunctionParameters + case 112: // Types value.template destroy< Types::Ptr > (); break; - case 112: // Undefined + case 114: // Undefined value.template destroy< UndefAtom::Ptr > (); break; - case 132: // UniversalQuantifierExpression + case 134: // UniversalQuantifierExpression value.template destroy< UniversalQuantifierExpression::Ptr > (); break; - case 92: // Initializer - case 148: // UpdateRule + case 93: // Initializer + case 150: // UpdateRule value.template destroy< UpdateRule::Ptr > (); break; - case 113: // Boolean - case 114: // String - case 115: // BitNumber - case 116: // IntegerNumber - case 117: // FloatingNumber - case 118: // RationalNumber + case 115: // Boolean + case 116: // String + case 117: // BitNumber + case 118: // IntegerNumber + case 119: // FloatingNumber + case 120: // RationalNumber value.template destroy< ValueAtom::Ptr > (); break; - case 101: // Variable - case 102: // AttributedVariable + case 103: // Variable + case 104: // AttributedVariable value.template destroy< VariableDefinition::Ptr > (); break; - case 70: // "binary" - case 71: // "hexadecimal" - case 72: // "integer" - case 73: // "rational" - case 74: // "floating" - case 75: // "string" - case 76: // "identifier" + case 71: // "binary" + case 72: // "hexadecimal" + case 73: // "integer" + case 74: // "rational" + case 75: // "floating" + case 76: // "string" + case 77: // "identifier" value.template destroy< std::string > (); break; @@ -2575,241 +2604,245 @@ namespace libcasm_fe { super_type::move(s); switch (this->type_get ()) { - case 150: // Attribute + case 152: // Attribute value.move< Attribute::Ptr > (s.value); break; - case 151: // Attributes + case 153: // Attributes value.move< Attributes::Ptr > (s.value); break; - case 152: // BasicAttribute + case 154: // BasicAttribute value.move< BasicAttribute::Ptr > (s.value); break; - case 106: // BasicType + case 108: // BasicType value.move< BasicType::Ptr > (s.value); break; - case 146: // BlockRule + case 148: // BlockRule value.move< BlockRule::Ptr > (s.value); break; - case 149: // CallRule + case 151: // CallRule value.move< CallRule::Ptr > (s.value); break; - case 140: // CaseLabel + case 142: // CaseLabel value.move< Case::Ptr > (s.value); break; - case 139: // CaseRule + case 141: // CaseRule value.move< CaseRule::Ptr > (s.value); break; - case 141: // CaseLabels + case 143: // CaseLabels value.move< Cases::Ptr > (s.value); break; - case 131: // ChooseExpression + case 133: // ChooseExpression value.move< ChooseExpression::Ptr > (s.value); break; - case 144: // ChooseRule + case 146: // ChooseRule value.move< ChooseRule::Ptr > (s.value); break; - case 107: // ComposedType + case 109: // ComposedType value.move< ComposedType::Ptr > (s.value); break; - case 130: // ConditionalExpression + case 132: // ConditionalExpression value.move< ConditionalExpression::Ptr > (s.value); break; - case 138: // ConditionalRule + case 140: // ConditionalRule value.move< ConditionalRule::Ptr > (s.value); break; - case 83: // Definition - case 84: // AttributedDefinition + case 84: // Definition + case 85: // AttributedDefinition value.move< Definition::Ptr > (s.value); break; - case 85: // Definitions + case 86: // Definitions value.move< Definitions::Ptr > (s.value); break; - case 95: // DerivedDefinition + case 96: // DerivedDefinition value.move< DerivedDefinition::Ptr > (s.value); break; - case 127: // DirectCallExpression + case 129: // DirectCallExpression value.move< DirectCallExpression::Ptr > (s.value); break; - case 96: // EnumerationDefinition + case 97: // EnumerationDefinition value.move< EnumerationDefinition::Ptr > (s.value); break; - case 133: // ExistentialQuantifierExpression + case 135: // ExistentialQuantifierExpression value.move< ExistentialQuantifierExpression::Ptr > (s.value); break; - case 88: // MaybeDefined - case 111: // Atom - case 120: // Term - case 121: // Expression + case 89: // MaybeDefined + case 113: // Atom + case 122: // Term + case 123: // Expression value.move< Expression::Ptr > (s.value); break; - case 153: // ExpressionAttribute + case 155: // ExpressionAttribute value.move< ExpressionAttribute::Ptr > (s.value); break; - case 124: // Terms - case 125: // Arguments - case 126: // TwoOrMoreArguments + case 126: // Terms + case 127: // Arguments + case 128: // TwoOrMoreArguments value.move< Expressions::Ptr > (s.value); break; - case 109: // FixedSizedType + case 111: // FixedSizedType value.move< FixedSizedType::Ptr > (s.value); break; - case 143: // ForallRule + case 145: // ForallRule value.move< ForallRule::Ptr > (s.value); break; - case 86: // FunctionDefinition - case 91: // ProgramFunctionDefinition + case 87: // FunctionDefinition + case 92: // ProgramFunctionDefinition value.move< FunctionDefinition::Ptr > (s.value); break; - case 97: // Identifier + case 99: // Identifier value.move< Identifier::Ptr > (s.value); break; - case 100: // IdentifierPath + case 102: // IdentifierPath value.move< IdentifierPath::Ptr > (s.value); break; - case 98: // Identifiers - case 99: // DotSeparatedIdentifiers + case 100: // Identifiers + case 101: // DotSeparatedIdentifiers value.move< Identifiers::Ptr > (s.value); break; - case 128: // IndirectCallExpression + case 130: // IndirectCallExpression value.move< IndirectCallExpression::Ptr > (s.value); break; - case 145: // IterateRule + case 147: // IterateRule value.move< IterateRule::Ptr > (s.value); break; - case 129: // LetExpression + case 131: // LetExpression value.move< LetExpression::Ptr > (s.value); break; - case 142: // LetRule + case 144: // LetRule value.move< LetRule::Ptr > (s.value); break; - case 123: // List + case 125: // List value.move< ListExpression::Ptr > (s.value); break; - case 87: // MaybeInitially - case 93: // Initializers - case 94: // MaybeInitializers + case 88: // MaybeInitially + case 94: // Initializers + case 95: // MaybeInitializers value.move< NodeList< UpdateRule >::Ptr > (s.value); break; - case 103: // Parameters - case 104: // MaybeParameters + case 105: // Parameters + case 106: // MaybeParameters value.move< NodeList< VariableDefinition >::Ptr > (s.value); break; - case 122: // Range + case 124: // Range value.move< RangeExpression::Ptr > (s.value); break; - case 119: // Reference + case 121: // Reference value.move< ReferenceAtom::Ptr > (s.value); break; - case 108: // RelationType + case 110: // RelationType value.move< RelationType::Ptr > (s.value); break; - case 135: // Rule + case 137: // Rule value.move< Rule::Ptr > (s.value); break; - case 134: // RuleDefinition + case 136: // RuleDefinition value.move< RuleDefinition::Ptr > (s.value); break; - case 136: // Rules + case 138: // Rules value.move< Rules::Ptr > (s.value); break; - case 147: // SequenceRule + case 149: // SequenceRule value.move< SequenceRule::Ptr > (s.value); break; - case 137: // SkipRule + case 139: // SkipRule value.move< SkipRule::Ptr > (s.value); break; - case 82: // Specification + case 83: // Specification value.move< Specification::Ptr > (s.value); break; - case 105: // Type + case 107: // Type value.move< Type::Ptr > (s.value); break; - case 89: // FunctionParameters - case 90: // MaybeFunctionParameters - case 110: // Types + case 98: // TypeDefinition + value.move< TypeDefinition::Ptr > (s.value); + break; + + case 90: // FunctionParameters + case 91: // MaybeFunctionParameters + case 112: // Types value.move< Types::Ptr > (s.value); break; - case 112: // Undefined + case 114: // Undefined value.move< UndefAtom::Ptr > (s.value); break; - case 132: // UniversalQuantifierExpression + case 134: // UniversalQuantifierExpression value.move< UniversalQuantifierExpression::Ptr > (s.value); break; - case 92: // Initializer - case 148: // UpdateRule + case 93: // Initializer + case 150: // UpdateRule value.move< UpdateRule::Ptr > (s.value); break; - case 113: // Boolean - case 114: // String - case 115: // BitNumber - case 116: // IntegerNumber - case 117: // FloatingNumber - case 118: // RationalNumber + case 115: // Boolean + case 116: // String + case 117: // BitNumber + case 118: // IntegerNumber + case 119: // FloatingNumber + case 120: // RationalNumber value.move< ValueAtom::Ptr > (s.value); break; - case 101: // Variable - case 102: // AttributedVariable + case 103: // Variable + case 104: // AttributedVariable value.move< VariableDefinition::Ptr > (s.value); break; - case 70: // "binary" - case 71: // "hexadecimal" - case 72: // "integer" - case 73: // "rational" - case 74: // "floating" - case 75: // "string" - case 76: // "identifier" + case 71: // "binary" + case 72: // "hexadecimal" + case 73: // "integer" + case 74: // "rational" + case 75: // "floating" + case 76: // "string" + case 77: // "identifier" value.move< std::string > (s.value); break; @@ -2876,7 +2909,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 + 335, 336 }; return static_cast (yytoken_number_[type]); } @@ -2917,6 +2950,12 @@ namespace libcasm_fe { return symbol_type (token::RULE, l); } + Parser::symbol_type + Parser::make_TYPE (const location_type& l) + { + return symbol_type (token::TYPE, l); + } + Parser::symbol_type Parser::make_FUNCTION (const location_type& l) { @@ -3358,7 +3397,7 @@ namespace libcasm_fe { #line 31 "../../obj/src/GrammarParser.yy" // lalr1.cc:377 } // libcasm_fe -#line 3362 "GrammarParser.tab.h" // lalr1.cc:377 +#line 3401 "GrammarParser.tab.h" // lalr1.cc:377