From 452957a271cc975e2114ac6bbf006e8c7566e858 Mon Sep 17 00:00:00 2001
From: Philipp Paulweber
Date: Sun, 30 Jul 2017 10:47:44 +0200
Subject: [PATCH] Implementation Definition
* added AST node for implementation definition and its new syntax rules
* added new grammar tokens 'implements', 'for', and 'this', which are
needed to fully describe the definition and implementation details
about implemented structures and/or features (aka. traits)
* related to ref #35
---
src/GrammarParser.yy | 57 +-
src/GrammarToken.hpp | 3 +
src/ast/Definition.cpp | 36 +
src/ast/Definition.h | 23 +
src/ast/EmptyVisitor.cpp | 4 +
src/ast/EmptyVisitor.h | 1 +
src/ast/Node.cpp | 4 +
src/ast/Node.h | 3 +
src/ast/RecursiveVisitor.cpp | 7 +
src/ast/RecursiveVisitor.h | 1 +
src/ast/Visitor.h | 2 +
src/transform/AstDumpSourcePass.cpp | 19 +
src/various/Grammar.org | 16 +-
src/various/GrammarLexer.cpp | 604 +-
src/various/GrammarParser.cpp | 2927 +++---
src/various/GrammarParser.output | 13704 +++++++++++++-------------
src/various/GrammarParser.tab.h | 958 +-
17 files changed, 9536 insertions(+), 8833 deletions(-)
diff --git a/src/GrammarParser.yy b/src/GrammarParser.yy
index 188b763de..1286c5f31 100644
--- a/src/GrammarParser.yy
+++ b/src/GrammarParser.yy
@@ -175,6 +175,9 @@ END 0 "end of file"
%type FeatureDefinition
%type FeatureDeclarationOrDefinition
%type FeatureDeclarationsAndDefinitions
+%type ImplementationDefinition
+%type ImplementationDefinitionDefinition
+%type ImplementationDefinitionDefinitions
%type DeclarationDefinition
// expressions
@@ -311,6 +314,10 @@ Definition
{
$$ = $1;
}
+| ImplementationDefinition
+ {
+ $$ = $1;
+ }
| error // error recovery
{
$$ = nullptr;
@@ -587,10 +594,10 @@ FeatureDeclarationOrDefinition
FeatureDeclarationsAndDefinitions
-: FeatureDeclarationsAndDefinitions COMMA FeatureDeclarationOrDefinition
+: FeatureDeclarationsAndDefinitions FeatureDeclarationOrDefinition
{
auto definitions = $1;
- definitions->add( $3 );
+ definitions->add( $2 );
$$ = definitions;
}
| FeatureDeclarationOrDefinition
@@ -602,6 +609,48 @@ FeatureDeclarationsAndDefinitions
;
+ImplementationDefinition
+: IMPLEMENTS IdentifierPath FOR Type EQUAL LCURPAREN ImplementationDefinitionDefinitions RCURPAREN
+ {
+ $$ = Ast::make< ImplementationDefinition >( @$, $2, $4, $7 );
+ }
+| IMPLEMENTS Type EQUAL LCURPAREN ImplementationDefinitionDefinitions RCURPAREN
+ {
+ const auto name = Ast::make< Identifier >( @$, "" );
+ const auto path = asIdentifierPath( name );
+ $$ = Ast::make< ImplementationDefinition >( @$, path, $2, $5 );
+ }
+;
+
+
+ImplementationDefinitionDefinition
+: DerivedDefinition
+ {
+ $$ = $1;
+ }
+| RuleDefinition
+ {
+ $$ = $1;
+ }
+;
+
+
+ImplementationDefinitionDefinitions
+: ImplementationDefinitionDefinitions ImplementationDefinitionDefinition
+ {
+ auto definitions = $1;
+ definitions->add( $2 );
+ $$ = definitions;
+ }
+| ImplementationDefinitionDefinition
+ {
+ auto definitions = Ast::make< Definitions >( @$ );
+ definitions->add( $1 );
+ $$ = definitions;
+ }
+;
+
+
DeclarationDefinition
: DERIVED Identifier COLON MaybeFunctionParameters MAPS Type
{
@@ -671,6 +720,10 @@ IdentifierPath
{
$$ = Ast::make< IdentifierPath >( @$, $2, IdentifierPath::Type::RELATIVE );
}
+| THIS DOT DotSeparatedIdentifiers
+ {
+ $$ = Ast::make< IdentifierPath >( @$, $3, IdentifierPath::Type::THIS );
+ }
;
diff --git a/src/GrammarToken.hpp b/src/GrammarToken.hpp
index bde87c907..ed51882a8 100644
--- a/src/GrammarToken.hpp
+++ b/src/GrammarToken.hpp
@@ -37,6 +37,9 @@ DEFINED "defined" { return Parser::make_DEFINED(loc); }
STRUCTURE "structure" { return Parser::make_STRUCTURE(loc); }
FEATURE "feature" { return Parser::make_FEATURE(loc); }
+IMPLEMENTS "implements" { return Parser::make_IMPLEMENTS(loc); }
+FOR "for" { return Parser::make_FOR(loc); }
+THIS "this" { return Parser::make_THIS(loc); }
SEQ "seq" { return Parser::make_SEQ(loc); }
ENDSEQ "endseq" { return Parser::make_ENDSEQ(loc); }
diff --git a/src/ast/Definition.cpp b/src/ast/Definition.cpp
index 2e68a3137..6f8095490 100644
--- a/src/ast/Definition.cpp
+++ b/src/ast/Definition.cpp
@@ -352,6 +352,42 @@ void FeatureDefinition::accept( Visitor& visitor )
visitor.visit( *this );
}
+//
+//
+// ImplementationDefinition
+//
+
+ImplementationDefinition::ImplementationDefinition(
+ const IdentifierPath::Ptr& path,
+ const Type::Ptr& type,
+ const Definitions::Ptr& definitions )
+: Definition( Node::ID::IMPLEMENTATION_DEFINITION, *path->identifiers()->end() )
+, m_path( path )
+, m_type( type )
+, m_definitions( definitions )
+{
+}
+
+const IdentifierPath::Ptr& ImplementationDefinition::path( void ) const
+{
+ return m_path;
+}
+
+const Type::Ptr& ImplementationDefinition::type( void ) const
+{
+ return m_type;
+}
+
+const Definitions::Ptr& ImplementationDefinition::definitions( void ) const
+{
+ return m_definitions;
+}
+
+void ImplementationDefinition::accept( Visitor& visitor )
+{
+ visitor.visit( *this );
+}
+
//
//
// DeclarationDefinition
diff --git a/src/ast/Definition.h b/src/ast/Definition.h
index 3c231904f..a43e33cb0 100644
--- a/src/ast/Definition.h
+++ b/src/ast/Definition.h
@@ -251,6 +251,29 @@ namespace libcasm_fe
const Definitions::Ptr m_definitions;
};
+ class ImplementationDefinition final : public Definition
+ {
+ public:
+ using Ptr = std::shared_ptr< ImplementationDefinition >;
+
+ ImplementationDefinition( const IdentifierPath::Ptr& path,
+ const Type::Ptr& type,
+ const Definitions::Ptr& definitions );
+
+ const IdentifierPath::Ptr& path( void ) const;
+
+ const Type::Ptr& type( void ) const;
+
+ const Definitions::Ptr& definitions( void ) const;
+
+ void accept( Visitor& visitor ) override final;
+
+ private:
+ const IdentifierPath::Ptr m_path;
+ const Type::Ptr m_type;
+ const Definitions::Ptr m_definitions;
+ };
+
class DeclarationDefinition final : public Definition
{
public:
diff --git a/src/ast/EmptyVisitor.cpp b/src/ast/EmptyVisitor.cpp
index a49f83517..75a2322e9 100644
--- a/src/ast/EmptyVisitor.cpp
+++ b/src/ast/EmptyVisitor.cpp
@@ -62,6 +62,10 @@ void EmptyVisitor::visit( FeatureDefinition& )
{
}
+void EmptyVisitor::visit( ImplementationDefinition& )
+{
+}
+
void EmptyVisitor::visit( DeclarationDefinition& )
{
}
diff --git a/src/ast/EmptyVisitor.h b/src/ast/EmptyVisitor.h
index 9209e106a..4a7834a34 100644
--- a/src/ast/EmptyVisitor.h
+++ b/src/ast/EmptyVisitor.h
@@ -44,6 +44,7 @@ namespace libcasm_fe
void visit( EnumerationDefinition& node ) override;
void visit( StructureDefinition& node ) override;
void visit( FeatureDefinition& node ) override;
+ void visit( ImplementationDefinition& node ) override;
void visit( DeclarationDefinition& node ) override;
void visit( ValueAtom& node ) override;
diff --git a/src/ast/Node.cpp b/src/ast/Node.cpp
index 46459f63d..16c22dba2 100644
--- a/src/ast/Node.cpp
+++ b/src/ast/Node.cpp
@@ -85,6 +85,10 @@ std::string Node::description( void ) const
{
return "feature";
}
+ case ID::IMPLEMENTATION_DEFINITION:
+ {
+ return "implementation";
+ }
case ID::DECLARATION_DEFINITION:
{
return "declaration";
diff --git a/src/ast/Node.h b/src/ast/Node.h
index 0d69ad7f8..91081ef6a 100644
--- a/src/ast/Node.h
+++ b/src/ast/Node.h
@@ -57,6 +57,7 @@ namespace libcasm_fe
ENUMERATION_DEFINITION,
STRUCTURE_DEFINITION,
FEATURE_DEFINITION,
+ IMPLEMENTATION_DEFINITION,
DECLARATION_DEFINITION,
// expressions
@@ -209,6 +210,8 @@ namespace libcasm_fe
{
ABSOLUTE, /**< absolute namespace + identifier path */
RELATIVE, /**< path started with a dot, needs to be resolved */
+ THIS, /**< path started with a 'this' and dot, needs to be
+ resolved */
};
public:
diff --git a/src/ast/RecursiveVisitor.cpp b/src/ast/RecursiveVisitor.cpp
index 431f8b276..bfb3a08d1 100644
--- a/src/ast/RecursiveVisitor.cpp
+++ b/src/ast/RecursiveVisitor.cpp
@@ -90,6 +90,13 @@ void RecursiveVisitor::visit( FeatureDefinition& node )
node.definitions()->accept( *this );
}
+void RecursiveVisitor::visit( ImplementationDefinition& node )
+{
+ node.identifier()->accept( *this );
+ node.type()->accept( *this );
+ node.definitions()->accept( *this );
+}
+
void RecursiveVisitor::visit( DeclarationDefinition& node )
{
node.identifier()->accept( *this );
diff --git a/src/ast/RecursiveVisitor.h b/src/ast/RecursiveVisitor.h
index 65c536d5d..4bb65e921 100644
--- a/src/ast/RecursiveVisitor.h
+++ b/src/ast/RecursiveVisitor.h
@@ -44,6 +44,7 @@ namespace libcasm_fe
void visit( EnumerationDefinition& node ) override;
void visit( StructureDefinition& node ) override;
void visit( FeatureDefinition& node ) override;
+ void visit( ImplementationDefinition& node ) override;
void visit( DeclarationDefinition& node ) override;
void visit( ValueAtom& node ) override;
diff --git a/src/ast/Visitor.h b/src/ast/Visitor.h
index d640cbf39..b61273472 100644
--- a/src/ast/Visitor.h
+++ b/src/ast/Visitor.h
@@ -39,6 +39,7 @@ namespace libcasm_fe
class EnumerationDefinition;
class StructureDefinition;
class FeatureDefinition;
+ class ImplementationDefinition;
class DeclarationDefinition;
class ValueAtom;
@@ -99,6 +100,7 @@ namespace libcasm_fe
virtual void visit( EnumerationDefinition& node ) = 0;
virtual void visit( StructureDefinition& node ) = 0;
virtual void visit( FeatureDefinition& node ) = 0;
+ virtual void visit( ImplementationDefinition& node ) = 0;
virtual void visit( DeclarationDefinition& node ) = 0;
virtual void visit( ValueAtom& node ) = 0;
diff --git a/src/transform/AstDumpSourcePass.cpp b/src/transform/AstDumpSourcePass.cpp
index 67b437ff9..3aeb03e70 100644
--- a/src/transform/AstDumpSourcePass.cpp
+++ b/src/transform/AstDumpSourcePass.cpp
@@ -132,6 +132,7 @@ class AstDumpSourceVisitor final : public Visitor
void visit( EnumerationDefinition& node ) override;
void visit( StructureDefinition& node ) override;
void visit( FeatureDefinition& node ) override;
+ void visit( ImplementationDefinition& node ) override;
void visit( DeclarationDefinition& node ) override;
void visit( ValueAtom& node ) override;
@@ -352,6 +353,24 @@ void AstDumpSourceVisitor::visit( FeatureDefinition& node )
m_stream << "}";
}
+void AstDumpSourceVisitor::visit( ImplementationDefinition& node )
+{
+ m_stream << "implements ";
+ if( node.identifier()->name() != "" )
+ {
+ node.identifier()->accept( *this );
+ m_stream << " for ";
+ }
+ node.type()->accept( *this );
+ m_stream << " =\n{";
+ for( auto& e : *node.definitions() )
+ {
+ m_stream << "\n ";
+ e->accept( *this );
+ }
+ m_stream << "}";
+}
+
void AstDumpSourceVisitor::visit( DeclarationDefinition& node )
{
m_stream << " ";
diff --git a/src/various/Grammar.org b/src/various/Grammar.org
index 289464fdc..37ec003ac 100644
--- a/src/various/Grammar.org
+++ b/src/various/Grammar.org
@@ -9,6 +9,7 @@ Definition
| EnumerationDefinition
| StructureDefinition
| FeatureDefinition
+| ImplementationDefinition
| error // error recovery
AttributedDefinition
@@ -78,9 +79,21 @@ FeatureDeclarationOrDefinition
| RuleDefinition
FeatureDeclarationsAndDefinitions
-: FeatureDeclarationsAndDefinitions COMMA FeatureDeclarationOrDefinition
+: FeatureDeclarationsAndDefinitions FeatureDeclarationOrDefinition
| FeatureDeclarationOrDefinition
+ImplementationDefinition
+: IMPLEMENTS IdentifierPath FOR Type EQUAL LCURPAREN ImplementationDefinitionDefinitions RCURPAREN
+| IMPLEMENTS Type EQUAL LCURPAREN ImplementationDefinitionDefinitions RCURPAREN
+
+ImplementationDefinitionDefinition
+: DerivedDefinition
+| RuleDefinition
+
+ImplementationDefinitionDefinitions
+: ImplementationDefinitionDefinitions ImplementationDefinitionDefinition
+| ImplementationDefinitionDefinition
+
DeclarationDefinition
: DERIVED Identifier COLON MaybeFunctionParameters MAPS Type
| RULE Identifier COLON MaybeFunctionParameters MAPS Type
@@ -100,6 +113,7 @@ DotSeparatedIdentifiers
IdentifierPath
: DotSeparatedIdentifiers %prec ABSOLUTE_PATH
| DOT DotSeparatedIdentifiers
+| THIS DOT DotSeparatedIdentifiers
Variable
: Identifier COLON Type
diff --git a/src/various/GrammarLexer.cpp b/src/various/GrammarLexer.cpp
index 1d89247f0..5d1e98e9f 100644
--- a/src/various/GrammarLexer.cpp
+++ b/src/various/GrammarLexer.cpp
@@ -322,8 +322,8 @@ int yyFlexLexer::yylex()
(yy_hold_char) = *yy_cp; \
*yy_cp = '\0'; \
(yy_c_buf_p) = yy_cp;
-#define YY_NUM_RULES 94
-#define YY_END_OF_BUFFER 95
+#define YY_NUM_RULES 97
+#define YY_END_OF_BUFFER 98
/* This struct is not used in this scanner,
but its presence is necessary. */
struct yy_trans_info
@@ -331,35 +331,36 @@ struct yy_trans_info
flex_int32_t yy_verify;
flex_int32_t yy_nxt;
};
-static const flex_int16_t yy_accept[250] =
+static const flex_int16_t yy_accept[258] =
{ 0,
- 0, 0, 0, 0, 0, 0, 86, 86, 95, 93,
- 76, 77, 93, 85, 62, 64, 48, 49, 60, 45,
- 57, 46, 66, 61, 4, 4, 54, 58, 47, 59,
- 56, 75, 75, 50, 51, 63, 55, 75, 75, 75,
- 75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
- 75, 75, 75, 75, 52, 93, 53, 79, 80, 84,
- 83, 84, 84, 86, 87, 92, 94, 76, 77, 70,
- 67, 65, 81, 78, 4, 0, 4, 0, 0, 0,
- 69, 71, 68, 72, 75, 75, 75, 75, 75, 75,
- 26, 75, 75, 75, 75, 75, 75, 75, 75, 28,
-
- 75, 22, 75, 75, 75, 32, 41, 75, 75, 75,
- 75, 75, 75, 75, 75, 75, 75, 73, 74, 84,
- 84, 82, 86, 90, 91, 88, 89, 4, 5, 1,
- 3, 2, 75, 40, 75, 75, 75, 75, 75, 75,
- 75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
- 75, 21, 44, 18, 75, 16, 75, 75, 75, 75,
- 75, 75, 42, 0, 1, 1, 3, 0, 3, 2,
- 2, 6, 27, 31, 75, 75, 75, 75, 30, 75,
- 75, 9, 75, 75, 75, 75, 75, 75, 75, 7,
- 75, 10, 20, 75, 29, 39, 75, 36, 0, 5,
-
- 3, 75, 75, 75, 75, 75, 75, 75, 38, 75,
- 75, 75, 34, 75, 75, 75, 75, 37, 3, 3,
- 24, 75, 75, 75, 19, 17, 35, 75, 23, 75,
- 75, 75, 75, 75, 33, 13, 8, 15, 75, 43,
- 75, 25, 75, 11, 75, 75, 12, 14, 0
+ 0, 0, 0, 0, 0, 0, 89, 89, 98, 96,
+ 79, 80, 96, 88, 65, 67, 51, 52, 63, 48,
+ 60, 49, 69, 64, 4, 4, 57, 61, 50, 62,
+ 59, 78, 78, 53, 54, 66, 58, 78, 78, 78,
+ 78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+ 78, 78, 78, 78, 55, 96, 56, 82, 83, 87,
+ 86, 87, 87, 89, 90, 95, 97, 79, 80, 73,
+ 70, 68, 84, 81, 4, 0, 4, 0, 0, 0,
+ 72, 74, 71, 75, 78, 78, 78, 78, 78, 78,
+ 29, 78, 78, 78, 78, 78, 78, 78, 78, 31,
+
+ 78, 25, 78, 78, 78, 35, 44, 78, 78, 78,
+ 78, 78, 78, 78, 78, 78, 78, 76, 77, 87,
+ 87, 85, 89, 93, 94, 91, 92, 4, 5, 1,
+ 3, 2, 78, 43, 78, 78, 78, 78, 78, 78,
+ 78, 78, 78, 78, 78, 17, 78, 78, 78, 78,
+ 78, 24, 47, 21, 78, 19, 78, 78, 78, 78,
+ 78, 78, 78, 45, 0, 1, 1, 3, 0, 3,
+ 2, 2, 6, 30, 34, 78, 78, 78, 78, 33,
+ 78, 78, 9, 78, 78, 78, 78, 78, 78, 78,
+ 7, 78, 10, 23, 78, 32, 18, 42, 78, 39,
+
+ 0, 5, 3, 78, 78, 78, 78, 78, 78, 78,
+ 41, 78, 78, 78, 37, 78, 78, 78, 78, 78,
+ 40, 3, 3, 27, 78, 78, 78, 22, 20, 38,
+ 78, 26, 78, 78, 78, 78, 78, 78, 36, 13,
+ 8, 15, 78, 78, 46, 78, 28, 78, 11, 78,
+ 78, 78, 78, 12, 14, 16, 0
} ;
static const YY_CHAR yy_ec[256] =
@@ -405,71 +406,73 @@ static const YY_CHAR yy_meta[65] =
7, 1, 1, 1
} ;
-static const flex_int16_t yy_base[258] =
+static const flex_int16_t yy_base[266] =
{ 0,
- 0, 0, 367, 366, 62, 64, 66, 68, 368, 371,
- 74, 364, 344, 371, 371, 371, 371, 371, 371, 371,
- 371, 342, 349, 66, 97, 71, 341, 340, 338, 338,
- 371, 0, 334, 371, 371, 371, 0, 308, 40, 40,
- 46, 41, 306, 51, 313, 304, 43, 314, 296, 66,
- 54, 302, 305, 299, 286, 284, 371, 371, 371, 343,
- 371, 342, 329, 0, 371, 371, 111, 116, 341, 371,
- 371, 371, 371, 371, 116, 108, 122, 93, 125, 0,
- 371, 371, 371, 371, 0, 310, 300, 73, 290, 49,
- 0, 285, 90, 293, 290, 297, 282, 285, 286, 0,
-
- 281, 286, 288, 274, 273, 0, 0, 274, 279, 273,
- 279, 270, 280, 265, 279, 264, 265, 371, 371, 314,
- 313, 371, 0, 371, 371, 371, 371, 137, 131, 145,
- 160, 308, 284, 0, 266, 270, 261, 106, 265, 267,
- 114, 260, 253, 252, 250, 265, 263, 261, 254, 245,
- 246, 0, 0, 0, 256, 0, 246, 240, 246, 252,
- 251, 248, 0, 168, 173, 175, 180, 153, 186, 284,
- 283, 0, 0, 0, 235, 232, 238, 229, 0, 246,
- 242, 0, 228, 240, 225, 233, 224, 224, 232, 231,
- 236, 0, 0, 234, 0, 0, 230, 0, 189, 192,
-
- 204, 230, 224, 228, 227, 214, 209, 206, 0, 203,
- 206, 174, 0, 176, 177, 160, 158, 0, 207, 210,
- 0, 157, 159, 158, 0, 0, 0, 152, 0, 138,
- 129, 127, 130, 108, 0, 0, 0, 0, 114, 0,
- 111, 0, 104, 0, 77, 93, 0, 0, 371, 229,
- 236, 243, 245, 252, 259, 64, 263
+ 0, 0, 375, 374, 62, 64, 66, 68, 376, 379,
+ 74, 372, 352, 379, 379, 379, 379, 379, 379, 379,
+ 379, 350, 357, 66, 97, 71, 349, 348, 346, 346,
+ 379, 0, 342, 379, 379, 379, 0, 316, 40, 40,
+ 46, 41, 314, 51, 321, 312, 43, 322, 304, 66,
+ 54, 310, 313, 307, 294, 292, 379, 379, 379, 351,
+ 379, 350, 337, 0, 379, 379, 111, 116, 349, 379,
+ 379, 379, 379, 379, 116, 108, 122, 93, 125, 0,
+ 379, 379, 379, 379, 0, 318, 308, 73, 298, 49,
+ 0, 293, 90, 301, 298, 305, 290, 293, 294, 0,
+
+ 289, 294, 296, 282, 281, 0, 0, 282, 287, 281,
+ 287, 278, 102, 274, 288, 273, 274, 379, 379, 323,
+ 322, 379, 0, 379, 379, 379, 379, 141, 135, 138,
+ 154, 317, 293, 0, 275, 279, 270, 123, 274, 276,
+ 113, 269, 262, 261, 259, 274, 272, 270, 263, 254,
+ 255, 0, 0, 0, 265, 0, 255, 249, 255, 249,
+ 260, 259, 256, 0, 162, 167, 169, 174, 177, 181,
+ 292, 291, 0, 0, 0, 243, 240, 246, 237, 0,
+ 254, 250, 0, 236, 248, 233, 241, 232, 232, 158,
+ 240, 245, 0, 0, 243, 0, 0, 0, 239, 0,
+
+ 188, 191, 194, 239, 233, 237, 236, 224, 224, 221,
+ 0, 221, 226, 227, 0, 223, 228, 230, 213, 211,
+ 0, 206, 209, 0, 205, 218, 214, 0, 0, 0,
+ 210, 0, 171, 178, 165, 171, 175, 159, 0, 0,
+ 0, 0, 165, 153, 0, 140, 0, 129, 0, 110,
+ 89, 95, 81, 0, 0, 0, 379, 228, 235, 242,
+ 244, 251, 258, 64, 262
} ;
-static const flex_int16_t yy_def[258] =
+static const flex_int16_t yy_def[266] =
{ 0,
- 249, 1, 250, 250, 251, 251, 252, 252, 249, 249,
- 249, 249, 249, 249, 249, 249, 249, 249, 249, 249,
- 249, 249, 249, 249, 249, 249, 249, 249, 249, 249,
- 249, 253, 253, 249, 249, 249, 253, 253, 253, 253,
- 253, 253, 253, 253, 253, 253, 253, 253, 253, 253,
- 253, 253, 253, 253, 249, 249, 249, 249, 249, 254,
- 249, 254, 249, 255, 249, 249, 249, 249, 249, 249,
- 249, 249, 249, 249, 249, 249, 249, 249, 249, 256,
- 249, 249, 249, 249, 253, 253, 253, 253, 253, 253,
- 253, 253, 253, 253, 253, 253, 253, 253, 253, 253,
-
- 253, 253, 253, 253, 253, 253, 253, 253, 253, 253,
- 253, 253, 253, 253, 253, 253, 253, 249, 249, 254,
- 254, 249, 255, 249, 249, 249, 249, 249, 249, 249,
- 249, 257, 253, 253, 253, 253, 253, 253, 253, 253,
- 253, 253, 253, 253, 253, 253, 253, 253, 253, 253,
- 253, 253, 253, 253, 253, 253, 253, 253, 253, 253,
- 253, 253, 253, 249, 249, 249, 249, 249, 249, 257,
- 257, 253, 253, 253, 253, 253, 253, 253, 253, 253,
- 253, 253, 253, 253, 253, 253, 253, 253, 253, 253,
- 253, 253, 253, 253, 253, 253, 253, 253, 249, 249,
-
- 249, 253, 253, 253, 253, 253, 253, 253, 253, 253,
- 253, 253, 253, 253, 253, 253, 253, 253, 249, 249,
- 253, 253, 253, 253, 253, 253, 253, 253, 253, 253,
- 253, 253, 253, 253, 253, 253, 253, 253, 253, 253,
- 253, 253, 253, 253, 253, 253, 253, 253, 0, 249,
- 249, 249, 249, 249, 249, 249, 249
+ 257, 1, 258, 258, 259, 259, 260, 260, 257, 257,
+ 257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
+ 257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
+ 257, 261, 261, 257, 257, 257, 261, 261, 261, 261,
+ 261, 261, 261, 261, 261, 261, 261, 261, 261, 261,
+ 261, 261, 261, 261, 257, 257, 257, 257, 257, 262,
+ 257, 262, 257, 263, 257, 257, 257, 257, 257, 257,
+ 257, 257, 257, 257, 257, 257, 257, 257, 257, 264,
+ 257, 257, 257, 257, 261, 261, 261, 261, 261, 261,
+ 261, 261, 261, 261, 261, 261, 261, 261, 261, 261,
+
+ 261, 261, 261, 261, 261, 261, 261, 261, 261, 261,
+ 261, 261, 261, 261, 261, 261, 261, 257, 257, 262,
+ 262, 257, 263, 257, 257, 257, 257, 257, 257, 257,
+ 257, 265, 261, 261, 261, 261, 261, 261, 261, 261,
+ 261, 261, 261, 261, 261, 261, 261, 261, 261, 261,
+ 261, 261, 261, 261, 261, 261, 261, 261, 261, 261,
+ 261, 261, 261, 261, 257, 257, 257, 257, 257, 257,
+ 265, 265, 261, 261, 261, 261, 261, 261, 261, 261,
+ 261, 261, 261, 261, 261, 261, 261, 261, 261, 261,
+ 261, 261, 261, 261, 261, 261, 261, 261, 261, 261,
+
+ 257, 257, 257, 261, 261, 261, 261, 261, 261, 261,
+ 261, 261, 261, 261, 261, 261, 261, 261, 261, 261,
+ 261, 257, 257, 261, 261, 261, 261, 261, 261, 261,
+ 261, 261, 261, 261, 261, 261, 261, 261, 261, 261,
+ 261, 261, 261, 261, 261, 261, 261, 261, 261, 261,
+ 261, 261, 261, 261, 261, 261, 0, 257, 257, 257,
+ 257, 257, 257, 257, 257
} ;
-static const flex_int16_t yy_nxt[436] =
+static const flex_int16_t yy_nxt[444] =
{ 0,
10, 11, 12, 11, 13, 14, 15, 16, 17, 18,
19, 20, 21, 22, 23, 24, 25, 26, 26, 27,
@@ -485,43 +488,44 @@ static const flex_int16_t yy_nxt[436] =
102, 67, 139, 67, 75, 94, 103, 114, 110, 130,
130, 76, 111, 77, 77, 77, 124, 68, 125, 68,
135, 112, 78, 75, 129, 129, 129, 136, 79, 75,
- 80, 141, 128, 128, 128, 248, 76, 247, 77, 77,
- 77, 131, 131, 131, 75, 176, 142, 129, 129, 129,
- 79, 177, 165, 128, 128, 128, 80, 246, 245, 164,
- 126, 166, 166, 244, 243, 180, 127, 167, 181, 201,
- 201, 201, 242, 164, 241, 168, 169, 169, 169, 199,
- 165, 199, 165, 240, 200, 200, 200, 167, 239, 166,
- 166, 166, 166, 167, 238, 168, 169, 169, 169, 237,
-
- 236, 168, 169, 169, 169, 200, 200, 200, 200, 200,
- 200, 219, 235, 234, 219, 233, 232, 219, 231, 230,
- 220, 220, 220, 220, 220, 220, 220, 220, 220, 58,
- 58, 58, 58, 58, 58, 58, 60, 60, 60, 60,
- 60, 60, 60, 64, 64, 64, 64, 64, 64, 64,
- 85, 85, 120, 229, 120, 120, 228, 120, 120, 123,
- 227, 226, 123, 123, 123, 123, 171, 225, 171, 224,
- 223, 222, 221, 218, 217, 216, 215, 214, 213, 212,
- 211, 210, 209, 208, 207, 206, 205, 204, 203, 202,
- 170, 170, 198, 197, 196, 195, 194, 193, 192, 191,
-
- 190, 189, 188, 187, 186, 185, 184, 183, 182, 179,
- 178, 175, 174, 173, 172, 170, 121, 121, 163, 162,
- 161, 160, 159, 158, 157, 156, 155, 154, 153, 152,
- 151, 150, 149, 148, 147, 146, 145, 144, 143, 140,
- 137, 134, 133, 69, 122, 121, 121, 119, 118, 117,
- 116, 115, 109, 108, 105, 104, 99, 87, 86, 84,
- 83, 82, 81, 72, 71, 70, 69, 249, 59, 59,
- 9, 249, 249, 249, 249, 249, 249, 249, 249, 249,
- 249, 249, 249, 249, 249, 249, 249, 249, 249, 249,
- 249, 249, 249, 249, 249, 249, 249, 249, 249, 249,
-
- 249, 249, 249, 249, 249, 249, 249, 249, 249, 249,
- 249, 249, 249, 249, 249, 249, 249, 249, 249, 249,
- 249, 249, 249, 249, 249, 249, 249, 249, 249, 249,
- 249, 249, 249, 249, 249
+ 80, 141, 128, 128, 128, 256, 76, 255, 77, 77,
+ 77, 131, 131, 131, 159, 166, 142, 160, 75, 254,
+ 79, 129, 129, 129, 167, 167, 80, 128, 128, 128,
+ 126, 168, 177, 165, 181, 253, 127, 182, 178, 169,
+ 170, 170, 170, 201, 166, 201, 166, 165, 202, 202,
+ 202, 168, 252, 167, 167, 167, 167, 251, 168, 169,
+ 170, 170, 170, 203, 203, 203, 169, 170, 170, 170,
+
+ 216, 222, 250, 217, 202, 202, 202, 202, 202, 202,
+ 223, 223, 223, 222, 249, 248, 222, 247, 246, 245,
+ 244, 243, 223, 223, 223, 223, 223, 223, 58, 58,
+ 58, 58, 58, 58, 58, 60, 60, 60, 60, 60,
+ 60, 60, 64, 64, 64, 64, 64, 64, 64, 85,
+ 85, 120, 242, 120, 120, 241, 120, 120, 123, 240,
+ 239, 123, 123, 123, 123, 172, 238, 172, 237, 236,
+ 235, 234, 233, 232, 231, 230, 229, 228, 227, 226,
+ 225, 224, 221, 220, 219, 218, 215, 214, 213, 212,
+ 211, 210, 209, 208, 207, 206, 205, 204, 171, 171,
+
+ 200, 199, 198, 197, 196, 195, 194, 193, 192, 191,
+ 190, 189, 188, 187, 186, 185, 184, 183, 180, 179,
+ 176, 175, 174, 173, 171, 121, 121, 164, 163, 162,
+ 161, 158, 157, 156, 155, 154, 153, 152, 151, 150,
+ 149, 148, 147, 146, 145, 144, 143, 140, 137, 134,
+ 133, 69, 122, 121, 121, 119, 118, 117, 116, 115,
+ 109, 108, 105, 104, 99, 87, 86, 84, 83, 82,
+ 81, 72, 71, 70, 69, 257, 59, 59, 9, 257,
+ 257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
+ 257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
+
+ 257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
+ 257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
+ 257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
+ 257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
+ 257, 257, 257
} ;
-static const flex_int16_t yy_chk[436] =
+static const flex_int16_t yy_chk[444] =
{ 0,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
@@ -529,7 +533,7 @@ static const flex_int16_t yy_chk[436] =
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 5, 5, 6, 6, 7, 256,
+ 1, 1, 1, 1, 5, 5, 6, 6, 7, 264,
8, 7, 5, 8, 6, 11, 24, 11, 26, 39,
42, 24, 40, 42, 39, 26, 47, 26, 26, 26,
40, 42, 90, 41, 44, 41, 47, 42, 51, 44,
@@ -537,40 +541,41 @@ static const flex_int16_t yy_chk[436] =
44, 7, 90, 8, 25, 41, 44, 51, 50, 78,
78, 25, 50, 25, 25, 25, 67, 68, 67, 68,
88, 50, 25, 75, 76, 76, 76, 88, 25, 77,
- 25, 93, 75, 75, 75, 246, 77, 245, 77, 77,
- 77, 79, 79, 79, 128, 138, 93, 129, 129, 129,
- 25, 138, 130, 128, 128, 128, 25, 243, 241, 129,
- 67, 130, 130, 239, 234, 141, 67, 131, 141, 168,
- 168, 168, 233, 129, 232, 131, 131, 131, 131, 164,
- 165, 164, 166, 231, 164, 164, 164, 167, 230, 165,
- 165, 166, 166, 169, 228, 167, 167, 167, 167, 224,
-
- 223, 169, 169, 169, 169, 199, 199, 199, 200, 200,
- 200, 201, 222, 217, 219, 216, 215, 220, 214, 212,
- 201, 201, 201, 219, 219, 219, 220, 220, 220, 250,
- 250, 250, 250, 250, 250, 250, 251, 251, 251, 251,
- 251, 251, 251, 252, 252, 252, 252, 252, 252, 252,
- 253, 253, 254, 211, 254, 254, 210, 254, 254, 255,
- 208, 207, 255, 255, 255, 255, 257, 206, 257, 205,
- 204, 203, 202, 197, 194, 191, 190, 189, 188, 187,
- 186, 185, 184, 183, 181, 180, 178, 177, 176, 175,
- 171, 170, 162, 161, 160, 159, 158, 157, 155, 151,
-
- 150, 149, 148, 147, 146, 145, 144, 143, 142, 140,
- 139, 137, 136, 135, 133, 132, 121, 120, 117, 116,
- 115, 114, 113, 112, 111, 110, 109, 108, 105, 104,
- 103, 102, 101, 99, 98, 97, 96, 95, 94, 92,
- 89, 87, 86, 69, 63, 62, 60, 56, 55, 54,
- 53, 52, 49, 48, 46, 45, 43, 38, 33, 30,
- 29, 28, 27, 23, 22, 13, 12, 9, 4, 3,
- 249, 249, 249, 249, 249, 249, 249, 249, 249, 249,
- 249, 249, 249, 249, 249, 249, 249, 249, 249, 249,
- 249, 249, 249, 249, 249, 249, 249, 249, 249, 249,
-
- 249, 249, 249, 249, 249, 249, 249, 249, 249, 249,
- 249, 249, 249, 249, 249, 249, 249, 249, 249, 249,
- 249, 249, 249, 249, 249, 249, 249, 249, 249, 249,
- 249, 249, 249, 249, 249
+ 25, 93, 75, 75, 75, 253, 77, 252, 77, 77,
+ 77, 79, 79, 79, 113, 130, 93, 113, 128, 251,
+ 25, 129, 129, 129, 130, 130, 25, 128, 128, 128,
+ 67, 131, 138, 129, 141, 250, 67, 141, 138, 131,
+ 131, 131, 131, 165, 166, 165, 167, 129, 165, 165,
+ 165, 168, 248, 166, 166, 167, 167, 246, 170, 168,
+ 168, 168, 168, 169, 169, 169, 170, 170, 170, 170,
+
+ 190, 203, 244, 190, 201, 201, 201, 202, 202, 202,
+ 203, 203, 203, 222, 243, 238, 223, 237, 236, 235,
+ 234, 233, 222, 222, 222, 223, 223, 223, 258, 258,
+ 258, 258, 258, 258, 258, 259, 259, 259, 259, 259,
+ 259, 259, 260, 260, 260, 260, 260, 260, 260, 261,
+ 261, 262, 231, 262, 262, 227, 262, 262, 263, 226,
+ 225, 263, 263, 263, 263, 265, 220, 265, 219, 218,
+ 217, 216, 214, 213, 212, 210, 209, 208, 207, 206,
+ 205, 204, 199, 195, 192, 191, 189, 188, 187, 186,
+ 185, 184, 182, 181, 179, 178, 177, 176, 172, 171,
+
+ 163, 162, 161, 160, 159, 158, 157, 155, 151, 150,
+ 149, 148, 147, 146, 145, 144, 143, 142, 140, 139,
+ 137, 136, 135, 133, 132, 121, 120, 117, 116, 115,
+ 114, 112, 111, 110, 109, 108, 105, 104, 103, 102,
+ 101, 99, 98, 97, 96, 95, 94, 92, 89, 87,
+ 86, 69, 63, 62, 60, 56, 55, 54, 53, 52,
+ 49, 48, 46, 45, 43, 38, 33, 30, 29, 28,
+ 27, 23, 22, 13, 12, 9, 4, 3, 257, 257,
+ 257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
+ 257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
+
+ 257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
+ 257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
+ 257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
+ 257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
+ 257, 257, 257
} ;
/* The intent behind this definition is that it'll catch
@@ -622,11 +627,11 @@ using namespace libcasm_fe;
// Code run each time a pattern is matched.
#define YY_USER_ACTION loc.columns( yyleng );
-#line 625 "src/various/GrammarLexer.cpp"
+#line 630 "src/various/GrammarLexer.cpp"
/* %option debug */
#define YY_NO_INPUT 1
-#line 629 "src/various/GrammarLexer.cpp"
+#line 634 "src/various/GrammarLexer.cpp"
#define INITIAL 0
#define LCOMMENT 1
@@ -769,7 +774,7 @@ YY_DECL
loc.step();
-#line 772 "src/various/GrammarLexer.cpp"
+#line 777 "src/various/GrammarLexer.cpp"
while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
{
@@ -796,13 +801,13 @@ YY_DECL
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
{
yy_current_state = (int) yy_def[yy_current_state];
- if ( yy_current_state >= 250 )
+ if ( yy_current_state >= 258 )
yy_c = yy_meta[yy_c];
}
yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
++yy_cp;
}
- while ( yy_current_state != 249 );
+ while ( yy_current_state != 257 );
yy_cp = (yy_last_accepting_cpos);
yy_current_state = (yy_last_accepting_state);
@@ -909,338 +914,353 @@ YY_RULE_SETUP
YY_BREAK
case 16:
YY_RULE_SETUP
-#line 100 "obj/src/GrammarLexer.l"
-{ return Parser::make_SEQ(loc); }
+#line 99 "obj/src/GrammarLexer.l"
+{ return Parser::make_IMPLEMENTS(loc); }
YY_BREAK
case 17:
YY_RULE_SETUP
-#line 101 "obj/src/GrammarLexer.l"
-{ return Parser::make_ENDSEQ(loc); }
+#line 100 "obj/src/GrammarLexer.l"
+{ return Parser::make_FOR(loc); }
YY_BREAK
case 18:
YY_RULE_SETUP
-#line 102 "obj/src/GrammarLexer.l"
-{ return Parser::make_PAR(loc); }
+#line 101 "obj/src/GrammarLexer.l"
+{ return Parser::make_THIS(loc); }
YY_BREAK
case 19:
YY_RULE_SETUP
#line 103 "obj/src/GrammarLexer.l"
-{ return Parser::make_ENDPAR(loc); }
+{ return Parser::make_SEQ(loc); }
YY_BREAK
case 20:
YY_RULE_SETUP
-#line 105 "obj/src/GrammarLexer.l"
-{ return Parser::make_SKIP(loc); }
+#line 104 "obj/src/GrammarLexer.l"
+{ return Parser::make_ENDSEQ(loc); }
YY_BREAK
case 21:
YY_RULE_SETUP
-#line 106 "obj/src/GrammarLexer.l"
-{ return Parser::make_LET(loc); }
+#line 105 "obj/src/GrammarLexer.l"
+{ return Parser::make_PAR(loc); }
YY_BREAK
case 22:
YY_RULE_SETUP
-#line 107 "obj/src/GrammarLexer.l"
-{ return Parser::make_IN(loc); }
+#line 106 "obj/src/GrammarLexer.l"
+{ return Parser::make_ENDPAR(loc); }
YY_BREAK
case 23:
YY_RULE_SETUP
#line 108 "obj/src/GrammarLexer.l"
-{ return Parser::make_FORALL(loc); }
+{ return Parser::make_SKIP(loc); }
YY_BREAK
case 24:
YY_RULE_SETUP
#line 109 "obj/src/GrammarLexer.l"
-{ return Parser::make_CHOOSE(loc); }
+{ return Parser::make_LET(loc); }
YY_BREAK
case 25:
YY_RULE_SETUP
#line 110 "obj/src/GrammarLexer.l"
-{ return Parser::make_ITERATE(loc); }
+{ return Parser::make_IN(loc); }
YY_BREAK
case 26:
YY_RULE_SETUP
#line 111 "obj/src/GrammarLexer.l"
-{ return Parser::make_DO(loc); }
+{ return Parser::make_FORALL(loc); }
YY_BREAK
case 27:
YY_RULE_SETUP
#line 112 "obj/src/GrammarLexer.l"
-{ return Parser::make_CALL(loc); }
+{ return Parser::make_CHOOSE(loc); }
YY_BREAK
case 28:
YY_RULE_SETUP
#line 113 "obj/src/GrammarLexer.l"
-{ return Parser::make_IF(loc); }
+{ return Parser::make_ITERATE(loc); }
YY_BREAK
case 29:
YY_RULE_SETUP
#line 114 "obj/src/GrammarLexer.l"
-{ return Parser::make_THEN(loc); }
+{ return Parser::make_DO(loc); }
YY_BREAK
case 30:
YY_RULE_SETUP
#line 115 "obj/src/GrammarLexer.l"
-{ return Parser::make_ELSE(loc); }
+{ return Parser::make_CALL(loc); }
YY_BREAK
case 31:
YY_RULE_SETUP
#line 116 "obj/src/GrammarLexer.l"
-{ return Parser::make_CASE(loc); }
+{ return Parser::make_IF(loc); }
YY_BREAK
case 32:
YY_RULE_SETUP
#line 117 "obj/src/GrammarLexer.l"
-{ return Parser::make_OF(loc); }
+{ return Parser::make_THEN(loc); }
YY_BREAK
case 33:
YY_RULE_SETUP
#line 118 "obj/src/GrammarLexer.l"
-{ return Parser::make_DEFAULT(loc); }
+{ return Parser::make_ELSE(loc); }
YY_BREAK
case 34:
YY_RULE_SETUP
#line 119 "obj/src/GrammarLexer.l"
-{ return Parser::make_HOLDS(loc); }
+{ return Parser::make_CASE(loc); }
YY_BREAK
case 35:
YY_RULE_SETUP
#line 120 "obj/src/GrammarLexer.l"
-{ return Parser::make_EXISTS(loc); }
+{ return Parser::make_OF(loc); }
YY_BREAK
case 36:
YY_RULE_SETUP
#line 121 "obj/src/GrammarLexer.l"
-{ return Parser::make_WITH(loc); }
+{ return Parser::make_DEFAULT(loc); }
YY_BREAK
case 37:
YY_RULE_SETUP
-#line 123 "obj/src/GrammarLexer.l"
-{ return Parser::make_UNDEF(loc); }
+#line 122 "obj/src/GrammarLexer.l"
+{ return Parser::make_HOLDS(loc); }
YY_BREAK
case 38:
YY_RULE_SETUP
-#line 124 "obj/src/GrammarLexer.l"
-{ return Parser::make_FALSE(loc); }
+#line 123 "obj/src/GrammarLexer.l"
+{ return Parser::make_EXISTS(loc); }
YY_BREAK
case 39:
YY_RULE_SETUP
-#line 125 "obj/src/GrammarLexer.l"
-{ return Parser::make_TRUE(loc); }
+#line 124 "obj/src/GrammarLexer.l"
+{ return Parser::make_WITH(loc); }
YY_BREAK
case 40:
YY_RULE_SETUP
-#line 127 "obj/src/GrammarLexer.l"
-{ return Parser::make_AND(loc); }
+#line 126 "obj/src/GrammarLexer.l"
+{ return Parser::make_UNDEF(loc); }
YY_BREAK
case 41:
YY_RULE_SETUP
-#line 128 "obj/src/GrammarLexer.l"
-{ return Parser::make_OR(loc); }
+#line 127 "obj/src/GrammarLexer.l"
+{ return Parser::make_FALSE(loc); }
YY_BREAK
case 42:
YY_RULE_SETUP
-#line 129 "obj/src/GrammarLexer.l"
-{ return Parser::make_XOR(loc); }
+#line 128 "obj/src/GrammarLexer.l"
+{ return Parser::make_TRUE(loc); }
YY_BREAK
case 43:
YY_RULE_SETUP
#line 130 "obj/src/GrammarLexer.l"
-{ return Parser::make_IMPLIES(loc); }
+{ return Parser::make_AND(loc); }
YY_BREAK
case 44:
YY_RULE_SETUP
#line 131 "obj/src/GrammarLexer.l"
-{ return Parser::make_NOT(loc); }
+{ return Parser::make_OR(loc); }
YY_BREAK
case 45:
YY_RULE_SETUP
-#line 133 "obj/src/GrammarLexer.l"
-{ return Parser::make_PLUS(loc); }
+#line 132 "obj/src/GrammarLexer.l"
+{ return Parser::make_XOR(loc); }
YY_BREAK
case 46:
YY_RULE_SETUP
-#line 134 "obj/src/GrammarLexer.l"
-{ return Parser::make_MINUS(loc); }
+#line 133 "obj/src/GrammarLexer.l"
+{ return Parser::make_IMPLIES(loc); }
YY_BREAK
case 47:
YY_RULE_SETUP
-#line 135 "obj/src/GrammarLexer.l"
-{ return Parser::make_EQUAL(loc); }
+#line 134 "obj/src/GrammarLexer.l"
+{ return Parser::make_NOT(loc); }
YY_BREAK
case 48:
YY_RULE_SETUP
#line 136 "obj/src/GrammarLexer.l"
-{ return Parser::make_LPAREN(loc); }
+{ return Parser::make_PLUS(loc); }
YY_BREAK
case 49:
YY_RULE_SETUP
#line 137 "obj/src/GrammarLexer.l"
-{ return Parser::make_RPAREN(loc); }
+{ return Parser::make_MINUS(loc); }
YY_BREAK
case 50:
YY_RULE_SETUP
#line 138 "obj/src/GrammarLexer.l"
-{ return Parser::make_LSQPAREN(loc); }
+{ return Parser::make_EQUAL(loc); }
YY_BREAK
case 51:
YY_RULE_SETUP
#line 139 "obj/src/GrammarLexer.l"
-{ return Parser::make_RSQPAREN(loc); }
+{ return Parser::make_LPAREN(loc); }
YY_BREAK
case 52:
YY_RULE_SETUP
#line 140 "obj/src/GrammarLexer.l"
-{ return Parser::make_LCURPAREN(loc); }
+{ return Parser::make_RPAREN(loc); }
YY_BREAK
case 53:
YY_RULE_SETUP
#line 141 "obj/src/GrammarLexer.l"
-{ return Parser::make_RCURPAREN(loc); }
+{ return Parser::make_LSQPAREN(loc); }
YY_BREAK
case 54:
YY_RULE_SETUP
#line 142 "obj/src/GrammarLexer.l"
-{ return Parser::make_COLON(loc); }
+{ return Parser::make_RSQPAREN(loc); }
YY_BREAK
case 55:
YY_RULE_SETUP
#line 143 "obj/src/GrammarLexer.l"
-{ return Parser::make_UNDERLINE(loc); }
+{ return Parser::make_LCURPAREN(loc); }
YY_BREAK
case 56:
YY_RULE_SETUP
#line 144 "obj/src/GrammarLexer.l"
-{ return Parser::make_AT(loc); }
+{ return Parser::make_RCURPAREN(loc); }
YY_BREAK
case 57:
YY_RULE_SETUP
#line 145 "obj/src/GrammarLexer.l"
-{ return Parser::make_COMMA(loc); }
+{ return Parser::make_COLON(loc); }
YY_BREAK
case 58:
YY_RULE_SETUP
#line 146 "obj/src/GrammarLexer.l"
-{ return Parser::make_LESSER(loc); }
+{ return Parser::make_UNDERLINE(loc); }
YY_BREAK
case 59:
YY_RULE_SETUP
#line 147 "obj/src/GrammarLexer.l"
-{ return Parser::make_GREATER(loc); }
+{ return Parser::make_AT(loc); }
YY_BREAK
case 60:
YY_RULE_SETUP
#line 148 "obj/src/GrammarLexer.l"
-{ return Parser::make_ASTERIX(loc); }
+{ return Parser::make_COMMA(loc); }
YY_BREAK
case 61:
YY_RULE_SETUP
#line 149 "obj/src/GrammarLexer.l"
-{ return Parser::make_SLASH(loc); }
+{ return Parser::make_LESSER(loc); }
YY_BREAK
case 62:
YY_RULE_SETUP
#line 150 "obj/src/GrammarLexer.l"
-{ return Parser::make_PERCENT(loc); }
+{ return Parser::make_GREATER(loc); }
YY_BREAK
case 63:
YY_RULE_SETUP
#line 151 "obj/src/GrammarLexer.l"
-{ return Parser::make_CARET(loc); }
+{ return Parser::make_ASTERIX(loc); }
YY_BREAK
case 64:
YY_RULE_SETUP
#line 152 "obj/src/GrammarLexer.l"
-{ return Parser::make_MARK(loc); }
+{ return Parser::make_SLASH(loc); }
YY_BREAK
case 65:
YY_RULE_SETUP
-#line 154 "obj/src/GrammarLexer.l"
-{ return Parser::make_DOTDOT(loc); }
+#line 153 "obj/src/GrammarLexer.l"
+{ return Parser::make_PERCENT(loc); }
YY_BREAK
case 66:
YY_RULE_SETUP
-#line 155 "obj/src/GrammarLexer.l"
-{ return Parser::make_DOT(loc); }
+#line 154 "obj/src/GrammarLexer.l"
+{ return Parser::make_CARET(loc); }
YY_BREAK
case 67:
YY_RULE_SETUP
-#line 156 "obj/src/GrammarLexer.l"
-{ return Parser::make_MAPS(loc); }
+#line 155 "obj/src/GrammarLexer.l"
+{ return Parser::make_MARK(loc); }
YY_BREAK
case 68:
YY_RULE_SETUP
#line 157 "obj/src/GrammarLexer.l"
-{ return Parser::make_ARROW(loc); }
+{ return Parser::make_DOTDOT(loc); }
YY_BREAK
case 69:
YY_RULE_SETUP
#line 158 "obj/src/GrammarLexer.l"
-{ return Parser::make_UPDATE(loc); }
+{ return Parser::make_DOT(loc); }
YY_BREAK
case 70:
YY_RULE_SETUP
#line 159 "obj/src/GrammarLexer.l"
-{ return Parser::make_NEQUAL(loc); }
+{ return Parser::make_MAPS(loc); }
YY_BREAK
case 71:
YY_RULE_SETUP
#line 160 "obj/src/GrammarLexer.l"
-{ return Parser::make_LESSEQ(loc); }
+{ return Parser::make_ARROW(loc); }
YY_BREAK
case 72:
YY_RULE_SETUP
#line 161 "obj/src/GrammarLexer.l"
-{ return Parser::make_GREATEREQ(loc); }
+{ return Parser::make_UPDATE(loc); }
YY_BREAK
case 73:
YY_RULE_SETUP
#line 162 "obj/src/GrammarLexer.l"
-{ return Parser::make_SEQ_BRACKET(loc); }
+{ return Parser::make_NEQUAL(loc); }
YY_BREAK
case 74:
YY_RULE_SETUP
#line 163 "obj/src/GrammarLexer.l"
-{ return Parser::make_ENDSEQ_BRACKET(loc); }
+{ return Parser::make_LESSEQ(loc); }
YY_BREAK
case 75:
YY_RULE_SETUP
-#line 167 "obj/src/GrammarLexer.l"
+#line 164 "obj/src/GrammarLexer.l"
+{ return Parser::make_GREATEREQ(loc); }
+ YY_BREAK
+case 76:
+YY_RULE_SETUP
+#line 165 "obj/src/GrammarLexer.l"
+{ return Parser::make_SEQ_BRACKET(loc); }
+ YY_BREAK
+case 77:
+YY_RULE_SETUP
+#line 166 "obj/src/GrammarLexer.l"
+{ return Parser::make_ENDSEQ_BRACKET(loc); }
+ YY_BREAK
+case 78:
+YY_RULE_SETUP
+#line 170 "obj/src/GrammarLexer.l"
{
return Parser::make_IDENTIFIER( yytext, loc );
}
YY_BREAK
-case 76:
+case 79:
YY_RULE_SETUP
-#line 171 "obj/src/GrammarLexer.l"
+#line 174 "obj/src/GrammarLexer.l"
{ // ignore spaces
loc.step();
}
YY_BREAK
-case 77:
-/* rule 77 can match eol */
+case 80:
+/* rule 80 can match eol */
YY_RULE_SETUP
-#line 175 "obj/src/GrammarLexer.l"
+#line 178 "obj/src/GrammarLexer.l"
{ // ignore newlines
loc.lines( yyleng );
loc.step();
}
YY_BREAK
-case 78:
+case 81:
YY_RULE_SETUP
-#line 180 "obj/src/GrammarLexer.l"
+#line 183 "obj/src/GrammarLexer.l"
{ // single-line comments
BEGIN( LCOMMENT );
}
YY_BREAK
-case 79:
+case 82:
YY_RULE_SETUP
-#line 183 "obj/src/GrammarLexer.l"
+#line 186 "obj/src/GrammarLexer.l"
YY_BREAK
-case 80:
-/* rule 80 can match eol */
+case 83:
+/* rule 83 can match eol */
YY_RULE_SETUP
-#line 184 "obj/src/GrammarLexer.l"
+#line 187 "obj/src/GrammarLexer.l"
{
BEGIN( INITIAL );
loc.lines( 1 );
@@ -1248,127 +1268,127 @@ YY_RULE_SETUP
}
YY_BREAK
case YY_STATE_EOF(LCOMMENT):
-#line 189 "obj/src/GrammarLexer.l"
+#line 192 "obj/src/GrammarLexer.l"
{
BEGIN( INITIAL );
}
YY_BREAK
-case 81:
+case 84:
YY_RULE_SETUP
-#line 193 "obj/src/GrammarLexer.l"
+#line 196 "obj/src/GrammarLexer.l"
{ // multi-line comments
BEGIN( COMMENT );
}
YY_BREAK
-case 82:
+case 85:
YY_RULE_SETUP
-#line 196 "obj/src/GrammarLexer.l"
+#line 199 "obj/src/GrammarLexer.l"
{
BEGIN( INITIAL );
}
YY_BREAK
-case 83:
-/* rule 83 can match eol */
+case 86:
+/* rule 86 can match eol */
YY_RULE_SETUP
-#line 199 "obj/src/GrammarLexer.l"
+#line 202 "obj/src/GrammarLexer.l"
{
loc.lines( 1 );
}
YY_BREAK
-case 84:
+case 87:
YY_RULE_SETUP
-#line 202 "obj/src/GrammarLexer.l"
+#line 205 "obj/src/GrammarLexer.l"
YY_BREAK
case YY_STATE_EOF(COMMENT):
-#line 203 "obj/src/GrammarLexer.l"
+#line 206 "obj/src/GrammarLexer.l"
{
BEGIN( INITIAL );
log.error( {loc}, "multiline comment not terminated", Code::SyntaxErrorUnclosedComment );
yyterminate();
}
YY_BREAK
-case 85:
+case 88:
YY_RULE_SETUP
-#line 209 "obj/src/GrammarLexer.l"
+#line 212 "obj/src/GrammarLexer.l"
{ // strings
BEGIN( STRING );
strbuf.clear();
}
YY_BREAK
-case 86:
+case 89:
YY_RULE_SETUP
-#line 213 "obj/src/GrammarLexer.l"
+#line 216 "obj/src/GrammarLexer.l"
{ /* eat all tokens */
strbuf.append( yytext );
}
YY_BREAK
-case 87:
-/* rule 87 can match eol */
+case 90:
+/* rule 90 can match eol */
YY_RULE_SETUP
-#line 216 "obj/src/GrammarLexer.l"
+#line 219 "obj/src/GrammarLexer.l"
{
loc.lines( 1 );
}
YY_BREAK
-case 88:
+case 91:
YY_RULE_SETUP
-#line 219 "obj/src/GrammarLexer.l"
+#line 222 "obj/src/GrammarLexer.l"
{
strbuf.append( "\n" );
}
YY_BREAK
-case 89:
+case 92:
YY_RULE_SETUP
-#line 222 "obj/src/GrammarLexer.l"
+#line 225 "obj/src/GrammarLexer.l"
{
strbuf.append( "\t" );
}
YY_BREAK
-case 90:
+case 93:
YY_RULE_SETUP
-#line 225 "obj/src/GrammarLexer.l"
+#line 228 "obj/src/GrammarLexer.l"
{
strbuf.append( "\"" );
}
YY_BREAK
-case 91:
+case 94:
YY_RULE_SETUP
-#line 228 "obj/src/GrammarLexer.l"
+#line 231 "obj/src/GrammarLexer.l"
{
strbuf.append( "\'" );
}
YY_BREAK
case YY_STATE_EOF(STRING):
-#line 231 "obj/src/GrammarLexer.l"
+#line 234 "obj/src/GrammarLexer.l"
{
BEGIN( INITIAL );
log.error( {loc}, "string not terminated", Code::SyntaxErrorUnclosedString );
yyterminate();
}
YY_BREAK
-case 92:
+case 95:
YY_RULE_SETUP
-#line 236 "obj/src/GrammarLexer.l"
+#line 239 "obj/src/GrammarLexer.l"
{
BEGIN( INITIAL );
return Parser::make_STRING( strbuf, loc );
}
YY_BREAK
-case 93:
+case 96:
YY_RULE_SETUP
-#line 241 "obj/src/GrammarLexer.l"
+#line 244 "obj/src/GrammarLexer.l"
{
log.error( {loc}, "unrecognized character `" + std::string( yytext ) + "`",
Code::SyntaxErrorUnrecognizedCharacter );
}
YY_BREAK
-case 94:
+case 97:
YY_RULE_SETUP
-#line 246 "obj/src/GrammarLexer.l"
+#line 249 "obj/src/GrammarLexer.l"
YY_FATAL_ERROR( "flex scanner jammed" );
YY_BREAK
-#line 1371 "src/various/GrammarLexer.cpp"
+#line 1391 "src/various/GrammarLexer.cpp"
case YY_STATE_EOF(INITIAL):
yyterminate();
@@ -1782,7 +1802,7 @@ int yyFlexLexer::yy_get_next_buffer()
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
{
yy_current_state = (int) yy_def[yy_current_state];
- if ( yy_current_state >= 250 )
+ if ( yy_current_state >= 258 )
yy_c = yy_meta[yy_c];
}
yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
@@ -1810,11 +1830,11 @@ int yyFlexLexer::yy_get_next_buffer()
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
{
yy_current_state = (int) yy_def[yy_current_state];
- if ( yy_current_state >= 250 )
+ if ( yy_current_state >= 258 )
yy_c = yy_meta[yy_c];
}
yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
- yy_is_jam = (yy_current_state == 249);
+ yy_is_jam = (yy_current_state == 257);
return yy_is_jam ? 0 : yy_current_state;
}
@@ -2324,7 +2344,7 @@ void yyfree (void * ptr )
#define YYTABLES_NAME "yytables"
-#line 246 "obj/src/GrammarLexer.l"
+#line 249 "obj/src/GrammarLexer.l"
Lexer::Lexer( Logger& log, std::istream& in, std::ostream& out )
diff --git a/src/various/GrammarParser.cpp b/src/various/GrammarParser.cpp
index b9e19ce02..f2565d006 100644
--- a/src/various/GrammarParser.cpp
+++ b/src/various/GrammarParser.cpp
@@ -328,259 +328,265 @@ namespace libcasm_fe {
{
switch (that.type_get ())
{
- case 158: // Attribute
+ case 164: // Attribute
value.move< Attribute::Ptr > (that.value);
break;
- case 159: // Attributes
+ case 165: // Attributes
value.move< Attributes::Ptr > (that.value);
break;
- case 160: // BasicAttribute
+ case 166: // BasicAttribute
value.move< BasicAttribute::Ptr > (that.value);
break;
- case 114: // BasicType
+ case 120: // BasicType
value.move< BasicType::Ptr > (that.value);
break;
- case 154: // BlockRule
+ case 160: // BlockRule
value.move< BlockRule::Ptr > (that.value);
break;
- case 157: // CallRule
+ case 163: // CallRule
value.move< CallRule::Ptr > (that.value);
break;
- case 148: // CaseLabel
+ case 154: // CaseLabel
value.move< Case::Ptr > (that.value);
break;
- case 147: // CaseRule
+ case 153: // CaseRule
value.move< CaseRule::Ptr > (that.value);
break;
- case 149: // CaseLabels
+ case 155: // CaseLabels
value.move< Cases::Ptr > (that.value);
break;
- case 139: // ChooseExpression
+ case 145: // ChooseExpression
value.move< ChooseExpression::Ptr > (that.value);
break;
- case 152: // ChooseRule
+ case 158: // ChooseRule
value.move< ChooseRule::Ptr > (that.value);
break;
- case 115: // ComposedType
+ case 121: // ComposedType
value.move< ComposedType::Ptr > (that.value);
break;
- case 138: // ConditionalExpression
+ case 144: // ConditionalExpression
value.move< ConditionalExpression::Ptr > (that.value);
break;
- case 146: // ConditionalRule
+ case 152: // ConditionalRule
value.move< ConditionalRule::Ptr > (that.value);
break;
- case 104: // DeclarationDefinition
+ case 110: // DeclarationDefinition
value.move< DeclarationDefinition::Ptr > (that.value);
break;
- case 85: // Definition
- case 86: // AttributedDefinition
- case 102: // FeatureDeclarationOrDefinition
+ case 88: // Definition
+ case 89: // AttributedDefinition
+ case 105: // FeatureDeclarationOrDefinition
+ case 108: // ImplementationDefinitionDefinition
value.move< Definition::Ptr > (that.value);
break;
- case 87: // Definitions
- case 103: // FeatureDeclarationsAndDefinitions
+ case 90: // Definitions
+ case 106: // FeatureDeclarationsAndDefinitions
+ case 109: // ImplementationDefinitionDefinitions
value.move< Definitions::Ptr > (that.value);
break;
- case 98: // DerivedDefinition
+ case 101: // DerivedDefinition
value.move< DerivedDefinition::Ptr > (that.value);
break;
- case 135: // DirectCallExpression
+ case 141: // DirectCallExpression
value.move< DirectCallExpression::Ptr > (that.value);
break;
- case 99: // EnumerationDefinition
+ case 102: // EnumerationDefinition
value.move< EnumerationDefinition::Ptr > (that.value);
break;
- case 141: // ExistentialQuantifierExpression
+ case 147: // ExistentialQuantifierExpression
value.move< ExistentialQuantifierExpression::Ptr > (that.value);
break;
- case 91: // MaybeDefined
- case 119: // Atom
- case 128: // Term
- case 129: // Expression
+ case 94: // MaybeDefined
+ case 125: // Atom
+ case 134: // Term
+ case 135: // Expression
value.move< Expression::Ptr > (that.value);
break;
- case 161: // ExpressionAttribute
+ case 167: // ExpressionAttribute
value.move< ExpressionAttribute::Ptr > (that.value);
break;
- case 132: // Terms
- case 133: // Arguments
- case 134: // TwoOrMoreArguments
+ case 138: // Terms
+ case 139: // Arguments
+ case 140: // TwoOrMoreArguments
value.move< Expressions::Ptr > (that.value);
break;
- case 101: // FeatureDefinition
+ case 104: // FeatureDefinition
value.move< FeatureDefinition::Ptr > (that.value);
break;
- case 117: // FixedSizedType
+ case 123: // FixedSizedType
value.move< FixedSizedType::Ptr > (that.value);
break;
- case 151: // ForallRule
+ case 157: // ForallRule
value.move< ForallRule::Ptr > (that.value);
break;
- case 88: // FunctionDefinition
- case 94: // ProgramFunctionDefinition
+ case 91: // FunctionDefinition
+ case 97: // ProgramFunctionDefinition
value.move< FunctionDefinition::Ptr > (that.value);
break;
- case 89: // FunctionDefinitions
+ case 92: // FunctionDefinitions
value.move< FunctionDefinitions::Ptr > (that.value);
break;
- case 105: // Identifier
+ case 111: // Identifier
value.move< Identifier::Ptr > (that.value);
break;
- case 108: // IdentifierPath
+ case 114: // IdentifierPath
value.move< IdentifierPath::Ptr > (that.value);
break;
- case 106: // Identifiers
- case 107: // DotSeparatedIdentifiers
+ case 112: // Identifiers
+ case 113: // DotSeparatedIdentifiers
value.move< Identifiers::Ptr > (that.value);
break;
- case 136: // IndirectCallExpression
+ case 107: // ImplementationDefinition
+ value.move< ImplementationDefinition::Ptr > (that.value);
+ break;
+
+ case 142: // IndirectCallExpression
value.move< IndirectCallExpression::Ptr > (that.value);
break;
- case 153: // IterateRule
+ case 159: // IterateRule
value.move< IterateRule::Ptr > (that.value);
break;
- case 137: // LetExpression
+ case 143: // LetExpression
value.move< LetExpression::Ptr > (that.value);
break;
- case 150: // LetRule
+ case 156: // LetRule
value.move< LetRule::Ptr > (that.value);
break;
- case 131: // List
+ case 137: // List
value.move< ListExpression::Ptr > (that.value);
break;
- case 90: // MaybeInitially
- case 96: // Initializers
- case 97: // MaybeInitializers
+ case 93: // MaybeInitially
+ case 99: // Initializers
+ case 100: // MaybeInitializers
value.move< NodeList< UpdateRule >::Ptr > (that.value);
break;
- case 111: // Parameters
- case 112: // MaybeParameters
+ case 117: // Parameters
+ case 118: // MaybeParameters
value.move< NodeList< VariableDefinition >::Ptr > (that.value);
break;
- case 130: // Range
+ case 136: // Range
value.move< RangeExpression::Ptr > (that.value);
break;
- case 127: // Reference
+ case 133: // Reference
value.move< ReferenceAtom::Ptr > (that.value);
break;
- case 116: // RelationType
+ case 122: // RelationType
value.move< RelationType::Ptr > (that.value);
break;
- case 143: // Rule
+ case 149: // Rule
value.move< Rule::Ptr > (that.value);
break;
- case 142: // RuleDefinition
+ case 148: // RuleDefinition
value.move< RuleDefinition::Ptr > (that.value);
break;
- case 144: // Rules
+ case 150: // Rules
value.move< Rules::Ptr > (that.value);
break;
- case 155: // SequenceRule
+ case 161: // SequenceRule
value.move< SequenceRule::Ptr > (that.value);
break;
- case 145: // SkipRule
+ case 151: // SkipRule
value.move< SkipRule::Ptr > (that.value);
break;
- case 84: // Specification
+ case 87: // Specification
value.move< Specification::Ptr > (that.value);
break;
- case 100: // StructureDefinition
+ case 103: // StructureDefinition
value.move< StructureDefinition::Ptr > (that.value);
break;
- case 113: // Type
+ case 119: // Type
value.move< Type::Ptr > (that.value);
break;
- case 92: // FunctionParameters
- case 93: // MaybeFunctionParameters
- case 118: // Types
+ case 95: // FunctionParameters
+ case 96: // MaybeFunctionParameters
+ case 124: // Types
value.move< Types::Ptr > (that.value);
break;
- case 120: // Undefined
+ case 126: // Undefined
value.move< UndefAtom::Ptr > (that.value);
break;
- case 140: // UniversalQuantifierExpression
+ case 146: // UniversalQuantifierExpression
value.move< UniversalQuantifierExpression::Ptr > (that.value);
break;
- case 95: // Initializer
- case 156: // UpdateRule
+ case 98: // Initializer
+ case 162: // UpdateRule
value.move< UpdateRule::Ptr > (that.value);
break;
- case 121: // Boolean
- case 122: // String
- case 123: // BitNumber
- case 124: // IntegerNumber
- case 125: // FloatingNumber
- case 126: // RationalNumber
+ case 127: // Boolean
+ case 128: // String
+ case 129: // BitNumber
+ case 130: // IntegerNumber
+ case 131: // FloatingNumber
+ case 132: // RationalNumber
value.move< ValueAtom::Ptr > (that.value);
break;
- case 109: // Variable
- case 110: // AttributedVariable
+ case 115: // Variable
+ case 116: // AttributedVariable
value.move< VariableDefinition::Ptr > (that.value);
break;
- case 72: // "binary"
- case 73: // "hexadecimal"
- case 74: // "integer"
- case 75: // "rational"
- case 76: // "floating"
- case 77: // "string"
- case 78: // "identifier"
+ case 75: // "binary"
+ case 76: // "hexadecimal"
+ case 77: // "integer"
+ case 78: // "rational"
+ case 79: // "floating"
+ case 80: // "string"
+ case 81: // "identifier"
value.move< std::string > (that.value);
break;
@@ -599,259 +605,265 @@ namespace libcasm_fe {
state = that.state;
switch (that.type_get ())
{
- case 158: // Attribute
+ case 164: // Attribute
value.copy< Attribute::Ptr > (that.value);
break;
- case 159: // Attributes
+ case 165: // Attributes
value.copy< Attributes::Ptr > (that.value);
break;
- case 160: // BasicAttribute
+ case 166: // BasicAttribute
value.copy< BasicAttribute::Ptr > (that.value);
break;
- case 114: // BasicType
+ case 120: // BasicType
value.copy< BasicType::Ptr > (that.value);
break;
- case 154: // BlockRule
+ case 160: // BlockRule
value.copy< BlockRule::Ptr > (that.value);
break;
- case 157: // CallRule
+ case 163: // CallRule
value.copy< CallRule::Ptr > (that.value);
break;
- case 148: // CaseLabel
+ case 154: // CaseLabel
value.copy< Case::Ptr > (that.value);
break;
- case 147: // CaseRule
+ case 153: // CaseRule
value.copy< CaseRule::Ptr > (that.value);
break;
- case 149: // CaseLabels
+ case 155: // CaseLabels
value.copy< Cases::Ptr > (that.value);
break;
- case 139: // ChooseExpression
+ case 145: // ChooseExpression
value.copy< ChooseExpression::Ptr > (that.value);
break;
- case 152: // ChooseRule
+ case 158: // ChooseRule
value.copy< ChooseRule::Ptr > (that.value);
break;
- case 115: // ComposedType
+ case 121: // ComposedType
value.copy< ComposedType::Ptr > (that.value);
break;
- case 138: // ConditionalExpression
+ case 144: // ConditionalExpression
value.copy< ConditionalExpression::Ptr > (that.value);
break;
- case 146: // ConditionalRule
+ case 152: // ConditionalRule
value.copy< ConditionalRule::Ptr > (that.value);
break;
- case 104: // DeclarationDefinition
+ case 110: // DeclarationDefinition
value.copy< DeclarationDefinition::Ptr > (that.value);
break;
- case 85: // Definition
- case 86: // AttributedDefinition
- case 102: // FeatureDeclarationOrDefinition
+ case 88: // Definition
+ case 89: // AttributedDefinition
+ case 105: // FeatureDeclarationOrDefinition
+ case 108: // ImplementationDefinitionDefinition
value.copy< Definition::Ptr > (that.value);
break;
- case 87: // Definitions
- case 103: // FeatureDeclarationsAndDefinitions
+ case 90: // Definitions
+ case 106: // FeatureDeclarationsAndDefinitions
+ case 109: // ImplementationDefinitionDefinitions
value.copy< Definitions::Ptr > (that.value);
break;
- case 98: // DerivedDefinition
+ case 101: // DerivedDefinition
value.copy< DerivedDefinition::Ptr > (that.value);
break;
- case 135: // DirectCallExpression
+ case 141: // DirectCallExpression
value.copy< DirectCallExpression::Ptr > (that.value);
break;
- case 99: // EnumerationDefinition
+ case 102: // EnumerationDefinition
value.copy< EnumerationDefinition::Ptr > (that.value);
break;
- case 141: // ExistentialQuantifierExpression
+ case 147: // ExistentialQuantifierExpression
value.copy< ExistentialQuantifierExpression::Ptr > (that.value);
break;
- case 91: // MaybeDefined
- case 119: // Atom
- case 128: // Term
- case 129: // Expression
+ case 94: // MaybeDefined
+ case 125: // Atom
+ case 134: // Term
+ case 135: // Expression
value.copy< Expression::Ptr > (that.value);
break;
- case 161: // ExpressionAttribute
+ case 167: // ExpressionAttribute
value.copy< ExpressionAttribute::Ptr > (that.value);
break;
- case 132: // Terms
- case 133: // Arguments
- case 134: // TwoOrMoreArguments
+ case 138: // Terms
+ case 139: // Arguments
+ case 140: // TwoOrMoreArguments
value.copy< Expressions::Ptr > (that.value);
break;
- case 101: // FeatureDefinition
+ case 104: // FeatureDefinition
value.copy< FeatureDefinition::Ptr > (that.value);
break;
- case 117: // FixedSizedType
+ case 123: // FixedSizedType
value.copy< FixedSizedType::Ptr > (that.value);
break;
- case 151: // ForallRule
+ case 157: // ForallRule
value.copy< ForallRule::Ptr > (that.value);
break;
- case 88: // FunctionDefinition
- case 94: // ProgramFunctionDefinition
+ case 91: // FunctionDefinition
+ case 97: // ProgramFunctionDefinition
value.copy< FunctionDefinition::Ptr > (that.value);
break;
- case 89: // FunctionDefinitions
+ case 92: // FunctionDefinitions
value.copy< FunctionDefinitions::Ptr > (that.value);
break;
- case 105: // Identifier
+ case 111: // Identifier
value.copy< Identifier::Ptr > (that.value);
break;
- case 108: // IdentifierPath
+ case 114: // IdentifierPath
value.copy< IdentifierPath::Ptr > (that.value);
break;
- case 106: // Identifiers
- case 107: // DotSeparatedIdentifiers
+ case 112: // Identifiers
+ case 113: // DotSeparatedIdentifiers
value.copy< Identifiers::Ptr > (that.value);
break;
- case 136: // IndirectCallExpression
+ case 107: // ImplementationDefinition
+ value.copy< ImplementationDefinition::Ptr > (that.value);
+ break;
+
+ case 142: // IndirectCallExpression
value.copy< IndirectCallExpression::Ptr > (that.value);
break;
- case 153: // IterateRule
+ case 159: // IterateRule
value.copy< IterateRule::Ptr > (that.value);
break;
- case 137: // LetExpression
+ case 143: // LetExpression
value.copy< LetExpression::Ptr > (that.value);
break;
- case 150: // LetRule
+ case 156: // LetRule
value.copy< LetRule::Ptr > (that.value);
break;
- case 131: // List
+ case 137: // List
value.copy< ListExpression::Ptr > (that.value);
break;
- case 90: // MaybeInitially
- case 96: // Initializers
- case 97: // MaybeInitializers
+ case 93: // MaybeInitially
+ case 99: // Initializers
+ case 100: // MaybeInitializers
value.copy< NodeList< UpdateRule >::Ptr > (that.value);
break;
- case 111: // Parameters
- case 112: // MaybeParameters
+ case 117: // Parameters
+ case 118: // MaybeParameters
value.copy< NodeList< VariableDefinition >::Ptr > (that.value);
break;
- case 130: // Range
+ case 136: // Range
value.copy< RangeExpression::Ptr > (that.value);
break;
- case 127: // Reference
+ case 133: // Reference
value.copy< ReferenceAtom::Ptr > (that.value);
break;
- case 116: // RelationType
+ case 122: // RelationType
value.copy< RelationType::Ptr > (that.value);
break;
- case 143: // Rule
+ case 149: // Rule
value.copy< Rule::Ptr > (that.value);
break;
- case 142: // RuleDefinition
+ case 148: // RuleDefinition
value.copy< RuleDefinition::Ptr > (that.value);
break;
- case 144: // Rules
+ case 150: // Rules
value.copy< Rules::Ptr > (that.value);
break;
- case 155: // SequenceRule
+ case 161: // SequenceRule
value.copy< SequenceRule::Ptr > (that.value);
break;
- case 145: // SkipRule
+ case 151: // SkipRule
value.copy< SkipRule::Ptr > (that.value);
break;
- case 84: // Specification
+ case 87: // Specification
value.copy< Specification::Ptr > (that.value);
break;
- case 100: // StructureDefinition
+ case 103: // StructureDefinition
value.copy< StructureDefinition::Ptr > (that.value);
break;
- case 113: // Type
+ case 119: // Type
value.copy< Type::Ptr > (that.value);
break;
- case 92: // FunctionParameters
- case 93: // MaybeFunctionParameters
- case 118: // Types
+ case 95: // FunctionParameters
+ case 96: // MaybeFunctionParameters
+ case 124: // Types
value.copy< Types::Ptr > (that.value);
break;
- case 120: // Undefined
+ case 126: // Undefined
value.copy< UndefAtom::Ptr > (that.value);
break;
- case 140: // UniversalQuantifierExpression
+ case 146: // UniversalQuantifierExpression
value.copy< UniversalQuantifierExpression::Ptr > (that.value);
break;
- case 95: // Initializer
- case 156: // UpdateRule
+ case 98: // Initializer
+ case 162: // UpdateRule
value.copy< UpdateRule::Ptr > (that.value);
break;
- case 121: // Boolean
- case 122: // String
- case 123: // BitNumber
- case 124: // IntegerNumber
- case 125: // FloatingNumber
- case 126: // RationalNumber
+ case 127: // Boolean
+ case 128: // String
+ case 129: // BitNumber
+ case 130: // IntegerNumber
+ case 131: // FloatingNumber
+ case 132: // RationalNumber
value.copy< ValueAtom::Ptr > (that.value);
break;
- case 109: // Variable
- case 110: // AttributedVariable
+ case 115: // Variable
+ case 116: // AttributedVariable
value.copy< VariableDefinition::Ptr > (that.value);
break;
- case 72: // "binary"
- case 73: // "hexadecimal"
- case 74: // "integer"
- case 75: // "rational"
- case 76: // "floating"
- case 77: // "string"
- case 78: // "identifier"
+ case 75: // "binary"
+ case 76: // "hexadecimal"
+ case 77: // "integer"
+ case 78: // "rational"
+ case 79: // "floating"
+ case 80: // "string"
+ case 81: // "identifier"
value.copy< std::string > (that.value);
break;
@@ -1083,259 +1095,265 @@ namespace libcasm_fe {
when using variants. */
switch (yyr1_[yyn])
{
- case 158: // Attribute
+ case 164: // Attribute
yylhs.value.build< Attribute::Ptr > ();
break;
- case 159: // Attributes
+ case 165: // Attributes
yylhs.value.build< Attributes::Ptr > ();
break;
- case 160: // BasicAttribute
+ case 166: // BasicAttribute
yylhs.value.build< BasicAttribute::Ptr > ();
break;
- case 114: // BasicType
+ case 120: // BasicType
yylhs.value.build< BasicType::Ptr > ();
break;
- case 154: // BlockRule
+ case 160: // BlockRule
yylhs.value.build< BlockRule::Ptr > ();
break;
- case 157: // CallRule
+ case 163: // CallRule
yylhs.value.build< CallRule::Ptr > ();
break;
- case 148: // CaseLabel
+ case 154: // CaseLabel
yylhs.value.build< Case::Ptr > ();
break;
- case 147: // CaseRule
+ case 153: // CaseRule
yylhs.value.build< CaseRule::Ptr > ();
break;
- case 149: // CaseLabels
+ case 155: // CaseLabels
yylhs.value.build< Cases::Ptr > ();
break;
- case 139: // ChooseExpression
+ case 145: // ChooseExpression
yylhs.value.build< ChooseExpression::Ptr > ();
break;
- case 152: // ChooseRule
+ case 158: // ChooseRule
yylhs.value.build< ChooseRule::Ptr > ();
break;
- case 115: // ComposedType
+ case 121: // ComposedType
yylhs.value.build< ComposedType::Ptr > ();
break;
- case 138: // ConditionalExpression
+ case 144: // ConditionalExpression
yylhs.value.build< ConditionalExpression::Ptr > ();
break;
- case 146: // ConditionalRule
+ case 152: // ConditionalRule
yylhs.value.build< ConditionalRule::Ptr > ();
break;
- case 104: // DeclarationDefinition
+ case 110: // DeclarationDefinition
yylhs.value.build< DeclarationDefinition::Ptr > ();
break;
- case 85: // Definition
- case 86: // AttributedDefinition
- case 102: // FeatureDeclarationOrDefinition
+ case 88: // Definition
+ case 89: // AttributedDefinition
+ case 105: // FeatureDeclarationOrDefinition
+ case 108: // ImplementationDefinitionDefinition
yylhs.value.build< Definition::Ptr > ();
break;
- case 87: // Definitions
- case 103: // FeatureDeclarationsAndDefinitions
+ case 90: // Definitions
+ case 106: // FeatureDeclarationsAndDefinitions
+ case 109: // ImplementationDefinitionDefinitions
yylhs.value.build< Definitions::Ptr > ();
break;
- case 98: // DerivedDefinition
+ case 101: // DerivedDefinition
yylhs.value.build< DerivedDefinition::Ptr > ();
break;
- case 135: // DirectCallExpression
+ case 141: // DirectCallExpression
yylhs.value.build< DirectCallExpression::Ptr > ();
break;
- case 99: // EnumerationDefinition
+ case 102: // EnumerationDefinition
yylhs.value.build< EnumerationDefinition::Ptr > ();
break;
- case 141: // ExistentialQuantifierExpression
+ case 147: // ExistentialQuantifierExpression
yylhs.value.build< ExistentialQuantifierExpression::Ptr > ();
break;
- case 91: // MaybeDefined
- case 119: // Atom
- case 128: // Term
- case 129: // Expression
+ case 94: // MaybeDefined
+ case 125: // Atom
+ case 134: // Term
+ case 135: // Expression
yylhs.value.build< Expression::Ptr > ();
break;
- case 161: // ExpressionAttribute
+ case 167: // ExpressionAttribute
yylhs.value.build< ExpressionAttribute::Ptr > ();
break;
- case 132: // Terms
- case 133: // Arguments
- case 134: // TwoOrMoreArguments
+ case 138: // Terms
+ case 139: // Arguments
+ case 140: // TwoOrMoreArguments
yylhs.value.build< Expressions::Ptr > ();
break;
- case 101: // FeatureDefinition
+ case 104: // FeatureDefinition
yylhs.value.build< FeatureDefinition::Ptr > ();
break;
- case 117: // FixedSizedType
+ case 123: // FixedSizedType
yylhs.value.build< FixedSizedType::Ptr > ();
break;
- case 151: // ForallRule
+ case 157: // ForallRule
yylhs.value.build< ForallRule::Ptr > ();
break;
- case 88: // FunctionDefinition
- case 94: // ProgramFunctionDefinition
+ case 91: // FunctionDefinition
+ case 97: // ProgramFunctionDefinition
yylhs.value.build< FunctionDefinition::Ptr > ();
break;
- case 89: // FunctionDefinitions
+ case 92: // FunctionDefinitions
yylhs.value.build< FunctionDefinitions::Ptr > ();
break;
- case 105: // Identifier
+ case 111: // Identifier
yylhs.value.build< Identifier::Ptr > ();
break;
- case 108: // IdentifierPath
+ case 114: // IdentifierPath
yylhs.value.build< IdentifierPath::Ptr > ();
break;
- case 106: // Identifiers
- case 107: // DotSeparatedIdentifiers
+ case 112: // Identifiers
+ case 113: // DotSeparatedIdentifiers
yylhs.value.build< Identifiers::Ptr > ();
break;
- case 136: // IndirectCallExpression
+ case 107: // ImplementationDefinition
+ yylhs.value.build< ImplementationDefinition::Ptr > ();
+ break;
+
+ case 142: // IndirectCallExpression
yylhs.value.build< IndirectCallExpression::Ptr > ();
break;
- case 153: // IterateRule
+ case 159: // IterateRule
yylhs.value.build< IterateRule::Ptr > ();
break;
- case 137: // LetExpression
+ case 143: // LetExpression
yylhs.value.build< LetExpression::Ptr > ();
break;
- case 150: // LetRule
+ case 156: // LetRule
yylhs.value.build< LetRule::Ptr > ();
break;
- case 131: // List
+ case 137: // List
yylhs.value.build< ListExpression::Ptr > ();
break;
- case 90: // MaybeInitially
- case 96: // Initializers
- case 97: // MaybeInitializers
+ case 93: // MaybeInitially
+ case 99: // Initializers
+ case 100: // MaybeInitializers
yylhs.value.build< NodeList< UpdateRule >::Ptr > ();
break;
- case 111: // Parameters
- case 112: // MaybeParameters
+ case 117: // Parameters
+ case 118: // MaybeParameters
yylhs.value.build< NodeList< VariableDefinition >::Ptr > ();
break;
- case 130: // Range
+ case 136: // Range
yylhs.value.build< RangeExpression::Ptr > ();
break;
- case 127: // Reference
+ case 133: // Reference
yylhs.value.build< ReferenceAtom::Ptr > ();
break;
- case 116: // RelationType
+ case 122: // RelationType
yylhs.value.build< RelationType::Ptr > ();
break;
- case 143: // Rule
+ case 149: // Rule
yylhs.value.build< Rule::Ptr > ();
break;
- case 142: // RuleDefinition
+ case 148: // RuleDefinition
yylhs.value.build< RuleDefinition::Ptr > ();
break;
- case 144: // Rules
+ case 150: // Rules
yylhs.value.build< Rules::Ptr > ();
break;
- case 155: // SequenceRule
+ case 161: // SequenceRule
yylhs.value.build< SequenceRule::Ptr > ();
break;
- case 145: // SkipRule
+ case 151: // SkipRule
yylhs.value.build< SkipRule::Ptr > ();
break;
- case 84: // Specification
+ case 87: // Specification
yylhs.value.build< Specification::Ptr > ();
break;
- case 100: // StructureDefinition
+ case 103: // StructureDefinition
yylhs.value.build< StructureDefinition::Ptr > ();
break;
- case 113: // Type
+ case 119: // Type
yylhs.value.build< Type::Ptr > ();
break;
- case 92: // FunctionParameters
- case 93: // MaybeFunctionParameters
- case 118: // Types
+ case 95: // FunctionParameters
+ case 96: // MaybeFunctionParameters
+ case 124: // Types
yylhs.value.build< Types::Ptr > ();
break;
- case 120: // Undefined
+ case 126: // Undefined
yylhs.value.build< UndefAtom::Ptr > ();
break;
- case 140: // UniversalQuantifierExpression
+ case 146: // UniversalQuantifierExpression
yylhs.value.build< UniversalQuantifierExpression::Ptr > ();
break;
- case 95: // Initializer
- case 156: // UpdateRule
+ case 98: // Initializer
+ case 162: // UpdateRule
yylhs.value.build< UpdateRule::Ptr > ();
break;
- case 121: // Boolean
- case 122: // String
- case 123: // BitNumber
- case 124: // IntegerNumber
- case 125: // FloatingNumber
- case 126: // RationalNumber
+ case 127: // Boolean
+ case 128: // String
+ case 129: // BitNumber
+ case 130: // IntegerNumber
+ case 131: // FloatingNumber
+ case 132: // RationalNumber
yylhs.value.build< ValueAtom::Ptr > ();
break;
- case 109: // Variable
- case 110: // AttributedVariable
+ case 115: // Variable
+ case 116: // AttributedVariable
yylhs.value.build< VariableDefinition::Ptr > ();
break;
- case 72: // "binary"
- case 73: // "hexadecimal"
- case 74: // "integer"
- case 75: // "rational"
- case 76: // "floating"
- case 77: // "string"
- case 78: // "identifier"
+ case 75: // "binary"
+ case 76: // "hexadecimal"
+ case 77: // "integer"
+ case 78: // "rational"
+ case 79: // "floating"
+ case 80: // "string"
+ case 81: // "identifier"
yylhs.value.build< std::string > ();
break;
@@ -1357,7 +1375,7 @@ namespace libcasm_fe {
switch (yyn)
{
case 2:
-#line 360 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+#line 366 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
const std::string& fileName = filePath.substr( filePath.find_last_of( "/\\" ) + 1 );
const std::string& name = fileName.substr( 0, fileName.rfind( "." ) );
@@ -1365,105 +1383,113 @@ namespace libcasm_fe {
const auto specificationName = make< Identifier >( yylhs.location, name );
result = Ast::make< Specification >( yylhs.location, specificationName, yystack_[0].value.as< Definitions::Ptr > () );
}
-#line 1369 "GrammarParser.cpp" // lalr1.cc:859
+#line 1387 "GrammarParser.cpp" // lalr1.cc:859
break;
case 3:
-#line 372 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+#line 378 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< FunctionDefinition::Ptr > ();
}
-#line 1377 "GrammarParser.cpp" // lalr1.cc:859
+#line 1395 "GrammarParser.cpp" // lalr1.cc:859
break;
case 4:
-#line 376 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+#line 382 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< DerivedDefinition::Ptr > ();
}
-#line 1385 "GrammarParser.cpp" // lalr1.cc:859
+#line 1403 "GrammarParser.cpp" // lalr1.cc:859
break;
case 5:
-#line 380 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+#line 386 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< RuleDefinition::Ptr > ();
}
-#line 1393 "GrammarParser.cpp" // lalr1.cc:859
+#line 1411 "GrammarParser.cpp" // lalr1.cc:859
break;
case 6:
-#line 384 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+#line 390 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< EnumerationDefinition::Ptr > ();
}
-#line 1401 "GrammarParser.cpp" // lalr1.cc:859
+#line 1419 "GrammarParser.cpp" // lalr1.cc:859
break;
case 7:
-#line 388 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+#line 394 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< StructureDefinition::Ptr > ();
}
-#line 1409 "GrammarParser.cpp" // lalr1.cc:859
+#line 1427 "GrammarParser.cpp" // lalr1.cc:859
break;
case 8:
-#line 392 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+#line 398 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< FeatureDefinition::Ptr > ();
}
-#line 1417 "GrammarParser.cpp" // lalr1.cc:859
+#line 1435 "GrammarParser.cpp" // lalr1.cc:859
break;
case 9:
-#line 396 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+#line 402 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
- yylhs.value.as< Definition::Ptr > () = nullptr;
+ yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< ImplementationDefinition::Ptr > ();
}
-#line 1425 "GrammarParser.cpp" // lalr1.cc:859
+#line 1443 "GrammarParser.cpp" // lalr1.cc:859
break;
case 10:
-#line 404 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+#line 406 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ {
+ yylhs.value.as< Definition::Ptr > () = nullptr;
+ }
+#line 1451 "GrammarParser.cpp" // lalr1.cc:859
+ break;
+
+ case 11:
+#line 414 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
auto definition = yystack_[0].value.as< Definition::Ptr > ();
definition->setAttributes( yystack_[2].value.as< Attributes::Ptr > () );
yylhs.value.as< Definition::Ptr > () = definition;
}
-#line 1435 "GrammarParser.cpp" // lalr1.cc:859
+#line 1461 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 11:
-#line 410 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 12:
+#line 420 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< Definition::Ptr > ();
}
-#line 1443 "GrammarParser.cpp" // lalr1.cc:859
+#line 1469 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 12:
-#line 418 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 13:
+#line 428 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
auto definitions = yystack_[1].value.as< Definitions::Ptr > ();
definitions->add( yystack_[0].value.as< Definition::Ptr > () );
yylhs.value.as< Definitions::Ptr > () = definitions;
}
-#line 1453 "GrammarParser.cpp" // lalr1.cc:859
+#line 1479 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 13:
-#line 424 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 14:
+#line 434 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
auto definitions = Ast::make< Definitions >( yylhs.location );
definitions->add( yystack_[0].value.as< Definition::Ptr > () );
yylhs.value.as< Definitions::Ptr > () = definitions;
}
-#line 1463 "GrammarParser.cpp" // lalr1.cc:859
+#line 1489 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 14:
-#line 434 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 15:
+#line 444 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
const auto identifier = yystack_[6].value.as< Identifier::Ptr > ();
@@ -1479,107 +1505,107 @@ namespace libcasm_fe {
yylhs.value.as< FunctionDefinition::Ptr > () = function;
}
-#line 1483 "GrammarParser.cpp" // lalr1.cc:859
+#line 1509 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 15:
-#line 450 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 16:
+#line 460 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< FunctionDefinition::Ptr > () = yystack_[0].value.as< FunctionDefinition::Ptr > (); // `init` special case
}
-#line 1491 "GrammarParser.cpp" // lalr1.cc:859
+#line 1517 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 16:
-#line 458 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 17:
+#line 468 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
auto functions = yystack_[2].value.as< FunctionDefinitions::Ptr > ();
functions->add( yystack_[0].value.as< FunctionDefinition::Ptr > () );
yylhs.value.as< FunctionDefinitions::Ptr > () = functions;
}
-#line 1501 "GrammarParser.cpp" // lalr1.cc:859
+#line 1527 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 17:
-#line 464 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 18:
+#line 474 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
auto functions = Ast::make< FunctionDefinitions >( yylhs.location );
functions->add( yystack_[0].value.as< FunctionDefinition::Ptr > () );
yylhs.value.as< FunctionDefinitions::Ptr > () = functions;
}
-#line 1511 "GrammarParser.cpp" // lalr1.cc:859
+#line 1537 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 18:
-#line 474 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 19:
+#line 484 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< NodeList< UpdateRule >::Ptr > () = yystack_[1].value.as< NodeList< UpdateRule >::Ptr > ();
}
-#line 1519 "GrammarParser.cpp" // lalr1.cc:859
+#line 1545 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 19:
-#line 478 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 20:
+#line 488 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< NodeList< UpdateRule >::Ptr > () = Ast::make< NodeList< UpdateRule > >( yylhs.location );
}
-#line 1527 "GrammarParser.cpp" // lalr1.cc:859
+#line 1553 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 20:
-#line 486 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 21:
+#line 496 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = yystack_[1].value.as< Expression::Ptr > ();
}
-#line 1535 "GrammarParser.cpp" // lalr1.cc:859
+#line 1561 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 21:
-#line 490 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 22:
+#line 500 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = Ast::make< UndefAtom >( yylhs.location );
}
-#line 1543 "GrammarParser.cpp" // lalr1.cc:859
+#line 1569 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 22:
-#line 498 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 23:
+#line 508 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
auto types = yystack_[2].value.as< Types::Ptr > ();
types->add( yystack_[0].value.as< Type::Ptr > () );
yylhs.value.as< Types::Ptr > () = types;
}
-#line 1553 "GrammarParser.cpp" // lalr1.cc:859
+#line 1579 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 23:
-#line 504 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 24:
+#line 514 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
auto types = Ast::make< Types >( yylhs.location );
types->add( yystack_[0].value.as< Type::Ptr > () );
yylhs.value.as< Types::Ptr > () = types;
}
-#line 1563 "GrammarParser.cpp" // lalr1.cc:859
+#line 1589 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 24:
-#line 514 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 25:
+#line 524 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Types::Ptr > () = yystack_[0].value.as< Types::Ptr > ();
}
-#line 1571 "GrammarParser.cpp" // lalr1.cc:859
+#line 1597 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 25:
-#line 518 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 26:
+#line 528 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Types::Ptr > () = Ast::make< Types >( yylhs.location );
}
-#line 1579 "GrammarParser.cpp" // lalr1.cc:859
+#line 1605 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 26:
-#line 526 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 27:
+#line 536 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
const auto singleAgentIdentifier = Ast::make< Identifier >( yylhs.location, "$" );
auto singleAgentArguments = libcasm_fe::Ast::make< Expressions >( yylhs.location );
@@ -1602,11 +1628,11 @@ namespace libcasm_fe {
yylhs.value.as< FunctionDefinition::Ptr > () = programDefinition;
}
-#line 1606 "GrammarParser.cpp" // lalr1.cc:859
+#line 1632 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 27:
-#line 549 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 28:
+#line 559 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
auto programDefinition = createProgramFunction( yylhs.location );
@@ -1620,11 +1646,11 @@ namespace libcasm_fe {
yylhs.value.as< FunctionDefinition::Ptr > () = programDefinition;
}
-#line 1624 "GrammarParser.cpp" // lalr1.cc:859
+#line 1650 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 28:
-#line 567 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 29:
+#line 577 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
// the unknown function identifier will be replaced in FunctionDefinition
const auto arguments = Ast::make< Expressions >( yylhs.location );
@@ -1632,11 +1658,11 @@ namespace libcasm_fe {
function->setTargetType( CallExpression::TargetType::FUNCTION );
yylhs.value.as< UpdateRule::Ptr > () = Ast::make< UpdateRule >( yylhs.location, function, yystack_[0].value.as< Expression::Ptr > () );
}
-#line 1636 "GrammarParser.cpp" // lalr1.cc:859
+#line 1662 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 29:
-#line 575 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 30:
+#line 585 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
auto arguments = Ast::make< Expressions >( yylhs.location );
arguments->add( yystack_[2].value.as< Expression::Ptr > () );
@@ -1646,479 +1672,541 @@ namespace libcasm_fe {
function->setTargetType( CallExpression::TargetType::FUNCTION );
yylhs.value.as< UpdateRule::Ptr > () = Ast::make< UpdateRule >( yylhs.location, function, yystack_[0].value.as< Expression::Ptr > () );
}
-#line 1650 "GrammarParser.cpp" // lalr1.cc:859
+#line 1676 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 30:
-#line 585 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 31:
+#line 595 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
// the unknown function identifier will be replaced in FunctionDefinition
const auto function = Ast::make< DirectCallExpression >( yylhs.location, nullptr, yystack_[2].value.as< Expressions::Ptr > () );
function->setTargetType( CallExpression::TargetType::FUNCTION );
yylhs.value.as< UpdateRule::Ptr > () = Ast::make< UpdateRule >( yylhs.location, function, yystack_[0].value.as< Expression::Ptr > () );
}
-#line 1661 "GrammarParser.cpp" // lalr1.cc:859
+#line 1687 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 31:
-#line 596 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 32:
+#line 606 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
auto initializers = yystack_[2].value.as< NodeList< UpdateRule >::Ptr > ();
initializers->add( yystack_[0].value.as< UpdateRule::Ptr > () );
yylhs.value.as< NodeList< UpdateRule >::Ptr > () = initializers;
}
-#line 1671 "GrammarParser.cpp" // lalr1.cc:859
+#line 1697 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 32:
-#line 602 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 33:
+#line 612 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
auto initializers = Ast::make< NodeList< UpdateRule > >( yylhs.location );
initializers->add( yystack_[0].value.as< UpdateRule::Ptr > () );
yylhs.value.as< NodeList< UpdateRule >::Ptr > () = initializers;
}
-#line 1681 "GrammarParser.cpp" // lalr1.cc:859
+#line 1707 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 33:
-#line 612 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 34:
+#line 622 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< NodeList< UpdateRule >::Ptr > () = yystack_[0].value.as< NodeList< UpdateRule >::Ptr > ();
}
-#line 1689 "GrammarParser.cpp" // lalr1.cc:859
+#line 1715 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 34:
-#line 616 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 35:
+#line 626 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< NodeList< UpdateRule >::Ptr > () = Ast::make< NodeList< UpdateRule > >( yylhs.location );
}
-#line 1697 "GrammarParser.cpp" // lalr1.cc:859
+#line 1723 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 35:
-#line 624 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 36:
+#line 634 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< DerivedDefinition::Ptr > () = Ast::make< DerivedDefinition >( yylhs.location, yystack_[5].value.as< Identifier::Ptr > (), yystack_[4].value.as< NodeList< VariableDefinition >::Ptr > (), yystack_[2].value.as< Type::Ptr > (), yystack_[0].value.as< Expression::Ptr > () );
}
-#line 1705 "GrammarParser.cpp" // lalr1.cc:859
+#line 1731 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 36:
-#line 632 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 37:
+#line 642 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< EnumerationDefinition::Ptr > () = Ast::make< EnumerationDefinition >( yylhs.location, yystack_[4].value.as< Identifier::Ptr > (), yystack_[1].value.as< Identifiers::Ptr > () );
}
-#line 1713 "GrammarParser.cpp" // lalr1.cc:859
+#line 1739 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 37:
-#line 640 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 38:
+#line 650 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< StructureDefinition::Ptr > () = Ast::make< StructureDefinition >( yylhs.location, yystack_[4].value.as< Identifier::Ptr > (), yystack_[1].value.as< FunctionDefinitions::Ptr > () );
}
-#line 1721 "GrammarParser.cpp" // lalr1.cc:859
+#line 1747 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 38:
-#line 648 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 39:
+#line 658 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< FeatureDefinition::Ptr > () = Ast::make< FeatureDefinition >( yylhs.location, yystack_[4].value.as< Identifier::Ptr > (), yystack_[1].value.as< Definitions::Ptr > () );
}
-#line 1729 "GrammarParser.cpp" // lalr1.cc:859
+#line 1755 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 39:
-#line 656 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 40:
+#line 666 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< DeclarationDefinition::Ptr > ();
}
-#line 1737 "GrammarParser.cpp" // lalr1.cc:859
+#line 1763 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 40:
-#line 660 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 41:
+#line 670 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< DerivedDefinition::Ptr > ();
}
-#line 1745 "GrammarParser.cpp" // lalr1.cc:859
+#line 1771 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 41:
-#line 664 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 42:
+#line 674 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< RuleDefinition::Ptr > ();
}
-#line 1753 "GrammarParser.cpp" // lalr1.cc:859
+#line 1779 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 42:
-#line 672 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 43:
+#line 682 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
- auto definitions = yystack_[2].value.as< Definitions::Ptr > ();
+ auto definitions = yystack_[1].value.as< Definitions::Ptr > ();
definitions->add( yystack_[0].value.as< Definition::Ptr > () );
yylhs.value.as< Definitions::Ptr > () = definitions;
}
-#line 1763 "GrammarParser.cpp" // lalr1.cc:859
+#line 1789 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 43:
-#line 678 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 44:
+#line 688 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
auto definitions = Ast::make< Definitions >( yylhs.location );
definitions->add( yystack_[0].value.as< Definition::Ptr > () );
yylhs.value.as< Definitions::Ptr > () = definitions;
}
-#line 1773 "GrammarParser.cpp" // lalr1.cc:859
+#line 1799 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 44:
-#line 688 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 45:
+#line 698 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ {
+ yylhs.value.as< ImplementationDefinition::Ptr > () = Ast::make< ImplementationDefinition >( yylhs.location, yystack_[6].value.as< IdentifierPath::Ptr > (), yystack_[4].value.as< Type::Ptr > (), yystack_[1].value.as< Definitions::Ptr > () );
+ }
+#line 1807 "GrammarParser.cpp" // lalr1.cc:859
+ break;
+
+ case 46:
+#line 702 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ {
+ const auto name = Ast::make< Identifier >( yylhs.location, "" );
+ const auto path = asIdentifierPath( name );
+ yylhs.value.as< ImplementationDefinition::Ptr > () = Ast::make< ImplementationDefinition >( yylhs.location, path, yystack_[4].value.as< Type::Ptr > (), yystack_[1].value.as< Definitions::Ptr > () );
+ }
+#line 1817 "GrammarParser.cpp" // lalr1.cc:859
+ break;
+
+ case 47:
+#line 712 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ {
+ yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< DerivedDefinition::Ptr > ();
+ }
+#line 1825 "GrammarParser.cpp" // lalr1.cc:859
+ break;
+
+ case 48:
+#line 716 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ {
+ yylhs.value.as< Definition::Ptr > () = yystack_[0].value.as< RuleDefinition::Ptr > ();
+ }
+#line 1833 "GrammarParser.cpp" // lalr1.cc:859
+ break;
+
+ case 49:
+#line 724 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ {
+ auto definitions = yystack_[1].value.as< Definitions::Ptr > ();
+ definitions->add( yystack_[0].value.as< Definition::Ptr > () );
+ yylhs.value.as< Definitions::Ptr > () = definitions;
+ }
+#line 1843 "GrammarParser.cpp" // lalr1.cc:859
+ break;
+
+ case 50:
+#line 730 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ {
+ auto definitions = Ast::make< Definitions >( yylhs.location );
+ definitions->add( yystack_[0].value.as< Definition::Ptr > () );
+ yylhs.value.as< Definitions::Ptr > () = definitions;
+ }
+#line 1853 "GrammarParser.cpp" // lalr1.cc:859
+ break;
+
+ case 51:
+#line 740 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
auto declaration = Ast::make< DeclarationDefinition >( yylhs.location, yystack_[4].value.as< Identifier::Ptr > (), yystack_[2].value.as< Types::Ptr > (), yystack_[0].value.as< Type::Ptr > () );
declaration->setKind( DeclarationDefinition::Kind::DERIVED );
yylhs.value.as< DeclarationDefinition::Ptr > () = declaration;
}
-#line 1783 "GrammarParser.cpp" // lalr1.cc:859
+#line 1863 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 45:
-#line 694 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 52:
+#line 746 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
auto declaration = Ast::make< DeclarationDefinition >( yylhs.location, yystack_[4].value.as< Identifier::Ptr > (), yystack_[2].value.as< Types::Ptr > (), yystack_[0].value.as< Type::Ptr > () );
declaration->setKind( DeclarationDefinition::Kind::RULE );
yylhs.value.as< DeclarationDefinition::Ptr > () = declaration;
}
-#line 1793 "GrammarParser.cpp" // lalr1.cc:859
+#line 1873 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 46:
-#line 704 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 53:
+#line 756 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Identifier::Ptr > () = Ast::make< Identifier >( yylhs.location, yystack_[0].value.as< std::string > () );
}
-#line 1801 "GrammarParser.cpp" // lalr1.cc:859
+#line 1881 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 47:
-#line 708 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 54:
+#line 760 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Identifier::Ptr > () = Ast::make< Identifier >( yylhs.location, "in" );
}
-#line 1809 "GrammarParser.cpp" // lalr1.cc:859
+#line 1889 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 48:
-#line 716 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 55:
+#line 768 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
auto identifiers = yystack_[2].value.as< Identifiers::Ptr > ();
identifiers->add( yystack_[0].value.as< Identifier::Ptr > () );
yylhs.value.as< Identifiers::Ptr > () = identifiers;
}
-#line 1819 "GrammarParser.cpp" // lalr1.cc:859
+#line 1899 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 49:
-#line 722 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 56:
+#line 774 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
auto identifiers = Ast::make< Identifiers >( yylhs.location );
identifiers->add( yystack_[0].value.as< Identifier::Ptr > () );
yylhs.value.as< Identifiers::Ptr > () = identifiers;
}
-#line 1829 "GrammarParser.cpp" // lalr1.cc:859
+#line 1909 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 50:
-#line 732 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 57:
+#line 784 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
auto identifiers = yystack_[2].value.as< Identifiers::Ptr > ();
identifiers->add( yystack_[0].value.as< Identifier::Ptr > () );
yylhs.value.as< Identifiers::Ptr > () = identifiers;
}
-#line 1839 "GrammarParser.cpp" // lalr1.cc:859
+#line 1919 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 51:
-#line 738 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 58:
+#line 790 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
auto identifiers = Ast::make< Identifiers >( yylhs.location );
identifiers->add( yystack_[0].value.as< Identifier::Ptr > () );
yylhs.value.as< Identifiers::Ptr > () = identifiers;
}
-#line 1849 "GrammarParser.cpp" // lalr1.cc:859
+#line 1929 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 52:
-#line 748 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 59:
+#line 800 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< IdentifierPath::Ptr > () = Ast::make< IdentifierPath >( yylhs.location, yystack_[0].value.as< Identifiers::Ptr > (), IdentifierPath::Type::ABSOLUTE );
}
-#line 1857 "GrammarParser.cpp" // lalr1.cc:859
+#line 1937 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 53:
-#line 752 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 60:
+#line 804 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< IdentifierPath::Ptr > () = Ast::make< IdentifierPath >( yylhs.location, yystack_[0].value.as< Identifiers::Ptr > (), IdentifierPath::Type::RELATIVE );
}
-#line 1865 "GrammarParser.cpp" // lalr1.cc:859
+#line 1945 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 54:
-#line 760 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 61:
+#line 808 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ {
+ yylhs.value.as< IdentifierPath::Ptr > () = Ast::make< IdentifierPath >( yylhs.location, yystack_[0].value.as< Identifiers::Ptr > (), IdentifierPath::Type::THIS );
+ }
+#line 1953 "GrammarParser.cpp" // lalr1.cc:859
+ break;
+
+ case 62:
+#line 816 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< VariableDefinition::Ptr > () = Ast::make< VariableDefinition >( yylhs.location, yystack_[2].value.as< Identifier::Ptr > (), yystack_[0].value.as< Type::Ptr > () );
}
-#line 1873 "GrammarParser.cpp" // lalr1.cc:859
+#line 1961 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 55:
-#line 764 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 63:
+#line 820 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
const auto unresolvedType = Ast::make< UnresolvedType >( yylhs.location );
yylhs.value.as< VariableDefinition::Ptr > () = Ast::make< VariableDefinition >( yylhs.location, yystack_[0].value.as< Identifier::Ptr > (), unresolvedType );
}
-#line 1882 "GrammarParser.cpp" // lalr1.cc:859
+#line 1970 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 56:
-#line 773 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 64:
+#line 829 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
auto variable = yystack_[0].value.as< VariableDefinition::Ptr > ();
variable->setAttributes( yystack_[2].value.as< Attributes::Ptr > () );
yylhs.value.as< VariableDefinition::Ptr > () = variable;
}
-#line 1892 "GrammarParser.cpp" // lalr1.cc:859
+#line 1980 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 57:
-#line 779 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 65:
+#line 835 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< VariableDefinition::Ptr > () = yystack_[0].value.as< VariableDefinition::Ptr > ();
}
-#line 1900 "GrammarParser.cpp" // lalr1.cc:859
+#line 1988 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 58:
-#line 787 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 66:
+#line 843 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
auto parameters = yystack_[2].value.as< NodeList< VariableDefinition >::Ptr > ();
parameters->add( yystack_[0].value.as< VariableDefinition::Ptr > () );
yylhs.value.as< NodeList< VariableDefinition >::Ptr > () = parameters;
}
-#line 1910 "GrammarParser.cpp" // lalr1.cc:859
+#line 1998 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 59:
-#line 793 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 67:
+#line 849 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
auto parameters = Ast::make< NodeList< VariableDefinition > >( yylhs.location );
parameters->add( yystack_[0].value.as< VariableDefinition::Ptr > () );
yylhs.value.as< NodeList< VariableDefinition >::Ptr > () = parameters;
}
-#line 1920 "GrammarParser.cpp" // lalr1.cc:859
+#line 2008 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 60:
-#line 803 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 68:
+#line 859 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< NodeList< VariableDefinition >::Ptr > () = yystack_[1].value.as< NodeList< VariableDefinition >::Ptr > ();
}
-#line 1928 "GrammarParser.cpp" // lalr1.cc:859
+#line 2016 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 61:
-#line 807 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 69:
+#line 863 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< NodeList< VariableDefinition >::Ptr > () = nullptr;
}
-#line 1936 "GrammarParser.cpp" // lalr1.cc:859
+#line 2024 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 62:
-#line 811 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 70:
+#line 867 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< NodeList< VariableDefinition >::Ptr > () = Ast::make< NodeList< VariableDefinition > >( yylhs.location );
}
-#line 1944 "GrammarParser.cpp" // lalr1.cc:859
+#line 2032 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 63:
-#line 819 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 71:
+#line 875 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Type::Ptr > () = yystack_[0].value.as< BasicType::Ptr > ();
}
-#line 1952 "GrammarParser.cpp" // lalr1.cc:859
+#line 2040 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 64:
-#line 823 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 72:
+#line 879 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Type::Ptr > () = yystack_[0].value.as< ComposedType::Ptr > ();
}
-#line 1960 "GrammarParser.cpp" // lalr1.cc:859
+#line 2048 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 65:
-#line 827 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 73:
+#line 883 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Type::Ptr > () = yystack_[0].value.as< RelationType::Ptr > ();
}
-#line 1968 "GrammarParser.cpp" // lalr1.cc:859
+#line 2056 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 66:
-#line 831 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 74:
+#line 887 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Type::Ptr > () = yystack_[0].value.as< FixedSizedType::Ptr > ();
}
-#line 1976 "GrammarParser.cpp" // lalr1.cc:859
+#line 2064 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 67:
-#line 839 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 75:
+#line 895 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< BasicType::Ptr > () = Ast::make< BasicType >( yylhs.location, yystack_[0].value.as< IdentifierPath::Ptr > () );
}
-#line 1984 "GrammarParser.cpp" // lalr1.cc:859
+#line 2072 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 68:
-#line 847 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 76:
+#line 903 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< ComposedType::Ptr > () = Ast::make< ComposedType >( yylhs.location, yystack_[3].value.as< IdentifierPath::Ptr > (), yystack_[1].value.as< Types::Ptr > () );
}
-#line 1992 "GrammarParser.cpp" // lalr1.cc:859
+#line 2080 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 69:
-#line 855 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 77:
+#line 911 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< RelationType::Ptr > () = Ast::make< RelationType >( yylhs.location, yystack_[5].value.as< IdentifierPath::Ptr > (), yystack_[3].value.as< Types::Ptr > (), yystack_[1].value.as< Type::Ptr > () );
}
-#line 2000 "GrammarParser.cpp" // lalr1.cc:859
+#line 2088 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 70:
-#line 863 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 78:
+#line 919 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< FixedSizedType::Ptr > () = Ast::make< FixedSizedType >( yylhs.location, yystack_[2].value.as< IdentifierPath::Ptr > (), yystack_[0].value.as< Expression::Ptr > () );
}
-#line 2008 "GrammarParser.cpp" // lalr1.cc:859
+#line 2096 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 71:
-#line 871 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 79:
+#line 927 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
auto types = yystack_[2].value.as< Types::Ptr > ();
types->add( yystack_[0].value.as< Type::Ptr > () );
yylhs.value.as< Types::Ptr > () = types;
}
-#line 2018 "GrammarParser.cpp" // lalr1.cc:859
+#line 2106 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 72:
-#line 877 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 80:
+#line 933 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
auto types = Ast::make< Types >( yylhs.location );
types->add( yystack_[0].value.as< Type::Ptr > () );
yylhs.value.as< Types::Ptr > () = types;
}
-#line 2028 "GrammarParser.cpp" // lalr1.cc:859
+#line 2116 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 73:
-#line 887 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 81:
+#line 943 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ReferenceAtom::Ptr > ();
}
-#line 2036 "GrammarParser.cpp" // lalr1.cc:859
+#line 2124 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 74:
-#line 891 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 82:
+#line 947 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ValueAtom::Ptr > ();
}
-#line 2044 "GrammarParser.cpp" // lalr1.cc:859
+#line 2132 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 75:
-#line 895 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 83:
+#line 951 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ValueAtom::Ptr > ();
}
-#line 2052 "GrammarParser.cpp" // lalr1.cc:859
+#line 2140 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 76:
-#line 899 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 84:
+#line 955 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ValueAtom::Ptr > ();
}
-#line 2060 "GrammarParser.cpp" // lalr1.cc:859
+#line 2148 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 77:
-#line 903 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 85:
+#line 959 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ValueAtom::Ptr > ();
}
-#line 2068 "GrammarParser.cpp" // lalr1.cc:859
+#line 2156 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 78:
-#line 907 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 86:
+#line 963 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ValueAtom::Ptr > ();
}
-#line 2076 "GrammarParser.cpp" // lalr1.cc:859
+#line 2164 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 79:
-#line 911 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 87:
+#line 967 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< UndefAtom::Ptr > ();
}
-#line 2084 "GrammarParser.cpp" // lalr1.cc:859
+#line 2172 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 80:
-#line 915 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 88:
+#line 971 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ValueAtom::Ptr > ();
}
-#line 2092 "GrammarParser.cpp" // lalr1.cc:859
+#line 2180 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 81:
-#line 923 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 89:
+#line 979 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< UndefAtom::Ptr > () = Ast::make< UndefAtom >( yylhs.location );
}
-#line 2100 "GrammarParser.cpp" // lalr1.cc:859
+#line 2188 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 82:
-#line 931 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 90:
+#line 987 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
const auto value = libstdhl::get< libcasm_ir::BooleanConstant >( true );
yylhs.value.as< ValueAtom::Ptr > () = Ast::make< ValueAtom >( yylhs.location, value );
}
-#line 2109 "GrammarParser.cpp" // lalr1.cc:859
+#line 2197 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 83:
-#line 936 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 91:
+#line 992 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
const auto value = libstdhl::get< libcasm_ir::BooleanConstant >( false );
yylhs.value.as< ValueAtom::Ptr > () = Ast::make< ValueAtom >( yylhs.location, value );
}
-#line 2118 "GrammarParser.cpp" // lalr1.cc:859
+#line 2206 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 84:
-#line 945 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 92:
+#line 1001 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
try
{
@@ -2130,11 +2218,11 @@ namespace libcasm_fe {
throw syntax_error( yylhs.location, e.what() );
}
}
-#line 2134 "GrammarParser.cpp" // lalr1.cc:859
+#line 2222 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 85:
-#line 961 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 93:
+#line 1017 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
try
{
@@ -2146,11 +2234,11 @@ namespace libcasm_fe {
throw syntax_error( yylhs.location, e.what() );
}
}
-#line 2150 "GrammarParser.cpp" // lalr1.cc:859
+#line 2238 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 86:
-#line 973 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 94:
+#line 1029 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
try
{
@@ -2162,11 +2250,11 @@ namespace libcasm_fe {
throw syntax_error( yylhs.location, e.what() );
}
}
-#line 2166 "GrammarParser.cpp" // lalr1.cc:859
+#line 2254 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 87:
-#line 989 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 95:
+#line 1045 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
try
{
@@ -2178,11 +2266,11 @@ namespace libcasm_fe {
throw syntax_error( yylhs.location, e.what() );
}
}
-#line 2182 "GrammarParser.cpp" // lalr1.cc:859
+#line 2270 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 88:
-#line 1005 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 96:
+#line 1061 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
try
{
@@ -2194,11 +2282,11 @@ namespace libcasm_fe {
throw syntax_error( yylhs.location, e.what() );
}
}
-#line 2198 "GrammarParser.cpp" // lalr1.cc:859
+#line 2286 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 89:
-#line 1021 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 97:
+#line 1077 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
try
{
@@ -2210,850 +2298,850 @@ namespace libcasm_fe {
throw syntax_error( yylhs.location, e.what() );
}
}
-#line 2214 "GrammarParser.cpp" // lalr1.cc:859
+#line 2302 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 90:
-#line 1037 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 98:
+#line 1093 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< ReferenceAtom::Ptr > () = Ast::make< ReferenceAtom >( yylhs.location, yystack_[0].value.as< IdentifierPath::Ptr > () );
}
-#line 2222 "GrammarParser.cpp" // lalr1.cc:859
+#line 2310 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 91:
-#line 1045 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 99:
+#line 1101 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< DirectCallExpression::Ptr > ();
}
-#line 2230 "GrammarParser.cpp" // lalr1.cc:859
+#line 2318 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 92:
-#line 1049 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 100:
+#line 1105 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< IndirectCallExpression::Ptr > ();
}
-#line 2238 "GrammarParser.cpp" // lalr1.cc:859
+#line 2326 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 93:
-#line 1053 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 101:
+#line 1109 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< LetExpression::Ptr > ();
}
-#line 2246 "GrammarParser.cpp" // lalr1.cc:859
+#line 2334 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 94:
-#line 1057 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 102:
+#line 1113 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ConditionalExpression::Ptr > ();
}
-#line 2254 "GrammarParser.cpp" // lalr1.cc:859
+#line 2342 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 95:
-#line 1061 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 103:
+#line 1117 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ChooseExpression::Ptr > ();
}
-#line 2262 "GrammarParser.cpp" // lalr1.cc:859
+#line 2350 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 96:
-#line 1065 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 104:
+#line 1121 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< UniversalQuantifierExpression::Ptr > ();
}
-#line 2270 "GrammarParser.cpp" // lalr1.cc:859
+#line 2358 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 97:
-#line 1069 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 105:
+#line 1125 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ExistentialQuantifierExpression::Ptr > ();
}
-#line 2278 "GrammarParser.cpp" // lalr1.cc:859
+#line 2366 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 98:
-#line 1073 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 106:
+#line 1129 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< Expression::Ptr > ();
}
-#line 2286 "GrammarParser.cpp" // lalr1.cc:859
+#line 2374 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 99:
-#line 1077 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 107:
+#line 1133 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< ListExpression::Ptr > ();
}
-#line 2294 "GrammarParser.cpp" // lalr1.cc:859
+#line 2382 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 100:
-#line 1081 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 108:
+#line 1137 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< RangeExpression::Ptr > ();
}
-#line 2302 "GrammarParser.cpp" // lalr1.cc:859
+#line 2390 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 101:
-#line 1085 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 109:
+#line 1141 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< Expression::Ptr > ();
}
-#line 2310 "GrammarParser.cpp" // lalr1.cc:859
+#line 2398 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 102:
-#line 1093 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 110:
+#line 1149 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = yystack_[1].value.as< Expression::Ptr > ();
}
-#line 2318 "GrammarParser.cpp" // lalr1.cc:859
+#line 2406 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 103:
-#line 1097 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 111:
+#line 1153 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = nullptr;
}
-#line 2326 "GrammarParser.cpp" // lalr1.cc:859
+#line 2414 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 104:
-#line 1101 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 112:
+#line 1157 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = yystack_[0].value.as< Expression::Ptr > ();
}
-#line 2334 "GrammarParser.cpp" // lalr1.cc:859
+#line 2422 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 105:
-#line 1105 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 113:
+#line 1161 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = Ast::make< UnaryExpression >( yylhs.location, yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::INV_INSTRUCTION );
}
-#line 2342 "GrammarParser.cpp" // lalr1.cc:859
+#line 2430 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 106:
-#line 1109 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 114:
+#line 1165 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::ADD_INSTRUCTION );
}
-#line 2350 "GrammarParser.cpp" // lalr1.cc:859
+#line 2438 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 107:
-#line 1113 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 115:
+#line 1169 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::SUB_INSTRUCTION );
}
-#line 2358 "GrammarParser.cpp" // lalr1.cc:859
+#line 2446 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 108:
-#line 1117 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 116:
+#line 1173 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::MUL_INSTRUCTION );
}
-#line 2366 "GrammarParser.cpp" // lalr1.cc:859
+#line 2454 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 109:
-#line 1121 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 117:
+#line 1177 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::DIV_INSTRUCTION );
}
-#line 2374 "GrammarParser.cpp" // lalr1.cc:859
+#line 2462 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 110:
-#line 1125 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 118:
+#line 1181 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::MOD_INSTRUCTION );
}
-#line 2382 "GrammarParser.cpp" // lalr1.cc:859
+#line 2470 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 111:
-#line 1129 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 119:
+#line 1185 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::POW_INSTRUCTION );
}
-#line 2390 "GrammarParser.cpp" // lalr1.cc:859
+#line 2478 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 112:
-#line 1133 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 120:
+#line 1189 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::NEQ_INSTRUCTION );
}
-#line 2398 "GrammarParser.cpp" // lalr1.cc:859
+#line 2486 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 113:
-#line 1137 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 121:
+#line 1193 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::EQU_INSTRUCTION );
}
-#line 2406 "GrammarParser.cpp" // lalr1.cc:859
+#line 2494 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 114:
-#line 1141 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 122:
+#line 1197 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::LTH_INSTRUCTION );
}
-#line 2414 "GrammarParser.cpp" // lalr1.cc:859
+#line 2502 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 115:
-#line 1145 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 123:
+#line 1201 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::GTH_INSTRUCTION );
}
-#line 2422 "GrammarParser.cpp" // lalr1.cc:859
+#line 2510 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 116:
-#line 1149 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 124:
+#line 1205 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::LEQ_INSTRUCTION );
}
-#line 2430 "GrammarParser.cpp" // lalr1.cc:859
+#line 2518 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 117:
-#line 1153 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 125:
+#line 1209 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::GEQ_INSTRUCTION );
}
-#line 2438 "GrammarParser.cpp" // lalr1.cc:859
+#line 2526 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 118:
-#line 1157 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 126:
+#line 1213 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::OR_INSTRUCTION );
}
-#line 2446 "GrammarParser.cpp" // lalr1.cc:859
+#line 2534 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 119:
-#line 1161 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 127:
+#line 1217 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::XOR_INSTRUCTION );
}
-#line 2454 "GrammarParser.cpp" // lalr1.cc:859
+#line 2542 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 120:
-#line 1165 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 128:
+#line 1221 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::AND_INSTRUCTION );
}
-#line 2462 "GrammarParser.cpp" // lalr1.cc:859
+#line 2550 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 121:
-#line 1169 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 129:
+#line 1225 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::IMP_INSTRUCTION );
}
-#line 2470 "GrammarParser.cpp" // lalr1.cc:859
+#line 2558 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 122:
-#line 1173 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 130:
+#line 1229 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = Ast::make< BinaryExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::IMP_INSTRUCTION );
}
-#line 2478 "GrammarParser.cpp" // lalr1.cc:859
+#line 2566 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 123:
-#line 1177 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 131:
+#line 1233 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expression::Ptr > () = Ast::make< UnaryExpression >( yylhs.location, yystack_[0].value.as< Expression::Ptr > (), libcasm_ir::Value::NOT_INSTRUCTION );
}
-#line 2486 "GrammarParser.cpp" // lalr1.cc:859
+#line 2574 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 124:
-#line 1185 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 132:
+#line 1241 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< RangeExpression::Ptr > () = Ast::make< RangeExpression >( yylhs.location, yystack_[3].value.as< Expression::Ptr > (), yystack_[1].value.as< Expression::Ptr > () );
}
-#line 2494 "GrammarParser.cpp" // lalr1.cc:859
+#line 2582 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 125:
-#line 1193 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 133:
+#line 1249 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
const auto expressions = Ast::make< Expressions >( yylhs.location );
yylhs.value.as< ListExpression::Ptr > () = Ast::make< ListExpression >( yylhs.location, expressions );
}
-#line 2503 "GrammarParser.cpp" // lalr1.cc:859
+#line 2591 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 126:
-#line 1198 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 134:
+#line 1254 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< ListExpression::Ptr > () = Ast::make< ListExpression >( yylhs.location, yystack_[1].value.as< Expressions::Ptr > () );
}
-#line 2511 "GrammarParser.cpp" // lalr1.cc:859
+#line 2599 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 127:
-#line 1202 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 135:
+#line 1258 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< ListExpression::Ptr > () = nullptr;
}
-#line 2519 "GrammarParser.cpp" // lalr1.cc:859
+#line 2607 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 128:
-#line 1210 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 136:
+#line 1266 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
auto expressions = yystack_[2].value.as< Expressions::Ptr > ();
expressions->add( yystack_[0].value.as< Expression::Ptr > () );
yylhs.value.as< Expressions::Ptr > () = expressions;
}
-#line 2529 "GrammarParser.cpp" // lalr1.cc:859
+#line 2617 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 129:
-#line 1216 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 137:
+#line 1272 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
const auto expressions = Ast::make< Expressions >( yylhs.location );
expressions->add( yystack_[0].value.as< Expression::Ptr > () );
yylhs.value.as< Expressions::Ptr > () = expressions;
}
-#line 2539 "GrammarParser.cpp" // lalr1.cc:859
+#line 2627 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 130:
-#line 1226 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 138:
+#line 1282 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expressions::Ptr > () = yystack_[1].value.as< Expressions::Ptr > ();
}
-#line 2547 "GrammarParser.cpp" // lalr1.cc:859
+#line 2635 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 131:
-#line 1230 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 139:
+#line 1286 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Expressions::Ptr > () = nullptr;
}
-#line 2555 "GrammarParser.cpp" // lalr1.cc:859
+#line 2643 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 132:
-#line 1234 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 140:
+#line 1290 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
const auto expressions = Ast::make< Expressions >( yylhs.location );
yylhs.value.as< Expressions::Ptr > () = expressions;
}
-#line 2564 "GrammarParser.cpp" // lalr1.cc:859
+#line 2652 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 133:
-#line 1243 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 141:
+#line 1299 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
const auto expressions = yystack_[3].value.as< Expressions::Ptr > ();
expressions->add( yystack_[1].value.as< Expression::Ptr > () );
yylhs.value.as< Expressions::Ptr > () = expressions;
}
-#line 2574 "GrammarParser.cpp" // lalr1.cc:859
+#line 2662 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 134:
-#line 1253 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 142:
+#line 1309 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
const auto arguments = Ast::make< Expressions >( yylhs.location );
yylhs.value.as< DirectCallExpression::Ptr > () = Ast::make< DirectCallExpression >( yylhs.location, yystack_[0].value.as< IdentifierPath::Ptr > (), arguments );
}
-#line 2583 "GrammarParser.cpp" // lalr1.cc:859
+#line 2671 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 135:
-#line 1258 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 143:
+#line 1314 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< DirectCallExpression::Ptr > () = Ast::make< DirectCallExpression >( yylhs.location, yystack_[1].value.as< IdentifierPath::Ptr > (), yystack_[0].value.as< Expressions::Ptr > () );
}
-#line 2591 "GrammarParser.cpp" // lalr1.cc:859
+#line 2679 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 136:
-#line 1266 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 144:
+#line 1322 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< IndirectCallExpression::Ptr > () = Ast::make< IndirectCallExpression >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expressions::Ptr > () );
}
-#line 2599 "GrammarParser.cpp" // lalr1.cc:859
+#line 2687 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 137:
-#line 1274 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 145:
+#line 1330 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< LetExpression::Ptr > () = Ast::make< LetExpression >( yylhs.location, yystack_[4].value.as< VariableDefinition::Ptr > (), yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > () );
}
-#line 2607 "GrammarParser.cpp" // lalr1.cc:859
+#line 2695 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 138:
-#line 1282 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 146:
+#line 1338 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< ConditionalExpression::Ptr > () = Ast::make< ConditionalExpression >( yylhs.location, yystack_[4].value.as< Expression::Ptr > (), yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > () );
}
-#line 2615 "GrammarParser.cpp" // lalr1.cc:859
+#line 2703 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 139:
-#line 1290 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 147:
+#line 1346 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< ChooseExpression::Ptr > () = Ast::make< ChooseExpression >( yylhs.location, yystack_[4].value.as< VariableDefinition::Ptr > (), yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > () );
}
-#line 2623 "GrammarParser.cpp" // lalr1.cc:859
+#line 2711 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 140:
-#line 1298 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 148:
+#line 1354 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< UniversalQuantifierExpression::Ptr > () = Ast::make< UniversalQuantifierExpression >( yylhs.location, yystack_[4].value.as< VariableDefinition::Ptr > (), yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > () );
}
-#line 2631 "GrammarParser.cpp" // lalr1.cc:859
+#line 2719 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 141:
-#line 1306 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 149:
+#line 1362 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< ExistentialQuantifierExpression::Ptr > () = Ast::make< ExistentialQuantifierExpression >( yylhs.location, yystack_[4].value.as< VariableDefinition::Ptr > (), yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Expression::Ptr > () );
}
-#line 2639 "GrammarParser.cpp" // lalr1.cc:859
+#line 2727 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 142:
-#line 1314 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 150:
+#line 1370 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< RuleDefinition::Ptr > () = Ast::make< RuleDefinition >( yylhs.location, yystack_[3].value.as< Identifier::Ptr > (), yystack_[2].value.as< NodeList< VariableDefinition >::Ptr > (), createVoidType( yylhs.location ),
wrapInBlockRule( yystack_[0].value.as< Rule::Ptr > () ) );
}
-#line 2648 "GrammarParser.cpp" // lalr1.cc:859
+#line 2736 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 143:
-#line 1319 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 151:
+#line 1375 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< RuleDefinition::Ptr > () = Ast::make< RuleDefinition >( yylhs.location, yystack_[5].value.as< Identifier::Ptr > (), yystack_[4].value.as< NodeList< VariableDefinition >::Ptr > (), yystack_[2].value.as< Type::Ptr > (),
wrapInBlockRule( yystack_[0].value.as< Rule::Ptr > () ) );
}
-#line 2657 "GrammarParser.cpp" // lalr1.cc:859
+#line 2745 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 144:
-#line 1328 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 152:
+#line 1384 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< SkipRule::Ptr > ();
}
-#line 2665 "GrammarParser.cpp" // lalr1.cc:859
+#line 2753 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 145:
-#line 1332 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 153:
+#line 1388 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< ConditionalRule::Ptr > ();
}
-#line 2673 "GrammarParser.cpp" // lalr1.cc:859
+#line 2761 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 146:
-#line 1336 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 154:
+#line 1392 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< CaseRule::Ptr > ();
}
-#line 2681 "GrammarParser.cpp" // lalr1.cc:859
+#line 2769 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 147:
-#line 1340 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 155:
+#line 1396 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< LetRule::Ptr > ();
}
-#line 2689 "GrammarParser.cpp" // lalr1.cc:859
+#line 2777 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 148:
-#line 1344 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 156:
+#line 1400 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< ForallRule::Ptr > ();
}
-#line 2697 "GrammarParser.cpp" // lalr1.cc:859
+#line 2785 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 149:
-#line 1348 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 157:
+#line 1404 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< ChooseRule::Ptr > ();
}
-#line 2705 "GrammarParser.cpp" // lalr1.cc:859
+#line 2793 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 150:
-#line 1352 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 158:
+#line 1408 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< IterateRule::Ptr > ();
}
-#line 2713 "GrammarParser.cpp" // lalr1.cc:859
+#line 2801 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 151:
-#line 1356 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 159:
+#line 1412 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< BlockRule::Ptr > ();
}
-#line 2721 "GrammarParser.cpp" // lalr1.cc:859
+#line 2809 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 152:
-#line 1360 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 160:
+#line 1416 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< SequenceRule::Ptr > ();
}
-#line 2729 "GrammarParser.cpp" // lalr1.cc:859
+#line 2817 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 153:
-#line 1364 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 161:
+#line 1420 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< UpdateRule::Ptr > ();
}
-#line 2737 "GrammarParser.cpp" // lalr1.cc:859
+#line 2825 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 154:
-#line 1368 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 162:
+#line 1424 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Rule::Ptr > () = yystack_[0].value.as< CallRule::Ptr > ();
}
-#line 2745 "GrammarParser.cpp" // lalr1.cc:859
+#line 2833 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 155:
-#line 1376 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 163:
+#line 1432 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
auto rules = yystack_[1].value.as< Rules::Ptr > ();
rules->add( yystack_[0].value.as< Rule::Ptr > () );
yylhs.value.as< Rules::Ptr > () = rules;
}
-#line 2755 "GrammarParser.cpp" // lalr1.cc:859
+#line 2843 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 156:
-#line 1382 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 164:
+#line 1438 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
auto rules = Ast::make< Rules >( yylhs.location );
rules->add( yystack_[0].value.as< Rule::Ptr > () );
yylhs.value.as< Rules::Ptr > () = rules;
}
-#line 2765 "GrammarParser.cpp" // lalr1.cc:859
+#line 2853 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 157:
-#line 1392 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 165:
+#line 1448 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< SkipRule::Ptr > () = Ast::make< SkipRule >( yylhs.location );
}
-#line 2773 "GrammarParser.cpp" // lalr1.cc:859
+#line 2861 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 158:
-#line 1400 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 166:
+#line 1456 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< ConditionalRule::Ptr > () = Ast::make< ConditionalRule >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Rule::Ptr > () );
}
-#line 2781 "GrammarParser.cpp" // lalr1.cc:859
+#line 2869 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 159:
-#line 1404 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 167:
+#line 1460 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< ConditionalRule::Ptr > () = Ast::make< ConditionalRule >( yylhs.location, yystack_[4].value.as< Expression::Ptr > (), yystack_[2].value.as< Rule::Ptr > (), yystack_[0].value.as< Rule::Ptr > () );
}
-#line 2789 "GrammarParser.cpp" // lalr1.cc:859
+#line 2877 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 160:
-#line 1412 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 168:
+#line 1468 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< CaseRule::Ptr > () = Ast::make< CaseRule >( yylhs.location, yystack_[4].value.as< Expression::Ptr > (), yystack_[1].value.as< Cases::Ptr > () );
}
-#line 2797 "GrammarParser.cpp" // lalr1.cc:859
+#line 2885 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 161:
-#line 1416 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 169:
+#line 1472 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< CaseRule::Ptr > () = nullptr;
}
-#line 2805 "GrammarParser.cpp" // lalr1.cc:859
+#line 2893 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 162:
-#line 1424 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 170:
+#line 1480 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Case::Ptr > () = Ast::make< DefaultCase >( yylhs.location, yystack_[0].value.as< Rule::Ptr > () );
}
-#line 2813 "GrammarParser.cpp" // lalr1.cc:859
+#line 2901 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 163:
-#line 1428 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 171:
+#line 1484 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Case::Ptr > () = Ast::make< DefaultCase >( yylhs.location, yystack_[0].value.as< Rule::Ptr > () );
}
-#line 2821 "GrammarParser.cpp" // lalr1.cc:859
+#line 2909 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 164:
-#line 1432 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 172:
+#line 1488 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Case::Ptr > () = Ast::make< ExpressionCase >( yylhs.location, yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Rule::Ptr > () );
}
-#line 2829 "GrammarParser.cpp" // lalr1.cc:859
+#line 2917 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 165:
-#line 1440 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 173:
+#line 1496 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
auto cases = yystack_[0].value.as< Cases::Ptr > ();
cases->add( yystack_[1].value.as< Case::Ptr > () );
yylhs.value.as< Cases::Ptr > () = cases;
}
-#line 2839 "GrammarParser.cpp" // lalr1.cc:859
+#line 2927 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 166:
-#line 1446 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 174:
+#line 1502 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
auto cases = Ast::make< Cases >( yylhs.location );
cases->add( yystack_[0].value.as< Case::Ptr > () );
yylhs.value.as< Cases::Ptr > () = cases;
}
-#line 2849 "GrammarParser.cpp" // lalr1.cc:859
+#line 2937 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 167:
-#line 1456 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 175:
+#line 1512 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< LetRule::Ptr > () = Ast::make< LetRule >( yylhs.location, yystack_[4].value.as< VariableDefinition::Ptr > (), yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Rule::Ptr > () );
}
-#line 2857 "GrammarParser.cpp" // lalr1.cc:859
+#line 2945 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 168:
-#line 1464 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 176:
+#line 1520 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< ForallRule::Ptr > () = Ast::make< ForallRule >( yylhs.location, yystack_[4].value.as< VariableDefinition::Ptr > (), yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Rule::Ptr > () );
}
-#line 2865 "GrammarParser.cpp" // lalr1.cc:859
+#line 2953 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 169:
-#line 1472 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 177:
+#line 1528 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< ChooseRule::Ptr > () = Ast::make< ChooseRule >( yylhs.location, yystack_[4].value.as< VariableDefinition::Ptr > (), yystack_[2].value.as< Expression::Ptr > (), yystack_[0].value.as< Rule::Ptr > () );
}
-#line 2873 "GrammarParser.cpp" // lalr1.cc:859
+#line 2961 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 170:
-#line 1480 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 178:
+#line 1536 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< IterateRule::Ptr > () = Ast::make< IterateRule >( yylhs.location, yystack_[0].value.as< Rule::Ptr > () );
}
-#line 2881 "GrammarParser.cpp" // lalr1.cc:859
+#line 2969 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 171:
-#line 1488 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 179:
+#line 1544 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< BlockRule::Ptr > () = Ast::make< BlockRule >( yylhs.location, yystack_[1].value.as< Rules::Ptr > () );
}
-#line 2889 "GrammarParser.cpp" // lalr1.cc:859
+#line 2977 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 172:
-#line 1492 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 180:
+#line 1548 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< BlockRule::Ptr > () = Ast::make< BlockRule >( yylhs.location, yystack_[1].value.as< Rules::Ptr > () );
}
-#line 2897 "GrammarParser.cpp" // lalr1.cc:859
+#line 2985 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 173:
-#line 1496 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 181:
+#line 1552 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< BlockRule::Ptr > () = nullptr;
yyerrok;
}
-#line 2906 "GrammarParser.cpp" // lalr1.cc:859
+#line 2994 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 174:
-#line 1501 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 182:
+#line 1557 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< BlockRule::Ptr > () = nullptr;
yyerrok;
}
-#line 2915 "GrammarParser.cpp" // lalr1.cc:859
+#line 3003 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 175:
-#line 1510 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 183:
+#line 1566 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< SequenceRule::Ptr > () = Ast::make< SequenceRule >( yylhs.location, yystack_[1].value.as< Rules::Ptr > () );
}
-#line 2923 "GrammarParser.cpp" // lalr1.cc:859
+#line 3011 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 176:
-#line 1514 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 184:
+#line 1570 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< SequenceRule::Ptr > () = Ast::make< SequenceRule >( yylhs.location, yystack_[1].value.as< Rules::Ptr > () );
}
-#line 2931 "GrammarParser.cpp" // lalr1.cc:859
+#line 3019 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 177:
-#line 1518 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 185:
+#line 1574 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< SequenceRule::Ptr > () = nullptr;
yyerrok;
}
-#line 2940 "GrammarParser.cpp" // lalr1.cc:859
+#line 3028 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 178:
-#line 1523 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 186:
+#line 1579 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< SequenceRule::Ptr > () = nullptr;
yyerrok;
}
-#line 2949 "GrammarParser.cpp" // lalr1.cc:859
+#line 3037 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 179:
-#line 1532 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 187:
+#line 1588 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
const auto function = yystack_[2].value.as< DirectCallExpression::Ptr > ();
function->setTargetType( CallExpression::TargetType::FUNCTION );
yylhs.value.as< UpdateRule::Ptr > () = Ast::make< UpdateRule >( yylhs.location, function, yystack_[0].value.as< Expression::Ptr > () );
}
-#line 2959 "GrammarParser.cpp" // lalr1.cc:859
+#line 3047 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 180:
-#line 1542 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 188:
+#line 1598 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
const std::set< CallExpression::TargetType >
allowedCallTargetTypes{ CallExpression::TargetType::RULE };
yylhs.value.as< CallRule::Ptr > () = Ast::make< CallRule >( yylhs.location, yystack_[0].value.as< DirectCallExpression::Ptr > (), allowedCallTargetTypes );
}
-#line 2969 "GrammarParser.cpp" // lalr1.cc:859
+#line 3057 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 181:
-#line 1548 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 189:
+#line 1604 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
const std::set< CallExpression::TargetType >
allowedCallTargetTypes{ CallExpression::TargetType::DERIVED,
CallExpression::TargetType::BUILTIN };
yylhs.value.as< CallRule::Ptr > () = Ast::make< CallRule >( yylhs.location, yystack_[0].value.as< DirectCallExpression::Ptr > (), allowedCallTargetTypes );
}
-#line 2980 "GrammarParser.cpp" // lalr1.cc:859
+#line 3068 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 182:
-#line 1555 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 190:
+#line 1611 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
const std::set< CallExpression::TargetType >
allowedCallTargetTypes{ CallExpression::TargetType::RULE };
yylhs.value.as< CallRule::Ptr > () = Ast::make< CallRule >( yylhs.location, yystack_[0].value.as< IndirectCallExpression::Ptr > (), allowedCallTargetTypes );
}
-#line 2990 "GrammarParser.cpp" // lalr1.cc:859
+#line 3078 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 183:
-#line 1561 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 191:
+#line 1617 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
const std::set< CallExpression::TargetType >
allowedCallTargetTypes{ CallExpression::TargetType::DERIVED,
CallExpression::TargetType::BUILTIN };
yylhs.value.as< CallRule::Ptr > () = Ast::make< CallRule >( yylhs.location, yystack_[0].value.as< IndirectCallExpression::Ptr > (), allowedCallTargetTypes );
}
-#line 3001 "GrammarParser.cpp" // lalr1.cc:859
+#line 3089 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 184:
-#line 1572 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 192:
+#line 1628 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Attribute::Ptr > () = yystack_[0].value.as< BasicAttribute::Ptr > ();
}
-#line 3009 "GrammarParser.cpp" // lalr1.cc:859
+#line 3097 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 185:
-#line 1576 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 193:
+#line 1632 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< Attribute::Ptr > () = yystack_[0].value.as< ExpressionAttribute::Ptr > ();
}
-#line 3017 "GrammarParser.cpp" // lalr1.cc:859
+#line 3105 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 186:
-#line 1584 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 194:
+#line 1640 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
auto attributes = yystack_[2].value.as< Attributes::Ptr > ();
attributes->add( yystack_[0].value.as< Attribute::Ptr > () );
yylhs.value.as< Attributes::Ptr > () = attributes;
}
-#line 3027 "GrammarParser.cpp" // lalr1.cc:859
+#line 3115 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 187:
-#line 1590 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 195:
+#line 1646 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
auto attributes = Ast::make< Attributes >( yylhs.location );
attributes->add( yystack_[0].value.as< Attribute::Ptr > () );
yylhs.value.as< Attributes::Ptr > () = attributes;
}
-#line 3037 "GrammarParser.cpp" // lalr1.cc:859
+#line 3125 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 188:
-#line 1600 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 196:
+#line 1656 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< BasicAttribute::Ptr > () = Ast::make< BasicAttribute >( yylhs.location, yystack_[0].value.as< Identifier::Ptr > () );
}
-#line 3045 "GrammarParser.cpp" // lalr1.cc:859
+#line 3133 "GrammarParser.cpp" // lalr1.cc:859
break;
- case 189:
-#line 1608 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
+ case 197:
+#line 1664 "../../obj/src/GrammarParser.yy" // lalr1.cc:859
{
yylhs.value.as< ExpressionAttribute::Ptr > () = Ast::make< ExpressionAttribute >( yylhs.location, yystack_[1].value.as< Identifier::Ptr > (), yystack_[0].value.as< Expression::Ptr > () );
}
-#line 3053 "GrammarParser.cpp" // lalr1.cc:859
+#line 3141 "GrammarParser.cpp" // lalr1.cc:859
break;
-#line 3057 "GrammarParser.cpp" // lalr1.cc:859
+#line 3145 "GrammarParser.cpp" // lalr1.cc:859
default:
break;
}
@@ -3308,606 +3396,634 @@ namespace libcasm_fe {
}
- const short int Parser::yypact_ninf_ = -219;
+ const short int Parser::yypact_ninf_ = -269;
- const signed char Parser::yytable_ninf_ = -73;
+ const signed char Parser::yytable_ninf_ = -81;
const short int
Parser::yypact_[] =
{
- 28, 184, 15, -219, -6, 9, 9, 9, 9, 9,
- 9, 9, -219, -219, 658, -219, -219, -219, -219, -219,
- -219, -219, -219, -219, 977, 9, -219, -219, -7, -219,
- 16, -3, 16, 25, 35, 42, 1038, -219, 10, -219,
- -219, -219, 7, 7, 7, 1038, 7, -219, -219, -219,
- 1038, 1038, 1038, 453, 514, 4, -219, -219, -219, -219,
- -219, -219, -219, 69, 13, 93, -219, -219, -219, -219,
- -219, -219, -219, -219, -219, 1415, -219, -219, -219, 94,
- -219, -219, -219, -219, -219, -219, -219, -219, 9, 6,
- 95, 108, -22, 4, 113, 114, 453, 1679, 445, 9,
- 9, 126, -219, 120, 162, 174, 1214, 175, -219, -219,
- -219, 152, 1038, 1448, 145, 157, -219, 1481, 11, -219,
- 977, -219, 575, -219, 1038, 1038, 1038, 1038, 1038, 1038,
- 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038,
- 1038, 1038, 1038, -219, 154, -219, -2, 4, 9, 884,
- 4, 153, 147, 19, -219, -219, -219, -219, -219, 116,
- 41, 1448, -219, -219, 12, 4, 1038, 1038, 1038, 1038,
- 1038, -219, 1514, -219, 1038, -219, 1038, -219, 1038, -219,
- 163, -219, 1679, 1, 1816, 1745, 1797, 1712, 52, 52,
- 1835, 144, 144, 155, 155, 155, -219, 1679, 1712, 1835,
- 144, 144, 1679, -219, -219, 7, 170, -219, 71, 612,
- 659, -219, 7, 7, 7, 884, 5, 1038, 1038, 159,
- 696, 733, 151, -219, -219, -219, -219, -219, -219, -219,
- -219, -219, -219, -219, -219, -219, 176, 4, 4, 4,
- 1038, -219, 87, 9, 9, -219, -219, 106, -219, -219,
- 9, -219, 111, 1349, 1103, 1283, 1382, 93, 1547, 1580,
- 1679, -219, -219, -219, 1038, -219, 9, 207, -219, 770,
- 206, 319, 181, 208, 209, -219, -219, -219, 1249, 1316,
- 179, 807, 165, 847, 1038, 884, -219, 216, 173, -42,
- 75, 1778, -219, 116, 30, 77, -219, 41, -219, 1038,
- 1038, 1038, 1038, 1038, -219, -219, -219, 1679, -219, -219,
- -219, -219, -219, -219, 1038, 1038, 1038, 884, 189, -219,
- -219, -219, -219, 1679, -219, 197, 238, 4, 4, -219,
- -219, 4, 4, -219, 1679, -219, 1679, 1679, -219, 1065,
- 1141, 1179, 224, 392, 1038, 203, -219, 199, -219, 192,
- 193, 884, 884, 884, 884, 210, 211, 222, 1613, 916,
- 225, 1646, 977, -219, 4, 4, -219, -219, -219, -219,
- -219, 884, 884, 884, -219, -219, -219, 226, -219, -219,
- -219, -219, -219, -219
+ 19, 321, 37, -269, -3, -11, -11, -11, -11, -11,
+ -11, 1, -11, -269, -269, 193, -269, -269, -269, -269,
+ -269, -269, -269, -269, -269, -27, -269, 934, -11, -269,
+ -269, -9, -269, 23, 17, 23, 29, 62, 69, 10,
+ 103, -269, -269, -269, -269, 1001, -269, -31, -269, -269,
+ -269, -11, -12, -12, -12, 1001, -12, -269, -269, -269,
+ 1001, 1001, 1001, 492, 559, 1, -269, -269, -269, -269,
+ -269, -269, -269, 48, 31, 105, -269, -269, -269, -269,
+ -269, -269, -269, -269, -269, 1529, -269, -269, -269, 9,
+ -269, -269, -269, -269, -269, -269, -269, -269, -11, 8,
+ 84, 102, -16, 1, 107, 108, 1, 1, 1001, 110,
+ 492, 1793, 724, -11, -269, -11, 114, -269, 109, 135,
+ 147, 1328, 148, -269, -269, -269, 127, 1001, 1562, 120,
+ 137, -269, 1595, 2, -269, 934, -269, 626, -269, 1001,
+ 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001,
+ 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, -269, 146,
+ -269, 16, 1, -11, 1180, 1, 124, 129, 34, -269,
+ 58, 45, 155, 140, 54, 89, 1859, 86, 1562, -269,
+ -269, 44, 1, 1001, 1001, 1001, 1001, 1001, -269, 1628,
+ -269, 1001, -269, 1001, -269, 1001, -269, 159, -269, 1793,
+ 28, 463, 1892, 1920, 1826, 119, 119, 370, 167, 167,
+ 153, 153, 153, -269, 1793, 1826, 370, 167, 167, 1793,
+ -269, -269, -12, 170, -269, 55, 693, 733, -269, -12,
+ -12, -12, 1180, 6, 1001, 1001, 158, 795, 835, 150,
+ -269, -269, -269, -269, -269, -269, -269, -269, -269, -269,
+ -269, -269, -269, 173, 1, 1, -269, 61, -11, -11,
+ -269, -269, 22, -269, -269, 172, 1, 1, -269, -269,
+ -269, 27, -269, -11, -269, 730, 1463, 1217, 1397, 1496,
+ 105, 1661, 1694, 1793, -269, -269, -269, 1001, -269, -11,
+ 205, -269, 1038, 207, 1078, 186, 212, 213, -269, -269,
+ -269, 1363, 1430, 183, 1100, 163, 1140, 1001, 1180, -269,
+ 228, -269, 58, 52, 56, -269, -269, 86, 180, -269,
+ -269, -269, -269, 1001, 1001, 1001, 1001, 1001, -269, -269,
+ -269, 1793, -269, -269, -269, -269, -269, -269, 1001, 1001,
+ 1001, 1180, 188, -269, -269, -269, -269, 1793, -269, 189,
+ 233, -269, 1, 1, 41, -269, 1793, -269, 1793, 1793,
+ -269, 1177, 1255, 1293, 217, 425, 1001, 197, -269, 185,
+ 192, -269, 1180, 1180, 1180, 1180, 202, 206, 210, 1727,
+ 867, 208, 1760, 934, 1, 1, -269, -269, -269, -269,
+ -269, 1180, 1180, 1180, -269, -269, -269, 216, -269, -269,
+ -269, -269, -269, -269
};
const unsigned char
Parser::yydefact_[] =
{
- 0, 0, 0, 9, 0, 0, 0, 0, 0, 0,
- 0, 0, 11, 13, 0, 3, 15, 4, 6, 7,
- 8, 5, 1, 47, 34, 0, 46, 51, 52, 26,
- 62, 0, 62, 0, 0, 0, 188, 187, 0, 184,
- 185, 12, 0, 0, 0, 0, 0, 81, 83, 82,
- 0, 0, 0, 0, 0, 0, 85, 86, 87, 89,
- 88, 84, 32, 33, 0, 134, 101, 79, 80, 78,
- 74, 75, 76, 77, 73, 28, 98, 100, 99, 0,
- 91, 92, 93, 94, 95, 96, 97, 53, 0, 0,
- 0, 0, 0, 25, 0, 0, 0, 189, 0, 0,
- 0, 55, 57, 0, 0, 0, 0, 0, 123, 104,
- 105, 0, 0, 129, 0, 0, 125, 129, 0, 90,
- 0, 27, 0, 135, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 10, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 12, 14, 0, 3, 16, 4, 6,
+ 7, 8, 9, 5, 1, 0, 54, 35, 0, 53,
+ 58, 59, 27, 70, 0, 70, 0, 0, 0, 75,
+ 0, 71, 72, 73, 74, 196, 195, 0, 192, 193,
+ 13, 0, 0, 0, 0, 0, 0, 89, 91, 90,
+ 0, 0, 0, 0, 0, 0, 93, 94, 95, 97,
+ 96, 92, 33, 34, 0, 142, 109, 87, 88, 86,
+ 82, 83, 84, 85, 81, 29, 106, 108, 107, 0,
+ 99, 100, 101, 102, 103, 104, 105, 60, 0, 0,
+ 0, 0, 0, 26, 0, 0, 0, 26, 0, 0,
+ 0, 197, 0, 0, 61, 0, 63, 65, 0, 0,
+ 0, 0, 0, 131, 112, 113, 0, 0, 137, 0,
+ 0, 133, 137, 0, 98, 0, 28, 0, 143, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 50, 0, 59, 0, 0, 0, 0,
- 0, 24, 0, 67, 23, 63, 64, 65, 66, 0,
- 0, 0, 10, 186, 0, 0, 0, 0, 0, 0,
- 0, 103, 0, 102, 0, 127, 0, 126, 0, 31,
- 0, 132, 129, 0, 120, 118, 119, 122, 106, 107,
- 113, 114, 115, 108, 109, 110, 111, 29, 121, 112,
- 116, 117, 30, 61, 60, 0, 0, 49, 0, 0,
- 0, 157, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 181, 183, 142, 144, 145, 146, 147, 148,
- 149, 150, 151, 152, 153, 154, 0, 0, 0, 25,
- 0, 17, 0, 0, 0, 40, 43, 0, 39, 41,
- 0, 54, 0, 0, 0, 0, 0, 0, 128, 0,
- 128, 131, 130, 58, 0, 36, 0, 0, 156, 0,
- 0, 0, 0, 0, 0, 170, 180, 182, 0, 0,
- 0, 0, 0, 0, 0, 0, 22, 21, 0, 23,
- 0, 70, 37, 0, 62, 62, 38, 0, 56, 0,
- 0, 0, 0, 0, 136, 133, 124, 35, 48, 178,
- 176, 155, 174, 172, 0, 0, 0, 0, 0, 173,
- 171, 177, 175, 179, 143, 0, 19, 0, 0, 68,
- 16, 25, 25, 42, 137, 140, 139, 138, 141, 0,
- 0, 0, 158, 0, 0, 0, 14, 0, 71, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 166,
- 0, 0, 34, 69, 0, 0, 167, 168, 169, 159,
- 161, 0, 0, 0, 165, 160, 20, 0, 44, 45,
- 162, 163, 164, 18
+ 0, 0, 0, 0, 0, 0, 0, 0, 57, 0,
+ 67, 0, 0, 0, 0, 0, 25, 0, 75, 24,
+ 0, 0, 0, 0, 24, 0, 78, 0, 0, 11,
+ 194, 0, 0, 0, 0, 0, 0, 0, 111, 0,
+ 110, 0, 135, 0, 134, 0, 32, 0, 140, 137,
+ 0, 128, 126, 127, 130, 114, 115, 121, 122, 123,
+ 116, 117, 118, 119, 30, 129, 120, 124, 125, 31,
+ 69, 68, 0, 0, 56, 0, 0, 0, 165, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 189,
+ 191, 150, 152, 153, 154, 155, 156, 157, 158, 159,
+ 160, 161, 162, 0, 0, 0, 18, 0, 0, 0,
+ 41, 44, 0, 40, 42, 0, 0, 0, 76, 47,
+ 50, 0, 48, 0, 62, 0, 0, 0, 0, 0,
+ 0, 136, 0, 136, 139, 138, 66, 0, 37, 0,
+ 0, 164, 0, 0, 0, 0, 0, 0, 178, 188,
+ 190, 0, 0, 0, 0, 0, 0, 0, 0, 23,
+ 22, 38, 0, 70, 70, 39, 43, 0, 0, 79,
+ 46, 49, 64, 0, 0, 0, 0, 0, 144, 141,
+ 132, 36, 55, 186, 184, 163, 182, 180, 0, 0,
+ 0, 0, 0, 181, 179, 185, 183, 187, 151, 0,
+ 20, 17, 26, 26, 0, 77, 145, 148, 147, 146,
+ 149, 0, 0, 0, 166, 0, 0, 0, 15, 0,
+ 0, 45, 0, 0, 0, 0, 0, 0, 0, 0,
+ 174, 0, 0, 35, 0, 0, 175, 176, 177, 167,
+ 169, 0, 0, 0, 173, 168, 21, 0, 51, 52,
+ 170, 171, 172, 19
};
const short int
Parser::yypgoto_[] =
{
- -219, -219, 160, 245, -219, -154, -219, -219, -219, -219,
- -218, -219, 141, -219, -84, -152, -219, -219, -219, -18,
- -219, -219, 27, -219, 258, -4, 37, -40, -219, -31,
- -120, -219, -219, -219, -219, -219, -219, -219, -219, -219,
- -219, -219, -219, -219, -219, -34, -219, -219, -219, -45,
- 32, -219, 3, 33, -219, -219, -219, -219, -219, -150,
- 48, -181, -219, -219, -219, -219, -74, -219, -219, -219,
- -219, -219, -219, -219, -219, 191, 194, -219, -219
+ -269, -269, 154, 255, -269, -165, -269, -269, -269, -269,
+ -99, -269, 136, -269, -109, 3, -269, -269, -269, 13,
+ -269, -269, -268, -41, -269, 133, -269, -15, -4, 4,
+ -39, -269, -33, -10, -269, -269, -269, -269, -269, -269,
+ -269, -269, -269, -269, -269, -269, -269, -269, -20, -269,
+ -269, -269, -58, 0, -269, 46, 104, -269, -269, -269,
+ -269, -269, 32, -83, -182, -269, -269, -269, -269, -98,
+ -269, -269, -269, -269, -269, -269, -269, -269, 175, 171,
+ -269, -269
};
const short int
Parser::yydefgoto_[] =
{
- -1, 2, 12, 13, 14, 15, 242, 346, 326, 151,
- 152, 16, 62, 63, 64, 17, 18, 19, 20, 246,
- 247, 248, 27, 208, 28, 65, 102, 103, 146, 90,
- 154, 155, 156, 157, 158, 290, 66, 67, 68, 69,
- 70, 71, 72, 73, 74, 75, 76, 77, 78, 114,
- 123, 79, 80, 81, 82, 83, 84, 85, 86, 21,
- 268, 269, 225, 226, 227, 359, 360, 228, 229, 230,
- 231, 232, 233, 234, 235, 37, 38, 39, 40
+ -1, 2, 13, 14, 15, 16, 257, 368, 350, 166,
+ 167, 17, 72, 73, 74, 269, 19, 20, 21, 261,
+ 262, 22, 270, 271, 263, 30, 225, 31, 75, 117,
+ 118, 161, 100, 169, 41, 42, 43, 44, 175, 76,
+ 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
+ 87, 88, 129, 138, 89, 90, 91, 92, 93, 94,
+ 95, 96, 272, 291, 292, 242, 243, 244, 380, 381,
+ 245, 246, 247, 248, 249, 250, 251, 252, 46, 47,
+ 48, 49
};
const short int
Parser::yytable_[] =
{
- 29, 92, 97, 104, 105, 241, 107, 144, 245, 118,
- 249, 106, -72, 23, -72, 22, 108, 109, 110, 113,
- 117, 288, 149, 23, 23, 23, 23, 206, 23, 271,
- 236, 1, 30, 31, 32, 33, 34, 35, 36, 281,
- 283, 91, 150, 24, 204, 251, 243, 262, 244, 145,
- 219, 119, 205, 100, 100, 178, 88, 25, 98, 177,
- 250, 89, 161, 121, 99, 178, 99, 25, 25, 101,
- 101, 101, 26, 101, 239, 89, 93, 183, 172, 94,
- 240, 331, 26, 26, 26, 26, 95, 26, 182, 153,
- 184, 185, 186, 187, 188, 189, 190, 191, 192, 193,
- 194, 195, 196, 197, 198, 199, 200, 201, 202, 133,
- 134, 135, 136, 349, 350, 143, 101, 286, 287, 289,
- 4, 265, 89, 120, 8, 266, 36, 36, 332, 328,
- 299, 329, 252, 253, 254, 255, 256, 292, 122, 330,
- 258, 293, 259, 153, 260, 245, 153, 249, 124, 125,
- 126, 127, 222, 128, 129, 130, 296, 148, 142, 147,
- 297, 153, 159, 160, 166, 263, 131, 132, 133, 134,
- 135, 136, 272, 273, 274, 207, 138, 165, 139, 140,
- 141, 167, 223, 278, 279, 3, 128, 129, 4, 5,
- 6, 7, 8, 168, 170, 9, 10, 224, 171, 174,
- 203, 133, 134, 135, 136, 175, 291, 347, 348, 261,
- 237, 238, 222, 222, 264, 136, 112, 284, 222, 276,
- 285, 309, 312, 222, 222, 314, 325, 315, 316, 319,
- 307, 11, 101, 153, 153, 153, 321, 327, 343, 101,
- 101, 101, 223, 223, 378, 379, 344, 345, 223, 277,
- 323, 354, 362, 223, 223, 363, 364, 365, 162, 41,
- 370, 179, 371, 275, 92, 334, 335, 336, 337, 338,
- 294, 295, 222, 372, 222, 375, 383, 101, 377, 333,
- 339, 340, 341, 87, 222, 374, 222, 298, 222, 304,
- 163, 0, 0, 308, 164, 0, 0, 0, 0, 0,
- 0, 0, 223, 0, 223, 0, 0, 0, 0, 358,
- 361, 0, 0, 0, 223, 0, 223, 311, 223, 311,
- 222, 0, 0, 153, 153, 358, 0, 153, 153, 311,
- 0, 311, 209, 324, 210, 313, 211, 212, 23, 213,
- 214, 215, 0, 216, 217, 0, 0, 218, 0, 0,
- 223, 0, 0, 0, 222, 222, 222, 222, 0, 0,
- 153, 153, 0, 0, 219, 342, 0, 0, 220, 0,
- 0, 0, 0, 0, 222, 222, 222, 0, 0, 0,
- 0, 0, 25, 0, 223, 223, 223, 223, 0, 221,
- 0, 0, 0, 355, 0, 0, 0, 26, 0, 366,
- 367, 368, 369, 0, 223, 223, 223, 0, 0, 0,
- 42, 23, 43, 44, 0, 0, 0, 45, 0, 380,
- 381, 382, 356, 0, 46, 0, 47, 48, 49, 0,
- 0, 0, 0, 50, 51, 52, 0, 96, 0, 54,
- 0, 0, 0, 0, 357, 55, 3, 0, 0, 4,
- 5, 6, 7, 8, 111, 25, 9, 10, 0, 0,
- 0, 0, 0, 0, 56, 57, 58, 59, 60, 61,
- 26, 42, 23, 43, 44, 0, 0, 0, 45, 0,
- 0, 0, 0, 0, 0, 46, 0, 47, 48, 49,
- 0, 0, 0, 0, 50, 51, 52, 0, 96, 0,
- 54, 0, 0, 0, 0, 0, 55, 0, 0, 0,
- 112, 0, 0, 0, 0, 115, 25, 0, 0, 0,
- 0, 0, 0, 0, 0, 56, 57, 58, 59, 60,
- 61, 26, 42, 23, 43, 44, 0, 0, 0, 45,
- 0, 0, 0, 0, 0, 0, 46, 0, 47, 48,
- 49, 0, 0, 0, 0, 50, 51, 52, 0, 96,
- 0, 54, 116, 0, 0, 0, 0, 55, 0, 0,
- 0, 0, 0, 0, 0, 0, 180, 25, 0, 0,
- 0, 0, 0, 0, 0, 0, 56, 57, 58, 59,
- 60, 61, 26, 42, 23, 43, 44, 0, 0, 0,
- 45, 0, 0, 0, 0, 0, 0, 46, 0, 47,
- 48, 49, 0, 267, 0, 0, 50, 51, 52, 0,
- 96, 181, 54, 0, 0, 209, 0, 210, 55, 211,
- 212, 23, 213, 214, 215, 0, 216, 217, 25, 0,
- 218, 0, 0, 0, 0, 0, 0, 56, 57, 58,
- 59, 60, 61, 26, 0, 0, 0, 219, -2, 3,
- 270, 220, 4, 5, 6, 7, 8, 0, 0, 9,
- 10, 0, 209, 0, 210, 25, 211, 212, 23, 213,
- 214, 215, 221, 216, 217, 0, 0, 218, 0, 0,
- 26, 0, 0, 0, 0, 0, 0, 280, 0, 0,
- 0, 0, 0, 0, 219, 11, 0, 0, 220, 209,
- 0, 210, 0, 211, 212, 23, 213, 214, 215, 0,
- 216, 217, 25, 0, 218, 0, 0, 0, 0, 221,
- 0, 0, 0, 0, 282, 0, 0, 26, 0, 0,
- 0, 219, 0, 0, 0, 220, 209, 0, 210, 0,
- 211, 212, 23, 213, 214, 215, 0, 216, 217, 25,
- 0, 218, 0, 0, 0, 0, 221, 0, 0, 0,
- 0, 0, 0, 0, 26, 0, 0, 0, 219, 0,
- 0, 0, 220, 209, 310, 210, 0, 211, 212, 23,
- 213, 214, 215, 0, 216, 217, 25, 0, 218, 0,
- 0, 0, 0, 221, 0, 0, 0, 0, 0, 0,
- 0, 26, 0, 0, 0, 219, 0, 0, 0, 220,
- 209, 0, 210, 0, 211, 212, 23, 213, 214, 215,
- 0, 216, 217, 25, 0, 218, 0, 0, 0, 0,
- 221, 0, 0, 0, 0, 0, 0, 0, 26, 0,
- 0, 0, 219, 0, 0, 0, 220, 320, 0, 0,
- 209, 0, 210, 0, 211, 212, 23, 213, 214, 215,
- 25, 216, 217, 0, 0, 218, 0, 221, 0, 0,
- 0, 0, 0, 0, 0, 26, 0, 0, 0, 0,
- 0, 0, 219, 0, 0, 0, 220, 209, 0, 210,
- 0, 211, 212, 23, 213, 214, 215, 0, 216, 217,
- 25, 0, 218, 0, 0, 0, 0, 221, 322, 0,
- 0, 0, 0, 0, 0, 26, 0, 0, 0, 219,
- 0, 0, 0, 220, 42, 23, 43, 44, 0, 0,
- 0, 45, 0, 0, 0, 0, 356, 25, 46, 0,
- 47, 48, 49, 0, 221, 0, 0, 50, 51, 52,
- 0, 96, 26, 54, 0, 0, 0, 0, 357, 55,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 25,
- 0, 0, 0, 0, 0, 0, 0, 0, 56, 57,
- 58, 59, 60, 61, 26, 42, 23, 43, 44, 0,
- 0, 0, 45, 0, 0, 0, 0, 0, 0, 46,
- 0, 47, 48, 49, 0, 0, 0, 0, 50, 51,
- 52, 0, 53, 0, 54, 0, 0, 0, 0, 0,
- 55, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 25, 0, 0, 0, 0, 0, 0, 0, 0, 56,
- 57, 58, 59, 60, 61, 26, 42, 23, 43, 44,
- 0, 0, 0, 45, 0, 0, 0, 0, 0, 0,
- 46, 0, 47, 48, 49, 0, 0, 0, 0, 50,
- 51, 52, 0, 96, 351, 54, 0, 0, 0, 0,
- 0, 55, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 25, 124, 125, 126, 127, 0, 128, 129, 130,
- 56, 57, 58, 59, 60, 61, 26, 0, 0, 0,
- 131, 132, 133, 134, 135, 136, 301, 0, 0, 0,
- 138, 0, 139, 140, 141, 0, 0, 0, 0, 0,
- 124, 125, 126, 127, 0, 128, 129, 130, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 131, 132,
- 133, 134, 135, 136, 352, 0, 0, 0, 138, 0,
- 139, 140, 141, 0, 0, 0, 0, 0, 124, 125,
- 126, 127, 0, 128, 129, 130, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 131, 132, 133, 134,
- 135, 136, 353, 0, 0, 0, 138, 0, 139, 140,
- 141, 0, 0, 0, 0, 0, 124, 125, 126, 127,
- 0, 128, 129, 130, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 131, 132, 133, 134, 135, 136,
- 169, 0, 0, 0, 138, 0, 139, 140, 141, 0,
- 0, 124, 125, 126, 127, 0, 128, 129, 130, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 131,
- 132, 133, 134, 135, 136, 317, 0, 0, 0, 138,
- 0, 139, 140, 141, 0, 0, 124, 125, 126, 127,
- 0, 128, 129, 130, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 131, 132, 133, 134, 135, 136,
- 302, 0, 0, 0, 138, 0, 139, 140, 141, 0,
- 124, 125, 126, 127, 0, 128, 129, 130, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 131, 132,
- 133, 134, 135, 136, 0, 318, 0, 0, 138, 0,
- 139, 140, 141, 124, 125, 126, 127, 0, 128, 129,
- 130, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 131, 132, 133, 134, 135, 136, 0, 0, 0,
- 300, 138, 0, 139, 140, 141, 124, 125, 126, 127,
- 0, 128, 129, 130, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 131, 132, 133, 134, 135, 136,
- 0, 0, 0, 0, 138, 303, 139, 140, 141, 124,
- 125, 126, 127, 0, 128, 129, 130, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 131, 132, 133,
- 134, 135, 136, 0, 0, 0, 0, 138, 0, 139,
- 140, 141, 124, 125, 126, 127, 0, 128, 129, 130,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 131, 132, 133, 134, 135, 136, 0, 0, 0, 137,
- 138, 0, 139, 140, 141, 124, 125, 126, 127, 0,
- 128, 129, 130, 0, 173, 0, 0, 0, 0, 0,
- 0, 0, 0, 131, 132, 133, 134, 135, 136, 0,
- 0, 0, 0, 138, 0, 139, 140, 141, 124, 125,
- 126, 127, 0, 128, 129, 130, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 131, 132, 133, 134,
- 135, 136, 0, 176, 0, 0, 138, 0, 139, 140,
- 141, 124, 125, 126, 127, 0, 128, 129, 130, 0,
- 257, 0, 0, 0, 0, 0, 0, 0, 0, 131,
- 132, 133, 134, 135, 136, 0, 0, 0, 0, 138,
- 0, 139, 140, 141, 124, 125, 126, 127, 0, 128,
- 129, 130, 0, 305, 0, 0, 0, 0, 0, 0,
- 0, 0, 131, 132, 133, 134, 135, 136, 0, 0,
- 0, 0, 138, 0, 139, 140, 141, 124, 125, 126,
- 127, 0, 128, 129, 130, 0, 0, 0, 306, 0,
- 0, 0, 0, 0, 0, 131, 132, 133, 134, 135,
- 136, 0, 0, 0, 0, 138, 0, 139, 140, 141,
- 124, 125, 126, 127, 0, 128, 129, 130, 0, 0,
- 0, 0, 0, 0, 373, 0, 0, 0, 131, 132,
- 133, 134, 135, 136, 0, 0, 0, 0, 138, 0,
- 139, 140, 141, 124, 125, 126, 127, 0, 128, 129,
- 130, 0, 0, 0, 0, 0, 376, 0, 0, 0,
- 0, 131, 132, 133, 134, 135, 136, 0, 0, 0,
- 0, 138, 0, 139, 140, 141, 124, 125, 126, 127,
- 0, 128, 129, 130, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 131, 132, 133, 134, 135, 136,
- 0, 0, 0, 0, 138, 0, 139, 140, 141, 124,
- 125, 126, 0, 0, 128, 129, 130, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 131, 132, 133,
- 134, 135, 136, 0, 0, 0, 0, 0, 0, 139,
- 140, 141, 124, 0, 126, 0, 0, 128, 129, 130,
+ 32, 40, 102, 321, 18, 256, 133, 39, 173, 159,
+ 26, 26, 25, 97, 119, 120, 25, 122, 18, 26,
+ 112, 25, 1, 26, 106, 111, 113, 258, 26, 259,
+ 26, 164, 5, 23, 7, 121, 114, 24, 115, 51,
+ 123, 124, 125, 128, 132, 294, 5, 23, 7, 27,
+ 258, 165, 259, 194, 236, 304, 306, 98, 115, 195,
+ 160, 134, 4, 28, 101, 221, 8, 28, 107, 29,
+ 29, 99, 28, 222, 108, 315, 157, 285, 29, 200,
+ 320, 241, 29, 103, 136, 195, 321, 29, 176, 29,
+ 178, 5, 107, 7, 371, 273, 172, 174, 108, 168,
+ 99, 113, 168, 168, 99, 135, 352, 189, 288, 104,
+ 353, -80, 289, -80, 311, 18, 105, 199, 312, 201,
+ 202, 203, 204, 205, 206, 207, 208, 209, 210, 211,
+ 212, 213, 214, 215, 216, 217, 218, 219, 33, 34,
+ 35, 36, 37, 38, 23, 45, 267, 351, 268, 298,
+ 109, 162, 223, 137, 163, 253, 183, 184, 168, 170,
+ 171, 168, 177, 275, 276, 277, 278, 279, 182, 185,
+ 187, 281, 274, 282, 260, 283, 188, 191, 168, 148,
+ 149, 150, 151, 286, 254, 116, 116, 116, 192, 116,
+ 295, 296, 297, -2, 3, 220, 255, 4, 5, 6,
+ 7, 8, 265, 264, 9, 10, 11, 266, 284, 335,
+ 239, 335, 143, 144, 301, 302, 151, 287, 127, 307,
+ 308, 335, 333, 335, 317, 348, 336, 148, 149, 150,
+ 151, 158, 116, 338, 339, 340, 343, 345, 349, 355,
+ 365, 366, 367, 12, 309, 310, 45, 375, 45, 383,
+ 168, 168, 384, 369, 370, 390, 318, 319, 364, 385,
+ 391, 395, 168, 168, 392, 260, 179, 331, 240, 403,
+ 50, 196, 239, 239, 397, 316, 354, 322, 239, 299,
+ 328, 102, 394, 239, 239, 0, 181, 347, 180, 386,
+ 387, 388, 389, 0, 264, 0, 224, 0, 0, 0,
+ 0, 0, 0, 356, 357, 358, 359, 360, 400, 401,
+ 402, 0, 0, 0, 0, 0, 0, 0, 361, 362,
+ 363, 0, 3, 0, 0, 4, 5, 6, 7, 8,
+ 240, 240, 9, 10, 11, 0, 240, 300, 239, 0,
+ 239, 240, 240, 0, 0, 379, 382, 0, 168, 168,
+ 239, 0, 239, 0, 239, 116, 0, 0, 0, 0,
+ 379, 0, 116, 116, 116, 0, 0, 0, 0, 0,
+ 0, 12, 0, 0, 398, 399, 0, 0, 0, 0,
+ 168, 168, 0, 0, 0, 0, 0, 239, 0, 0,
+ 0, 313, 314, 0, 0, 0, 240, 0, 240, 0,
+ 0, 0, 0, 0, 0, 0, 116, 0, 240, 0,
+ 240, 0, 240, 0, 0, 143, 144, 0, 239, 239,
+ 239, 239, 332, 0, 0, 0, 376, 0, 146, 147,
+ 148, 149, 150, 151, 0, 0, 0, 239, 239, 239,
+ 25, 155, 156, 0, 0, 240, 52, 26, 53, 54,
+ 0, 0, 0, 55, 0, 0, 0, 0, 377, 0,
+ 56, 0, 57, 58, 59, 0, 0, 0, 0, 60,
+ 61, 62, 0, 110, 0, 64, 240, 240, 240, 240,
+ 378, 65, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 28, 0, 126, 0, 240, 240, 240, 0, 0,
+ 66, 67, 68, 69, 70, 71, 29, 25, 143, 144,
+ 145, 0, 0, 52, 26, 53, 54, 0, 0, 0,
+ 55, 146, 147, 148, 149, 150, 151, 56, 0, 57,
+ 58, 59, 0, 154, 155, 156, 60, 61, 62, 0,
+ 110, 0, 64, 0, 0, 0, 0, 0, 65, 0,
+ 0, 0, 127, 0, 0, 0, 0, 0, 28, 0,
+ 130, 0, 0, 0, 0, 0, 0, 66, 67, 68,
+ 69, 70, 71, 29, 25, 0, 0, 0, 0, 0,
+ 52, 26, 53, 54, 0, 0, 0, 55, 0, 0,
+ 0, 0, 0, 0, 56, 0, 57, 58, 59, 0,
+ 0, 0, 0, 60, 61, 62, 0, 110, 0, 64,
+ 131, 0, 0, 0, 0, 65, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 28, 0, 197, 0, 0,
+ 0, 0, 0, 0, 66, 67, 68, 69, 70, 71,
+ 29, 25, 0, 0, 0, 0, 0, 52, 26, 53,
+ 54, 0, 0, 0, 55, 0, 0, 0, 0, 0,
+ 0, 56, 0, 57, 58, 59, 0, 0, 0, 0,
+ 60, 61, 62, 0, 110, 198, 64, 0, 0, 0,
+ 0, 0, 65, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 28, 0, 290, 0, 0, 0, 0, 0,
+ 0, 66, 67, 68, 69, 70, 71, 29, 25, 226,
+ 0, 227, 0, 228, 229, 26, 230, 231, 232, 0,
+ 233, 234, 0, 0, 235, 3, 0, 0, 4, 5,
+ 6, 7, 8, 0, 293, 9, 10, 11, 0, 0,
+ 0, 236, 0, 0, 0, 237, 0, 0, 25, 226,
+ 0, 227, 323, 228, 229, 26, 230, 231, 232, 28,
+ 233, 234, 0, 0, 235, 0, 238, 0, 0, 0,
+ 139, 140, 141, 142, 29, 143, 144, 145, 0, 0,
+ 0, 236, 0, 0, 0, 237, 0, 0, 146, 147,
+ 148, 149, 150, 151, 0, 0, 303, 0, 153, 28,
+ 154, 155, 156, 0, 0, 0, 238, 0, 0, 0,
+ 25, 226, 0, 227, 29, 228, 229, 26, 230, 231,
+ 232, 0, 233, 234, 0, 0, 235, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 305, 0, 0, 0,
+ 0, 0, 0, 236, 0, 0, 0, 237, 0, 0,
+ 25, 226, 0, 227, 0, 228, 229, 26, 230, 231,
+ 232, 28, 233, 234, 0, 0, 235, 0, 238, 0,
+ 0, 0, 0, 0, 0, 0, 29, 0, 0, 0,
+ 0, 0, 25, 236, 0, 0, 0, 237, 52, 26,
+ 53, 54, 0, 0, 0, 55, 0, 0, 0, 0,
+ 377, 28, 56, 0, 57, 58, 59, 0, 238, 0,
+ 0, 60, 61, 62, 0, 110, 29, 64, 0, 0,
+ 0, 0, 378, 65, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 28, 0, 0, 0, 0, 0, 0,
+ 0, 0, 66, 67, 68, 69, 70, 71, 29, 25,
+ 0, 0, 0, 0, 0, 52, 26, 53, 54, 0,
+ 0, 0, 55, 0, 0, 0, 0, 0, 0, 56,
+ 0, 57, 58, 59, 0, 0, 0, 0, 60, 61,
+ 62, 0, 63, 0, 64, 0, 0, 0, 0, 0,
+ 65, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 28, 0, 0, 0, 0, 0, 0, 0, 0, 66,
+ 67, 68, 69, 70, 71, 29, 25, 0, 0, 0,
+ 0, 0, 52, 26, 53, 54, 0, 0, 0, 55,
+ 0, 0, 0, 0, 0, 0, 56, 0, 57, 58,
+ 59, 0, 0, 0, 0, 60, 61, 62, 0, 110,
+ 0, 64, 0, 25, 226, 334, 227, 65, 228, 229,
+ 26, 230, 231, 232, 0, 233, 234, 28, 0, 235,
+ 0, 0, 0, 0, 0, 0, 66, 67, 68, 69,
+ 70, 71, 29, 0, 0, 0, 236, 0, 0, 0,
+ 237, 0, 0, 25, 226, 0, 227, 337, 228, 229,
+ 26, 230, 231, 232, 28, 233, 234, 0, 0, 235,
+ 0, 238, 0, 0, 0, 25, 226, 0, 227, 29,
+ 228, 229, 26, 230, 231, 232, 236, 233, 234, 0,
+ 237, 235, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 28, 0, 0, 0, 236, 0,
+ 0, 238, 237, 344, 0, 25, 226, 0, 227, 29,
+ 228, 229, 26, 230, 231, 232, 28, 233, 234, 0,
+ 0, 235, 0, 238, 0, 0, 0, 0, 0, 0,
+ 0, 29, 0, 0, 0, 0, 0, 0, 236, 0,
+ 0, 0, 237, 0, 0, 25, 226, 0, 227, 372,
+ 228, 229, 26, 230, 231, 232, 28, 233, 234, 0,
+ 0, 235, 0, 238, 346, 0, 0, 139, 140, 141,
+ 142, 29, 143, 144, 145, 0, 0, 0, 236, 0,
+ 0, 0, 237, 0, 0, 146, 147, 148, 149, 150,
+ 151, 0, 0, 325, 0, 153, 28, 154, 155, 156,
+ 0, 0, 0, 238, 0, 0, 0, 139, 140, 141,
+ 142, 29, 143, 144, 145, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 146, 147, 148, 149, 150,
+ 151, 373, 0, 0, 0, 153, 0, 154, 155, 156,
+ 0, 0, 0, 0, 0, 139, 140, 141, 142, 0,
+ 143, 144, 145, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 146, 147, 148, 149, 150, 151, 374,
+ 0, 0, 0, 153, 0, 154, 155, 156, 0, 0,
+ 0, 0, 0, 139, 140, 141, 142, 0, 143, 144,
+ 145, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 146, 147, 148, 149, 150, 151, 186, 0, 0,
+ 0, 153, 0, 154, 155, 156, 0, 0, 139, 140,
+ 141, 142, 0, 143, 144, 145, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 146, 147, 148, 149,
+ 150, 151, 341, 0, 0, 0, 153, 0, 154, 155,
+ 156, 0, 0, 139, 140, 141, 142, 0, 143, 144,
+ 145, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 146, 147, 148, 149, 150, 151, 326, 0, 0,
+ 0, 153, 0, 154, 155, 156, 0, 139, 140, 141,
+ 142, 0, 143, 144, 145, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 146, 147, 148, 149, 150,
+ 151, 0, 342, 0, 0, 153, 0, 154, 155, 156,
+ 139, 140, 141, 142, 0, 143, 144, 145, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 146, 147,
+ 148, 149, 150, 151, 0, 0, 0, 324, 153, 0,
+ 154, 155, 156, 139, 140, 141, 142, 0, 143, 144,
+ 145, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 146, 147, 148, 149, 150, 151, 0, 0, 0,
+ 0, 153, 327, 154, 155, 156, 139, 140, 141, 142,
+ 0, 143, 144, 145, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 146, 147, 148, 149, 150, 151,
+ 0, 0, 0, 0, 153, 0, 154, 155, 156, 139,
+ 140, 141, 142, 0, 143, 144, 145, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 146, 147, 148,
+ 149, 150, 151, 0, 0, 0, 152, 153, 0, 154,
+ 155, 156, 139, 140, 141, 142, 0, 143, 144, 145,
+ 0, 190, 0, 0, 0, 0, 0, 0, 0, 0,
+ 146, 147, 148, 149, 150, 151, 0, 0, 0, 0,
+ 153, 0, 154, 155, 156, 139, 140, 141, 142, 0,
+ 143, 144, 145, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 146, 147, 148, 149, 150, 151, 0,
+ 193, 0, 0, 153, 0, 154, 155, 156, 139, 140,
+ 141, 142, 0, 143, 144, 145, 0, 280, 0, 0,
+ 0, 0, 0, 0, 0, 0, 146, 147, 148, 149,
+ 150, 151, 0, 0, 0, 0, 153, 0, 154, 155,
+ 156, 139, 140, 141, 142, 0, 143, 144, 145, 0,
+ 329, 0, 0, 0, 0, 0, 0, 0, 0, 146,
+ 147, 148, 149, 150, 151, 0, 0, 0, 0, 153,
+ 0, 154, 155, 156, 139, 140, 141, 142, 0, 143,
+ 144, 145, 0, 0, 0, 330, 0, 0, 0, 0,
+ 0, 0, 146, 147, 148, 149, 150, 151, 0, 0,
+ 0, 0, 153, 0, 154, 155, 156, 139, 140, 141,
+ 142, 0, 143, 144, 145, 0, 0, 0, 0, 0,
+ 0, 393, 0, 0, 0, 146, 147, 148, 149, 150,
+ 151, 0, 0, 0, 0, 153, 0, 154, 155, 156,
+ 139, 140, 141, 142, 0, 143, 144, 145, 0, 0,
+ 0, 0, 0, 396, 0, 0, 0, 0, 146, 147,
+ 148, 149, 150, 151, 0, 0, 0, 0, 153, 0,
+ 154, 155, 156, 139, 140, 141, 142, 0, 143, 144,
+ 145, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 146, 147, 148, 149, 150, 151, 0, 0, 0,
+ 0, 153, 0, 154, 155, 156, 139, 140, 141, 0,
+ 0, 143, 144, 145, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 146, 147, 148, 149, 150, 151,
+ 0, 0, 0, 0, 0, 0, 154, 155, 156, 139,
+ 140, 141, 142, 0, 143, 144, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 146, 0, 0,
+ 149, 150, 151, 0, 0, 0, 0, 153, 0, 154,
+ 155, 156, 139, 0, 141, 0, 0, 143, 144, 145,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 131, 132, 133, 134, 135, 136, 0, 0, 0, 0,
- 0, 0, 139, 140, 141, 124, 125, 126, 127, 0,
- 128, 129, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 131, 124, 0, 134, 135, 136, 128,
- 129, 130, 0, 138, 0, 139, 140, 141, 0, 0,
- 0, 0, 131, 132, 133, 134, 135, 136, 128, 129,
- 130, 0, 0, 0, 139, 140, 141, 0, 0, 0,
- 0, 131, 132, 133, 134, 135, 136, 128, 129, 0,
- 0, 0, 0, 139, 140, 141, 0, 0, 0, 0,
- 131, 132, 133, 134, 135, 136, 0, 0, 0, 0,
- 0, 0, 0, 140, 141
+ 146, 147, 148, 149, 150, 151, 0, 0, 0, 0,
+ 139, 0, 154, 155, 156, 143, 144, 145, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 146, 147,
+ 148, 149, 150, 151, 0, 0, 0, 0, 0, 0,
+ 154, 155, 156
};
const short int
Parser::yycheck_[] =
{
- 4, 32, 36, 43, 44, 159, 46, 1, 160, 54,
- 160, 45, 54, 19, 56, 0, 50, 51, 52, 53,
- 54, 239, 44, 19, 19, 19, 19, 147, 19, 210,
- 150, 3, 5, 6, 7, 8, 9, 10, 11, 220,
- 221, 44, 64, 49, 46, 165, 5, 46, 7, 89,
- 45, 55, 54, 47, 47, 54, 63, 63, 48, 48,
- 48, 45, 96, 50, 54, 54, 54, 63, 63, 42,
- 43, 44, 78, 46, 55, 45, 51, 122, 112, 44,
- 61, 51, 78, 78, 78, 78, 44, 78, 122, 93,
- 124, 125, 126, 127, 128, 129, 130, 131, 132, 133,
- 134, 135, 136, 137, 138, 139, 140, 141, 142, 57,
- 58, 59, 60, 331, 332, 88, 89, 237, 238, 239,
- 4, 50, 45, 54, 8, 54, 99, 100, 51, 54,
- 19, 56, 166, 167, 168, 169, 170, 50, 45, 293,
- 174, 54, 176, 147, 178, 297, 150, 297, 37, 38,
- 39, 40, 149, 42, 43, 44, 50, 49, 64, 64,
- 54, 165, 49, 49, 44, 205, 55, 56, 57, 58,
- 59, 60, 212, 213, 214, 148, 65, 51, 67, 68,
- 69, 19, 149, 217, 218, 1, 42, 43, 4, 5,
- 6, 7, 8, 19, 19, 11, 12, 149, 46, 54,
- 46, 57, 58, 59, 60, 48, 240, 327, 328, 46,
- 57, 64, 209, 210, 44, 60, 57, 66, 215, 216,
- 44, 14, 16, 220, 221, 44, 10, 19, 19, 50,
- 264, 47, 205, 237, 238, 239, 71, 64, 49, 212,
- 213, 214, 209, 210, 364, 365, 49, 9, 215, 216,
- 284, 27, 49, 220, 221, 56, 64, 64, 98, 14,
- 50, 120, 51, 215, 295, 299, 300, 301, 302, 303,
- 243, 244, 269, 51, 271, 50, 50, 250, 362, 297,
- 314, 315, 316, 25, 281, 359, 283, 250, 285, 257,
- 99, -1, -1, 266, 100, -1, -1, -1, -1, -1,
- -1, -1, 269, -1, 271, -1, -1, -1, -1, 343,
- 344, -1, -1, -1, 281, -1, 283, 269, 285, 271,
- 317, -1, -1, 327, 328, 359, -1, 331, 332, 281,
- -1, 283, 13, 285, 15, 16, 17, 18, 19, 20,
- 21, 22, -1, 24, 25, -1, -1, 28, -1, -1,
- 317, -1, -1, -1, 351, 352, 353, 354, -1, -1,
- 364, 365, -1, -1, 45, 317, -1, -1, 49, -1,
- -1, -1, -1, -1, 371, 372, 373, -1, -1, -1,
- -1, -1, 63, -1, 351, 352, 353, 354, -1, 70,
- -1, -1, -1, 1, -1, -1, -1, 78, -1, 351,
- 352, 353, 354, -1, 371, 372, 373, -1, -1, -1,
- 18, 19, 20, 21, -1, -1, -1, 25, -1, 371,
- 372, 373, 30, -1, 32, -1, 34, 35, 36, -1,
- -1, -1, -1, 41, 42, 43, -1, 45, -1, 47,
- -1, -1, -1, -1, 52, 53, 1, -1, -1, 4,
- 5, 6, 7, 8, 1, 63, 11, 12, -1, -1,
- -1, -1, -1, -1, 72, 73, 74, 75, 76, 77,
- 78, 18, 19, 20, 21, -1, -1, -1, 25, -1,
- -1, -1, -1, -1, -1, 32, -1, 34, 35, 36,
- -1, -1, -1, -1, 41, 42, 43, -1, 45, -1,
- 47, -1, -1, -1, -1, -1, 53, -1, -1, -1,
- 57, -1, -1, -1, -1, 1, 63, -1, -1, -1,
- -1, -1, -1, -1, -1, 72, 73, 74, 75, 76,
- 77, 78, 18, 19, 20, 21, -1, -1, -1, 25,
- -1, -1, -1, -1, -1, -1, 32, -1, 34, 35,
- 36, -1, -1, -1, -1, 41, 42, 43, -1, 45,
- -1, 47, 48, -1, -1, -1, -1, 53, -1, -1,
- -1, -1, -1, -1, -1, -1, 1, 63, -1, -1,
- -1, -1, -1, -1, -1, -1, 72, 73, 74, 75,
- 76, 77, 78, 18, 19, 20, 21, -1, -1, -1,
- 25, -1, -1, -1, -1, -1, -1, 32, -1, 34,
- 35, 36, -1, 1, -1, -1, 41, 42, 43, -1,
- 45, 46, 47, -1, -1, 13, -1, 15, 53, 17,
- 18, 19, 20, 21, 22, -1, 24, 25, 63, -1,
- 28, -1, -1, -1, -1, -1, -1, 72, 73, 74,
- 75, 76, 77, 78, -1, -1, -1, 45, 0, 1,
- 1, 49, 4, 5, 6, 7, 8, -1, -1, 11,
- 12, -1, 13, -1, 15, 63, 17, 18, 19, 20,
- 21, 22, 70, 24, 25, -1, -1, 28, -1, -1,
- 78, -1, -1, -1, -1, -1, -1, 1, -1, -1,
- -1, -1, -1, -1, 45, 47, -1, -1, 49, 13,
- -1, 15, -1, 17, 18, 19, 20, 21, 22, -1,
- 24, 25, 63, -1, 28, -1, -1, -1, -1, 70,
- -1, -1, -1, -1, 1, -1, -1, 78, -1, -1,
- -1, 45, -1, -1, -1, 49, 13, -1, 15, -1,
- 17, 18, 19, 20, 21, 22, -1, 24, 25, 63,
- -1, 28, -1, -1, -1, -1, 70, -1, -1, -1,
- -1, -1, -1, -1, 78, -1, -1, -1, 45, -1,
- -1, -1, 49, 13, 14, 15, -1, 17, 18, 19,
- 20, 21, 22, -1, 24, 25, 63, -1, 28, -1,
- -1, -1, -1, 70, -1, -1, -1, -1, -1, -1,
- -1, 78, -1, -1, -1, 45, -1, -1, -1, 49,
- 13, -1, 15, -1, 17, 18, 19, 20, 21, 22,
- -1, 24, 25, 63, -1, 28, -1, -1, -1, -1,
- 70, -1, -1, -1, -1, -1, -1, -1, 78, -1,
- -1, -1, 45, -1, -1, -1, 49, 50, -1, -1,
- 13, -1, 15, -1, 17, 18, 19, 20, 21, 22,
- 63, 24, 25, -1, -1, 28, -1, 70, -1, -1,
- -1, -1, -1, -1, -1, 78, -1, -1, -1, -1,
- -1, -1, 45, -1, -1, -1, 49, 13, -1, 15,
- -1, 17, 18, 19, 20, 21, 22, -1, 24, 25,
- 63, -1, 28, -1, -1, -1, -1, 70, 71, -1,
- -1, -1, -1, -1, -1, 78, -1, -1, -1, 45,
- -1, -1, -1, 49, 18, 19, 20, 21, -1, -1,
- -1, 25, -1, -1, -1, -1, 30, 63, 32, -1,
- 34, 35, 36, -1, 70, -1, -1, 41, 42, 43,
- -1, 45, 78, 47, -1, -1, -1, -1, 52, 53,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 63,
- -1, -1, -1, -1, -1, -1, -1, -1, 72, 73,
- 74, 75, 76, 77, 78, 18, 19, 20, 21, -1,
- -1, -1, 25, -1, -1, -1, -1, -1, -1, 32,
- -1, 34, 35, 36, -1, -1, -1, -1, 41, 42,
- 43, -1, 45, -1, 47, -1, -1, -1, -1, -1,
- 53, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 63, -1, -1, -1, -1, -1, -1, -1, -1, 72,
- 73, 74, 75, 76, 77, 78, 18, 19, 20, 21,
- -1, -1, -1, 25, -1, -1, -1, -1, -1, -1,
- 32, -1, 34, 35, 36, -1, -1, -1, -1, 41,
- 42, 43, -1, 45, 19, 47, -1, -1, -1, -1,
- -1, 53, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 63, 37, 38, 39, 40, -1, 42, 43, 44,
- 72, 73, 74, 75, 76, 77, 78, -1, -1, -1,
- 55, 56, 57, 58, 59, 60, 23, -1, -1, -1,
- 65, -1, 67, 68, 69, -1, -1, -1, -1, -1,
- 37, 38, 39, 40, -1, 42, 43, 44, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 55, 56,
- 57, 58, 59, 60, 23, -1, -1, -1, 65, -1,
- 67, 68, 69, -1, -1, -1, -1, -1, 37, 38,
- 39, 40, -1, 42, 43, 44, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 55, 56, 57, 58,
- 59, 60, 23, -1, -1, -1, 65, -1, 67, 68,
- 69, -1, -1, -1, -1, -1, 37, 38, 39, 40,
- -1, 42, 43, 44, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 55, 56, 57, 58, 59, 60,
- 26, -1, -1, -1, 65, -1, 67, 68, 69, -1,
- -1, 37, 38, 39, 40, -1, 42, 43, 44, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 55,
- 56, 57, 58, 59, 60, 26, -1, -1, -1, 65,
- -1, 67, 68, 69, -1, -1, 37, 38, 39, 40,
- -1, 42, 43, 44, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 55, 56, 57, 58, 59, 60,
- 27, -1, -1, -1, 65, -1, 67, 68, 69, -1,
- 37, 38, 39, 40, -1, 42, 43, 44, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 55, 56,
- 57, 58, 59, 60, -1, 29, -1, -1, 65, -1,
- 67, 68, 69, 37, 38, 39, 40, -1, 42, 43,
- 44, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 55, 56, 57, 58, 59, 60, -1, -1, -1,
- 31, 65, -1, 67, 68, 69, 37, 38, 39, 40,
- -1, 42, 43, 44, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 55, 56, 57, 58, 59, 60,
- -1, -1, -1, -1, 65, 33, 67, 68, 69, 37,
- 38, 39, 40, -1, 42, 43, 44, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, 55, 56, 57,
- 58, 59, 60, -1, -1, -1, -1, 65, -1, 67,
- 68, 69, 37, 38, 39, 40, -1, 42, 43, 44,
+ 4, 11, 35, 271, 1, 170, 64, 11, 107, 1,
+ 22, 22, 15, 28, 53, 54, 15, 56, 15, 22,
+ 51, 15, 3, 22, 14, 45, 57, 5, 22, 7,
+ 22, 47, 5, 1, 7, 55, 51, 0, 50, 66,
+ 60, 61, 62, 63, 64, 227, 5, 15, 7, 52,
+ 5, 67, 7, 51, 48, 237, 238, 66, 50, 57,
+ 99, 65, 4, 66, 47, 49, 8, 66, 58, 81,
+ 81, 48, 66, 57, 64, 53, 67, 49, 81, 137,
+ 53, 164, 81, 54, 53, 57, 354, 81, 108, 81,
+ 110, 5, 58, 7, 53, 51, 106, 107, 64, 103,
+ 48, 57, 106, 107, 48, 57, 54, 127, 53, 47,
+ 54, 57, 57, 59, 53, 112, 47, 137, 57, 139,
+ 140, 141, 142, 143, 144, 145, 146, 147, 148, 149,
+ 150, 151, 152, 153, 154, 155, 156, 157, 5, 6,
+ 7, 8, 9, 10, 112, 12, 57, 312, 59, 232,
+ 47, 67, 162, 48, 52, 165, 47, 22, 162, 52,
+ 52, 165, 52, 183, 184, 185, 186, 187, 54, 22,
+ 22, 191, 182, 193, 171, 195, 49, 57, 182, 60,
+ 61, 62, 63, 222, 60, 52, 53, 54, 51, 56,
+ 229, 230, 231, 0, 1, 49, 67, 4, 5, 6,
+ 7, 8, 47, 171, 11, 12, 13, 67, 49, 292,
+ 164, 294, 45, 46, 234, 235, 63, 47, 60, 69,
+ 47, 304, 17, 306, 52, 308, 19, 60, 61, 62,
+ 63, 98, 99, 47, 22, 22, 53, 74, 10, 59,
+ 52, 52, 9, 50, 254, 255, 113, 30, 115, 52,
+ 254, 255, 67, 352, 353, 53, 266, 267, 341, 67,
+ 54, 53, 266, 267, 54, 262, 112, 287, 164, 53,
+ 15, 135, 226, 227, 383, 262, 317, 273, 232, 233,
+ 280, 314, 380, 237, 238, -1, 115, 307, 113, 372,
+ 373, 374, 375, -1, 262, -1, 163, -1, -1, -1,
+ -1, -1, -1, 323, 324, 325, 326, 327, 391, 392,
+ 393, -1, -1, -1, -1, -1, -1, -1, 338, 339,
+ 340, -1, 1, -1, -1, 4, 5, 6, 7, 8,
+ 226, 227, 11, 12, 13, -1, 232, 233, 292, -1,
+ 294, 237, 238, -1, -1, 365, 366, -1, 352, 353,
+ 304, -1, 306, -1, 308, 222, -1, -1, -1, -1,
+ 380, -1, 229, 230, 231, -1, -1, -1, -1, -1,
+ -1, 50, -1, -1, 384, 385, -1, -1, -1, -1,
+ 384, 385, -1, -1, -1, -1, -1, 341, -1, -1,
+ -1, 258, 259, -1, -1, -1, 292, -1, 294, -1,
+ -1, -1, -1, -1, -1, -1, 273, -1, 304, -1,
+ 306, -1, 308, -1, -1, 45, 46, -1, 372, 373,
+ 374, 375, 289, -1, -1, -1, 1, -1, 58, 59,
+ 60, 61, 62, 63, -1, -1, -1, 391, 392, 393,
+ 15, 71, 72, -1, -1, 341, 21, 22, 23, 24,
+ -1, -1, -1, 28, -1, -1, -1, -1, 33, -1,
+ 35, -1, 37, 38, 39, -1, -1, -1, -1, 44,
+ 45, 46, -1, 48, -1, 50, 372, 373, 374, 375,
+ 55, 56, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 66, -1, 1, -1, 391, 392, 393, -1, -1,
+ 75, 76, 77, 78, 79, 80, 81, 15, 45, 46,
+ 47, -1, -1, 21, 22, 23, 24, -1, -1, -1,
+ 28, 58, 59, 60, 61, 62, 63, 35, -1, 37,
+ 38, 39, -1, 70, 71, 72, 44, 45, 46, -1,
+ 48, -1, 50, -1, -1, -1, -1, -1, 56, -1,
+ -1, -1, 60, -1, -1, -1, -1, -1, 66, -1,
+ 1, -1, -1, -1, -1, -1, -1, 75, 76, 77,
+ 78, 79, 80, 81, 15, -1, -1, -1, -1, -1,
+ 21, 22, 23, 24, -1, -1, -1, 28, -1, -1,
+ -1, -1, -1, -1, 35, -1, 37, 38, 39, -1,
+ -1, -1, -1, 44, 45, 46, -1, 48, -1, 50,
+ 51, -1, -1, -1, -1, 56, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 66, -1, 1, -1, -1,
+ -1, -1, -1, -1, 75, 76, 77, 78, 79, 80,
+ 81, 15, -1, -1, -1, -1, -1, 21, 22, 23,
+ 24, -1, -1, -1, 28, -1, -1, -1, -1, -1,
+ -1, 35, -1, 37, 38, 39, -1, -1, -1, -1,
+ 44, 45, 46, -1, 48, 49, 50, -1, -1, -1,
+ -1, -1, 56, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, 66, -1, 1, -1, -1, -1, -1, -1,
+ -1, 75, 76, 77, 78, 79, 80, 81, 15, 16,
+ -1, 18, -1, 20, 21, 22, 23, 24, 25, -1,
+ 27, 28, -1, -1, 31, 1, -1, -1, 4, 5,
+ 6, 7, 8, -1, 1, 11, 12, 13, -1, -1,
+ -1, 48, -1, -1, -1, 52, -1, -1, 15, 16,
+ -1, 18, 22, 20, 21, 22, 23, 24, 25, 66,
+ 27, 28, -1, -1, 31, -1, 73, -1, -1, -1,
+ 40, 41, 42, 43, 81, 45, 46, 47, -1, -1,
+ -1, 48, -1, -1, -1, 52, -1, -1, 58, 59,
+ 60, 61, 62, 63, -1, -1, 1, -1, 68, 66,
+ 70, 71, 72, -1, -1, -1, 73, -1, -1, -1,
+ 15, 16, -1, 18, 81, 20, 21, 22, 23, 24,
+ 25, -1, 27, 28, -1, -1, 31, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 1, -1, -1, -1,
+ -1, -1, -1, 48, -1, -1, -1, 52, -1, -1,
+ 15, 16, -1, 18, -1, 20, 21, 22, 23, 24,
+ 25, 66, 27, 28, -1, -1, 31, -1, 73, -1,
+ -1, -1, -1, -1, -1, -1, 81, -1, -1, -1,
+ -1, -1, 15, 48, -1, -1, -1, 52, 21, 22,
+ 23, 24, -1, -1, -1, 28, -1, -1, -1, -1,
+ 33, 66, 35, -1, 37, 38, 39, -1, 73, -1,
+ -1, 44, 45, 46, -1, 48, 81, 50, -1, -1,
+ -1, -1, 55, 56, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 66, -1, -1, -1, -1, -1, -1,
+ -1, -1, 75, 76, 77, 78, 79, 80, 81, 15,
+ -1, -1, -1, -1, -1, 21, 22, 23, 24, -1,
+ -1, -1, 28, -1, -1, -1, -1, -1, -1, 35,
+ -1, 37, 38, 39, -1, -1, -1, -1, 44, 45,
+ 46, -1, 48, -1, 50, -1, -1, -1, -1, -1,
+ 56, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 66, -1, -1, -1, -1, -1, -1, -1, -1, 75,
+ 76, 77, 78, 79, 80, 81, 15, -1, -1, -1,
+ -1, -1, 21, 22, 23, 24, -1, -1, -1, 28,
+ -1, -1, -1, -1, -1, -1, 35, -1, 37, 38,
+ 39, -1, -1, -1, -1, 44, 45, 46, -1, 48,
+ -1, 50, -1, 15, 16, 17, 18, 56, 20, 21,
+ 22, 23, 24, 25, -1, 27, 28, 66, -1, 31,
+ -1, -1, -1, -1, -1, -1, 75, 76, 77, 78,
+ 79, 80, 81, -1, -1, -1, 48, -1, -1, -1,
+ 52, -1, -1, 15, 16, -1, 18, 19, 20, 21,
+ 22, 23, 24, 25, 66, 27, 28, -1, -1, 31,
+ -1, 73, -1, -1, -1, 15, 16, -1, 18, 81,
+ 20, 21, 22, 23, 24, 25, 48, 27, 28, -1,
+ 52, 31, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 66, -1, -1, -1, 48, -1,
+ -1, 73, 52, 53, -1, 15, 16, -1, 18, 81,
+ 20, 21, 22, 23, 24, 25, 66, 27, 28, -1,
+ -1, 31, -1, 73, -1, -1, -1, -1, -1, -1,
+ -1, 81, -1, -1, -1, -1, -1, -1, 48, -1,
+ -1, -1, 52, -1, -1, 15, 16, -1, 18, 22,
+ 20, 21, 22, 23, 24, 25, 66, 27, 28, -1,
+ -1, 31, -1, 73, 74, -1, -1, 40, 41, 42,
+ 43, 81, 45, 46, 47, -1, -1, -1, 48, -1,
+ -1, -1, 52, -1, -1, 58, 59, 60, 61, 62,
+ 63, -1, -1, 26, -1, 68, 66, 70, 71, 72,
+ -1, -1, -1, 73, -1, -1, -1, 40, 41, 42,
+ 43, 81, 45, 46, 47, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 58, 59, 60, 61, 62,
+ 63, 26, -1, -1, -1, 68, -1, 70, 71, 72,
+ -1, -1, -1, -1, -1, 40, 41, 42, 43, -1,
+ 45, 46, 47, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 58, 59, 60, 61, 62, 63, 26,
+ -1, -1, -1, 68, -1, 70, 71, 72, -1, -1,
+ -1, -1, -1, 40, 41, 42, 43, -1, 45, 46,
+ 47, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 58, 59, 60, 61, 62, 63, 29, -1, -1,
+ -1, 68, -1, 70, 71, 72, -1, -1, 40, 41,
+ 42, 43, -1, 45, 46, 47, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 58, 59, 60, 61,
+ 62, 63, 29, -1, -1, -1, 68, -1, 70, 71,
+ 72, -1, -1, 40, 41, 42, 43, -1, 45, 46,
+ 47, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 58, 59, 60, 61, 62, 63, 30, -1, -1,
+ -1, 68, -1, 70, 71, 72, -1, 40, 41, 42,
+ 43, -1, 45, 46, 47, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 58, 59, 60, 61, 62,
+ 63, -1, 32, -1, -1, 68, -1, 70, 71, 72,
+ 40, 41, 42, 43, -1, 45, 46, 47, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 58, 59,
+ 60, 61, 62, 63, -1, -1, -1, 34, 68, -1,
+ 70, 71, 72, 40, 41, 42, 43, -1, 45, 46,
+ 47, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 58, 59, 60, 61, 62, 63, -1, -1, -1,
+ -1, 68, 36, 70, 71, 72, 40, 41, 42, 43,
+ -1, 45, 46, 47, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 58, 59, 60, 61, 62, 63,
+ -1, -1, -1, -1, 68, -1, 70, 71, 72, 40,
+ 41, 42, 43, -1, 45, 46, 47, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 58, 59, 60,
+ 61, 62, 63, -1, -1, -1, 67, 68, -1, 70,
+ 71, 72, 40, 41, 42, 43, -1, 45, 46, 47,
+ -1, 49, -1, -1, -1, -1, -1, -1, -1, -1,
+ 58, 59, 60, 61, 62, 63, -1, -1, -1, -1,
+ 68, -1, 70, 71, 72, 40, 41, 42, 43, -1,
+ 45, 46, 47, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 58, 59, 60, 61, 62, 63, -1,
+ 65, -1, -1, 68, -1, 70, 71, 72, 40, 41,
+ 42, 43, -1, 45, 46, 47, -1, 49, -1, -1,
+ -1, -1, -1, -1, -1, -1, 58, 59, 60, 61,
+ 62, 63, -1, -1, -1, -1, 68, -1, 70, 71,
+ 72, 40, 41, 42, 43, -1, 45, 46, 47, -1,
+ 49, -1, -1, -1, -1, -1, -1, -1, -1, 58,
+ 59, 60, 61, 62, 63, -1, -1, -1, -1, 68,
+ -1, 70, 71, 72, 40, 41, 42, 43, -1, 45,
+ 46, 47, -1, -1, -1, 51, -1, -1, -1, -1,
+ -1, -1, 58, 59, 60, 61, 62, 63, -1, -1,
+ -1, -1, 68, -1, 70, 71, 72, 40, 41, 42,
+ 43, -1, 45, 46, 47, -1, -1, -1, -1, -1,
+ -1, 54, -1, -1, -1, 58, 59, 60, 61, 62,
+ 63, -1, -1, -1, -1, 68, -1, 70, 71, 72,
+ 40, 41, 42, 43, -1, 45, 46, 47, -1, -1,
+ -1, -1, -1, 53, -1, -1, -1, -1, 58, 59,
+ 60, 61, 62, 63, -1, -1, -1, -1, 68, -1,
+ 70, 71, 72, 40, 41, 42, 43, -1, 45, 46,
+ 47, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 58, 59, 60, 61, 62, 63, -1, -1, -1,
+ -1, 68, -1, 70, 71, 72, 40, 41, 42, -1,
+ -1, 45, 46, 47, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 58, 59, 60, 61, 62, 63,
+ -1, -1, -1, -1, -1, -1, 70, 71, 72, 40,
+ 41, 42, 43, -1, 45, 46, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 58, -1, -1,
+ 61, 62, 63, -1, -1, -1, -1, 68, -1, 70,
+ 71, 72, 40, -1, 42, -1, -1, 45, 46, 47,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 55, 56, 57, 58, 59, 60, -1, -1, -1, 64,
- 65, -1, 67, 68, 69, 37, 38, 39, 40, -1,
- 42, 43, 44, -1, 46, -1, -1, -1, -1, -1,
- -1, -1, -1, 55, 56, 57, 58, 59, 60, -1,
- -1, -1, -1, 65, -1, 67, 68, 69, 37, 38,
- 39, 40, -1, 42, 43, 44, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 55, 56, 57, 58,
- 59, 60, -1, 62, -1, -1, 65, -1, 67, 68,
- 69, 37, 38, 39, 40, -1, 42, 43, 44, -1,
- 46, -1, -1, -1, -1, -1, -1, -1, -1, 55,
- 56, 57, 58, 59, 60, -1, -1, -1, -1, 65,
- -1, 67, 68, 69, 37, 38, 39, 40, -1, 42,
- 43, 44, -1, 46, -1, -1, -1, -1, -1, -1,
- -1, -1, 55, 56, 57, 58, 59, 60, -1, -1,
- -1, -1, 65, -1, 67, 68, 69, 37, 38, 39,
- 40, -1, 42, 43, 44, -1, -1, -1, 48, -1,
- -1, -1, -1, -1, -1, 55, 56, 57, 58, 59,
- 60, -1, -1, -1, -1, 65, -1, 67, 68, 69,
- 37, 38, 39, 40, -1, 42, 43, 44, -1, -1,
- -1, -1, -1, -1, 51, -1, -1, -1, 55, 56,
- 57, 58, 59, 60, -1, -1, -1, -1, 65, -1,
- 67, 68, 69, 37, 38, 39, 40, -1, 42, 43,
- 44, -1, -1, -1, -1, -1, 50, -1, -1, -1,
- -1, 55, 56, 57, 58, 59, 60, -1, -1, -1,
- -1, 65, -1, 67, 68, 69, 37, 38, 39, 40,
- -1, 42, 43, 44, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 55, 56, 57, 58, 59, 60,
- -1, -1, -1, -1, 65, -1, 67, 68, 69, 37,
- 38, 39, -1, -1, 42, 43, 44, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, 55, 56, 57,
- 58, 59, 60, -1, -1, -1, -1, -1, -1, 67,
- 68, 69, 37, -1, 39, -1, -1, 42, 43, 44,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 55, 56, 57, 58, 59, 60, -1, -1, -1, -1,
- -1, -1, 67, 68, 69, 37, 38, 39, 40, -1,
- 42, 43, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, 55, 37, -1, 58, 59, 60, 42,
- 43, 44, -1, 65, -1, 67, 68, 69, -1, -1,
- -1, -1, 55, 56, 57, 58, 59, 60, 42, 43,
- 44, -1, -1, -1, 67, 68, 69, -1, -1, -1,
- -1, 55, 56, 57, 58, 59, 60, 42, 43, -1,
- -1, -1, -1, 67, 68, 69, -1, -1, -1, -1,
- 55, 56, 57, 58, 59, 60, -1, -1, -1, -1,
- -1, -1, -1, 68, 69
+ 58, 59, 60, 61, 62, 63, -1, -1, -1, -1,
+ 40, -1, 70, 71, 72, 45, 46, 47, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 58, 59,
+ 60, 61, 62, 63, -1, -1, -1, -1, -1, -1,
+ 70, 71, 72
};
const unsigned char
Parser::yystos_[] =
{
- 0, 3, 84, 1, 4, 5, 6, 7, 8, 11,
- 12, 47, 85, 86, 87, 88, 94, 98, 99, 100,
- 101, 142, 0, 19, 49, 63, 78, 105, 107, 108,
- 105, 105, 105, 105, 105, 105, 105, 158, 159, 160,
- 161, 86, 18, 20, 21, 25, 32, 34, 35, 36,
- 41, 42, 43, 45, 47, 53, 72, 73, 74, 75,
- 76, 77, 95, 96, 97, 108, 119, 120, 121, 122,
- 123, 124, 125, 126, 127, 128, 129, 130, 131, 134,
- 135, 136, 137, 138, 139, 140, 141, 107, 63, 45,
- 112, 44, 112, 51, 44, 44, 45, 128, 48, 54,
- 47, 105, 109, 110, 110, 110, 128, 110, 128, 128,
- 128, 1, 57, 128, 132, 1, 48, 128, 132, 108,
- 54, 50, 45, 133, 37, 38, 39, 40, 42, 43,
- 44, 55, 56, 57, 58, 59, 60, 64, 65, 67,
- 68, 69, 64, 105, 1, 110, 111, 64, 49, 44,
- 64, 92, 93, 108, 113, 114, 115, 116, 117, 49,
- 49, 128, 85, 158, 159, 51, 44, 19, 19, 26,
- 19, 46, 128, 46, 54, 48, 62, 48, 54, 95,
- 1, 46, 128, 132, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 46, 46, 54, 113, 105, 106, 13,
- 15, 17, 18, 20, 21, 22, 24, 25, 28, 45,
- 49, 70, 135, 136, 143, 145, 146, 147, 150, 151,
- 152, 153, 154, 155, 156, 157, 113, 57, 64, 55,
- 61, 88, 89, 5, 7, 98, 102, 103, 104, 142,
- 48, 113, 128, 128, 128, 128, 128, 46, 128, 128,
- 128, 46, 46, 110, 44, 50, 54, 1, 143, 144,
- 1, 144, 110, 110, 110, 143, 135, 136, 128, 128,
- 1, 144, 1, 144, 66, 44, 113, 113, 93, 113,
- 118, 128, 50, 54, 105, 105, 50, 54, 109, 19,
- 31, 23, 27, 33, 133, 46, 48, 128, 105, 14,
- 14, 143, 16, 16, 44, 19, 19, 26, 29, 50,
- 50, 71, 71, 128, 143, 10, 91, 64, 54, 56,
- 88, 51, 51, 102, 128, 128, 128, 128, 128, 128,
- 128, 128, 143, 49, 49, 9, 90, 113, 113, 93,
- 93, 19, 23, 23, 27, 1, 30, 52, 128, 148,
- 149, 128, 49, 56, 64, 64, 143, 143, 143, 143,
- 50, 51, 51, 51, 149, 50, 50, 97, 113, 113,
- 143, 143, 143, 50
+ 0, 3, 87, 1, 4, 5, 6, 7, 8, 11,
+ 12, 13, 50, 88, 89, 90, 91, 97, 101, 102,
+ 103, 104, 107, 148, 0, 15, 22, 52, 66, 81,
+ 111, 113, 114, 111, 111, 111, 111, 111, 111, 114,
+ 119, 120, 121, 122, 123, 111, 164, 165, 166, 167,
+ 89, 66, 21, 23, 24, 28, 35, 37, 38, 39,
+ 44, 45, 46, 48, 50, 56, 75, 76, 77, 78,
+ 79, 80, 98, 99, 100, 114, 125, 126, 127, 128,
+ 129, 130, 131, 132, 133, 134, 135, 136, 137, 140,
+ 141, 142, 143, 144, 145, 146, 147, 113, 66, 48,
+ 118, 47, 118, 54, 47, 47, 14, 58, 64, 47,
+ 48, 134, 51, 57, 113, 50, 111, 115, 116, 116,
+ 116, 134, 116, 134, 134, 134, 1, 60, 134, 138,
+ 1, 51, 134, 138, 114, 57, 53, 48, 139, 40,
+ 41, 42, 43, 45, 46, 47, 58, 59, 60, 61,
+ 62, 63, 67, 68, 70, 71, 72, 67, 111, 1,
+ 116, 117, 67, 52, 47, 67, 95, 96, 114, 119,
+ 52, 52, 119, 96, 119, 124, 134, 52, 134, 88,
+ 164, 165, 54, 47, 22, 22, 29, 22, 49, 134,
+ 49, 57, 51, 65, 51, 57, 98, 1, 49, 134,
+ 138, 134, 134, 134, 134, 134, 134, 134, 134, 134,
+ 134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
+ 49, 49, 57, 119, 111, 112, 16, 18, 20, 21,
+ 23, 24, 25, 27, 28, 31, 48, 52, 73, 141,
+ 142, 149, 151, 152, 153, 156, 157, 158, 159, 160,
+ 161, 162, 163, 119, 60, 67, 91, 92, 5, 7,
+ 101, 105, 106, 110, 148, 47, 67, 57, 59, 101,
+ 108, 109, 148, 51, 119, 134, 134, 134, 134, 134,
+ 49, 134, 134, 134, 49, 49, 116, 47, 53, 57,
+ 1, 149, 150, 1, 150, 116, 116, 116, 149, 141,
+ 142, 134, 134, 1, 150, 1, 150, 69, 47, 119,
+ 119, 53, 57, 111, 111, 53, 105, 52, 119, 119,
+ 53, 108, 115, 22, 34, 26, 30, 36, 139, 49,
+ 51, 134, 111, 17, 17, 149, 19, 19, 47, 22,
+ 22, 29, 32, 53, 53, 74, 74, 134, 149, 10,
+ 94, 91, 54, 54, 109, 59, 134, 134, 134, 134,
+ 134, 134, 134, 134, 149, 52, 52, 9, 93, 96,
+ 96, 53, 22, 26, 26, 30, 1, 33, 55, 134,
+ 154, 155, 134, 52, 67, 67, 149, 149, 149, 149,
+ 53, 54, 54, 54, 155, 53, 53, 100, 119, 119,
+ 149, 149, 149, 53
};
const unsigned char
Parser::yyr1_[] =
{
- 0, 83, 84, 85, 85, 85, 85, 85, 85, 85,
- 86, 86, 87, 87, 88, 88, 89, 89, 90, 90,
- 91, 91, 92, 92, 93, 93, 94, 94, 95, 95,
- 95, 96, 96, 97, 97, 98, 99, 100, 101, 102,
- 102, 102, 103, 103, 104, 104, 105, 105, 106, 106,
- 107, 107, 108, 108, 109, 109, 110, 110, 111, 111,
- 112, 112, 112, 113, 113, 113, 113, 114, 115, 116,
- 117, 118, 118, 119, 119, 119, 119, 119, 119, 119,
- 119, 120, 121, 121, 122, 123, 123, 124, 125, 126,
- 127, 128, 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 129, 129, 129, 129, 129, 129, 129, 129,
- 129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
- 129, 129, 129, 129, 130, 131, 131, 131, 132, 132,
- 133, 133, 133, 134, 135, 135, 136, 137, 138, 139,
- 140, 141, 142, 142, 143, 143, 143, 143, 143, 143,
- 143, 143, 143, 143, 143, 144, 144, 145, 146, 146,
- 147, 147, 148, 148, 148, 149, 149, 150, 151, 152,
- 153, 154, 154, 154, 154, 155, 155, 155, 155, 156,
- 157, 157, 157, 157, 158, 158, 159, 159, 160, 161
+ 0, 86, 87, 88, 88, 88, 88, 88, 88, 88,
+ 88, 89, 89, 90, 90, 91, 91, 92, 92, 93,
+ 93, 94, 94, 95, 95, 96, 96, 97, 97, 98,
+ 98, 98, 99, 99, 100, 100, 101, 102, 103, 104,
+ 105, 105, 105, 106, 106, 107, 107, 108, 108, 109,
+ 109, 110, 110, 111, 111, 112, 112, 113, 113, 114,
+ 114, 114, 115, 115, 116, 116, 117, 117, 118, 118,
+ 118, 119, 119, 119, 119, 120, 121, 122, 123, 124,
+ 124, 125, 125, 125, 125, 125, 125, 125, 125, 126,
+ 127, 127, 128, 129, 129, 130, 131, 132, 133, 134,
+ 134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
+ 135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
+ 135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
+ 135, 135, 136, 137, 137, 137, 138, 138, 139, 139,
+ 139, 140, 141, 141, 142, 143, 144, 145, 146, 147,
+ 148, 148, 149, 149, 149, 149, 149, 149, 149, 149,
+ 149, 149, 149, 150, 150, 151, 152, 152, 153, 153,
+ 154, 154, 154, 155, 155, 156, 157, 158, 159, 160,
+ 160, 160, 160, 161, 161, 161, 161, 162, 163, 163,
+ 163, 163, 164, 164, 165, 165, 166, 167
};
const unsigned char
Parser::yyr2_[] =
{
0, 2, 2, 1, 1, 1, 1, 1, 1, 1,
- 4, 1, 2, 1, 8, 1, 3, 1, 4, 0,
- 4, 0, 3, 1, 1, 0, 2, 4, 1, 3,
- 3, 3, 1, 1, 0, 7, 6, 6, 6, 1,
- 1, 1, 3, 1, 6, 6, 1, 1, 3, 1,
- 3, 1, 1, 2, 3, 1, 4, 1, 3, 1,
- 3, 3, 0, 1, 1, 1, 1, 1, 4, 6,
- 3, 3, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 4, 1, 2, 1, 8, 1, 3, 1, 4,
+ 0, 4, 0, 3, 1, 1, 0, 2, 4, 1,
+ 3, 3, 3, 1, 1, 0, 7, 6, 6, 6,
+ 1, 1, 1, 2, 1, 8, 6, 1, 1, 2,
+ 1, 6, 6, 1, 1, 3, 1, 3, 1, 1,
+ 2, 3, 3, 1, 4, 1, 3, 1, 3, 3,
+ 0, 1, 1, 1, 1, 1, 4, 6, 3, 3,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 2, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 2, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 3, 3, 2, 2, 3, 3, 3, 3,
+ 3, 3, 2, 2, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 2, 5, 2, 3, 3, 3, 1,
- 3, 3, 2, 5, 1, 2, 5, 6, 6, 6,
- 6, 6, 5, 7, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 2, 1, 1, 4, 6,
- 6, 6, 3, 3, 3, 2, 1, 6, 6, 6,
- 2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 2, 1, 2, 1, 1, 1, 3, 1, 1, 2
+ 3, 2, 5, 2, 3, 3, 3, 1, 3, 3,
+ 2, 5, 1, 2, 5, 6, 6, 6, 6, 6,
+ 5, 7, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 2, 1, 1, 4, 6, 6, 6,
+ 3, 3, 3, 2, 1, 6, 6, 6, 2, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 2, 1,
+ 2, 1, 1, 1, 3, 1, 1, 2
};
@@ -3919,18 +4035,19 @@ namespace libcasm_fe {
{
"\"end of file\"", "error", "$undefined", "\"CASM\"", "\"init\"",
"\"derived\"", "\"enum\"", "\"rule\"", "\"function\"", "\"initially\"",
- "\"defined\"", "\"structure\"", "\"feature\"", "\"seq\"", "\"endseq\"",
- "\"par\"", "\"endpar\"", "\"skip\"", "\"let\"", "\"in\"", "\"forall\"",
- "\"choose\"", "\"iterate\"", "\"do\"", "\"call\"", "\"if\"", "\"then\"",
- "\"else\"", "\"case\"", "\"of\"", "\"default\"", "\"holds\"",
- "\"exists\"", "\"with\"", "\"undef\"", "\"false\"", "\"true\"",
- "\"and\"", "\"or\"", "\"xor\"", "\"implies\"", "\"not\"", "\"+\"",
- "\"-\"", "\"=\"", "\"(\"", "\")\"", "\"[\"", "\"]\"", "\"{\"", "\"}\"",
- "\":\"", "\"_\"", "\"@\"", "\",\"", "\"<\"", "\">\"", "\"*\"", "\"/\"",
- "\"%\"", "\"^\"", "\"'\"", "\"..\"", "\".\"", "\"->\"", "\"=>\"",
- "\":=\"", "\"!=\"", "\"<=\"", "\">=\"", "\"{|\"", "\"|}\"", "\"binary\"",
- "\"hexadecimal\"", "\"integer\"", "\"rational\"", "\"floating\"",
- "\"string\"", "\"identifier\"", "ABSOLUTE_PATH", "UPLUS", "UMINUS",
+ "\"defined\"", "\"structure\"", "\"feature\"", "\"implements\"",
+ "\"for\"", "\"this\"", "\"seq\"", "\"endseq\"", "\"par\"", "\"endpar\"",
+ "\"skip\"", "\"let\"", "\"in\"", "\"forall\"", "\"choose\"",
+ "\"iterate\"", "\"do\"", "\"call\"", "\"if\"", "\"then\"", "\"else\"",
+ "\"case\"", "\"of\"", "\"default\"", "\"holds\"", "\"exists\"",
+ "\"with\"", "\"undef\"", "\"false\"", "\"true\"", "\"and\"", "\"or\"",
+ "\"xor\"", "\"implies\"", "\"not\"", "\"+\"", "\"-\"", "\"=\"", "\"(\"",
+ "\")\"", "\"[\"", "\"]\"", "\"{\"", "\"}\"", "\":\"", "\"_\"", "\"@\"",
+ "\",\"", "\"<\"", "\">\"", "\"*\"", "\"/\"", "\"%\"", "\"^\"", "\"'\"",
+ "\"..\"", "\".\"", "\"->\"", "\"=>\"", "\":=\"", "\"!=\"", "\"<=\"",
+ "\">=\"", "\"{|\"", "\"|}\"", "\"binary\"", "\"hexadecimal\"",
+ "\"integer\"", "\"rational\"", "\"floating\"", "\"string\"",
+ "\"identifier\"", "ABSOLUTE_PATH", "UPLUS", "UMINUS",
"CALL_WITHOUT_ARGS", "$accept", "Specification", "Definition",
"AttributedDefinition", "Definitions", "FunctionDefinition",
"FunctionDefinitions", "MaybeInitially", "MaybeDefined",
@@ -3939,15 +4056,16 @@ namespace libcasm_fe {
"MaybeInitializers", "DerivedDefinition", "EnumerationDefinition",
"StructureDefinition", "FeatureDefinition",
"FeatureDeclarationOrDefinition", "FeatureDeclarationsAndDefinitions",
- "DeclarationDefinition", "Identifier", "Identifiers",
- "DotSeparatedIdentifiers", "IdentifierPath", "Variable",
- "AttributedVariable", "Parameters", "MaybeParameters", "Type",
- "BasicType", "ComposedType", "RelationType", "FixedSizedType", "Types",
- "Atom", "Undefined", "Boolean", "String", "BitNumber", "IntegerNumber",
- "FloatingNumber", "RationalNumber", "Reference", "Term", "Expression",
- "Range", "List", "Terms", "Arguments", "TwoOrMoreArguments",
- "DirectCallExpression", "IndirectCallExpression", "LetExpression",
- "ConditionalExpression", "ChooseExpression",
+ "ImplementationDefinition", "ImplementationDefinitionDefinition",
+ "ImplementationDefinitionDefinitions", "DeclarationDefinition",
+ "Identifier", "Identifiers", "DotSeparatedIdentifiers", "IdentifierPath",
+ "Variable", "AttributedVariable", "Parameters", "MaybeParameters",
+ "Type", "BasicType", "ComposedType", "RelationType", "FixedSizedType",
+ "Types", "Atom", "Undefined", "Boolean", "String", "BitNumber",
+ "IntegerNumber", "FloatingNumber", "RationalNumber", "Reference", "Term",
+ "Expression", "Range", "List", "Terms", "Arguments",
+ "TwoOrMoreArguments", "DirectCallExpression", "IndirectCallExpression",
+ "LetExpression", "ConditionalExpression", "ChooseExpression",
"UniversalQuantifierExpression", "ExistentialQuantifierExpression",
"RuleDefinition", "Rule", "Rules", "SkipRule", "ConditionalRule",
"CaseRule", "CaseLabel", "CaseLabels", "LetRule", "ForallRule",
@@ -3960,25 +4078,26 @@ namespace libcasm_fe {
const unsigned short int
Parser::yyrline_[] =
{
- 0, 359, 359, 371, 375, 379, 383, 387, 391, 395,
- 403, 409, 417, 423, 433, 449, 457, 463, 473, 477,
- 485, 489, 497, 503, 513, 517, 525, 548, 566, 574,
- 584, 595, 601, 611, 615, 623, 631, 639, 647, 655,
- 659, 663, 671, 677, 687, 693, 703, 707, 715, 721,
- 731, 737, 747, 751, 759, 763, 772, 778, 786, 792,
- 802, 806, 810, 818, 822, 826, 830, 838, 846, 854,
- 862, 870, 876, 886, 890, 894, 898, 902, 906, 910,
- 914, 922, 930, 935, 944, 960, 972, 988, 1004, 1020,
- 1036, 1044, 1048, 1052, 1056, 1060, 1064, 1068, 1072, 1076,
- 1080, 1084, 1092, 1096, 1100, 1104, 1108, 1112, 1116, 1120,
- 1124, 1128, 1132, 1136, 1140, 1144, 1148, 1152, 1156, 1160,
- 1164, 1168, 1172, 1176, 1184, 1192, 1197, 1201, 1209, 1215,
- 1225, 1229, 1233, 1242, 1252, 1257, 1265, 1273, 1281, 1289,
- 1297, 1305, 1313, 1318, 1327, 1331, 1335, 1339, 1343, 1347,
- 1351, 1355, 1359, 1363, 1367, 1375, 1381, 1391, 1399, 1403,
- 1411, 1415, 1423, 1427, 1431, 1439, 1445, 1455, 1463, 1471,
- 1479, 1487, 1491, 1495, 1500, 1509, 1513, 1517, 1522, 1531,
- 1541, 1547, 1554, 1560, 1571, 1575, 1583, 1589, 1599, 1607
+ 0, 365, 365, 377, 381, 385, 389, 393, 397, 401,
+ 405, 413, 419, 427, 433, 443, 459, 467, 473, 483,
+ 487, 495, 499, 507, 513, 523, 527, 535, 558, 576,
+ 584, 594, 605, 611, 621, 625, 633, 641, 649, 657,
+ 665, 669, 673, 681, 687, 697, 701, 711, 715, 723,
+ 729, 739, 745, 755, 759, 767, 773, 783, 789, 799,
+ 803, 807, 815, 819, 828, 834, 842, 848, 858, 862,
+ 866, 874, 878, 882, 886, 894, 902, 910, 918, 926,
+ 932, 942, 946, 950, 954, 958, 962, 966, 970, 978,
+ 986, 991, 1000, 1016, 1028, 1044, 1060, 1076, 1092, 1100,
+ 1104, 1108, 1112, 1116, 1120, 1124, 1128, 1132, 1136, 1140,
+ 1148, 1152, 1156, 1160, 1164, 1168, 1172, 1176, 1180, 1184,
+ 1188, 1192, 1196, 1200, 1204, 1208, 1212, 1216, 1220, 1224,
+ 1228, 1232, 1240, 1248, 1253, 1257, 1265, 1271, 1281, 1285,
+ 1289, 1298, 1308, 1313, 1321, 1329, 1337, 1345, 1353, 1361,
+ 1369, 1374, 1383, 1387, 1391, 1395, 1399, 1403, 1407, 1411,
+ 1415, 1419, 1423, 1431, 1437, 1447, 1455, 1459, 1467, 1471,
+ 1479, 1483, 1487, 1495, 1501, 1511, 1519, 1527, 1535, 1543,
+ 1547, 1551, 1556, 1565, 1569, 1573, 1578, 1587, 1597, 1603,
+ 1610, 1616, 1627, 1631, 1639, 1645, 1655, 1663
};
// Print the state stack on the debug stream.
@@ -4013,8 +4132,8 @@ namespace libcasm_fe {
#line 31 "../../obj/src/GrammarParser.yy" // lalr1.cc:1167
} // libcasm_fe
-#line 4017 "GrammarParser.cpp" // lalr1.cc:1167
-#line 1613 "../../obj/src/GrammarParser.yy" // lalr1.cc:1168
+#line 4136 "GrammarParser.cpp" // lalr1.cc:1167
+#line 1669 "../../obj/src/GrammarParser.yy" // lalr1.cc:1168
void Parser::error( const SourceLocation& location, const std::string& message )
diff --git a/src/various/GrammarParser.output b/src/various/GrammarParser.output
index 73b69d2e6..c33147637 100644
--- a/src/various/GrammarParser.output
+++ b/src/various/GrammarParser.output
@@ -10,517 +10,538 @@ Grammar
5 | EnumerationDefinition
6 | StructureDefinition
7 | FeatureDefinition
- 8 | error
+ 8 | ImplementationDefinition
+ 9 | error
- 9 AttributedDefinition: "[" Attributes "]" Definition
- 10 | Definition
+ 10 AttributedDefinition: "[" Attributes "]" Definition
+ 11 | Definition
- 11 Definitions: Definitions AttributedDefinition
- 12 | AttributedDefinition
+ 12 Definitions: Definitions AttributedDefinition
+ 13 | AttributedDefinition
- 13 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially
- 14 | ProgramFunctionDefinition
+ 14 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially
+ 15 | ProgramFunctionDefinition
- 15 FunctionDefinitions: FunctionDefinitions "," FunctionDefinition
- 16 | FunctionDefinition
+ 16 FunctionDefinitions: FunctionDefinitions "," FunctionDefinition
+ 17 | FunctionDefinition
- 17 MaybeInitially: "initially" "{" MaybeInitializers "}"
- 18 | %empty
+ 18 MaybeInitially: "initially" "{" MaybeInitializers "}"
+ 19 | %empty
- 19 MaybeDefined: "defined" "{" Term "}"
- 20 | %empty
+ 20 MaybeDefined: "defined" "{" Term "}"
+ 21 | %empty
- 21 FunctionParameters: FunctionParameters "*" Type
- 22 | Type
+ 22 FunctionParameters: FunctionParameters "*" Type
+ 23 | Type
- 23 MaybeFunctionParameters: FunctionParameters
- 24 | %empty
+ 24 MaybeFunctionParameters: FunctionParameters
+ 25 | %empty
- 25 ProgramFunctionDefinition: "init" IdentifierPath
- 26 | "init" "{" MaybeInitializers "}"
+ 26 ProgramFunctionDefinition: "init" IdentifierPath
+ 27 | "init" "{" MaybeInitializers "}"
- 27 Initializer: Term
- 28 | Term "->" Term
- 29 | TwoOrMoreArguments "->" Term
+ 28 Initializer: Term
+ 29 | Term "->" Term
+ 30 | TwoOrMoreArguments "->" Term
- 30 Initializers: Initializers "," Initializer
- 31 | Initializer
+ 31 Initializers: Initializers "," Initializer
+ 32 | Initializer
- 32 MaybeInitializers: Initializers
- 33 | %empty
+ 33 MaybeInitializers: Initializers
+ 34 | %empty
- 34 DerivedDefinition: "derived" Identifier MaybeParameters "->" Type "=" Term
+ 35 DerivedDefinition: "derived" Identifier MaybeParameters "->" Type "=" Term
- 35 EnumerationDefinition: "enum" Identifier "=" "{" Identifiers "}"
+ 36 EnumerationDefinition: "enum" Identifier "=" "{" Identifiers "}"
- 36 StructureDefinition: "structure" Identifier "=" "{" FunctionDefinitions "}"
+ 37 StructureDefinition: "structure" Identifier "=" "{" FunctionDefinitions "}"
- 37 FeatureDefinition: "feature" Identifier "=" "{" FeatureDeclarationsAndDefinitions "}"
+ 38 FeatureDefinition: "feature" Identifier "=" "{" FeatureDeclarationsAndDefinitions "}"
- 38 FeatureDeclarationOrDefinition: DeclarationDefinition
- 39 | DerivedDefinition
- 40 | RuleDefinition
+ 39 FeatureDeclarationOrDefinition: DeclarationDefinition
+ 40 | DerivedDefinition
+ 41 | RuleDefinition
- 41 FeatureDeclarationsAndDefinitions: FeatureDeclarationsAndDefinitions "," FeatureDeclarationOrDefinition
- 42 | FeatureDeclarationOrDefinition
+ 42 FeatureDeclarationsAndDefinitions: FeatureDeclarationsAndDefinitions FeatureDeclarationOrDefinition
+ 43 | FeatureDeclarationOrDefinition
- 43 DeclarationDefinition: "derived" Identifier ":" MaybeFunctionParameters "->" Type
- 44 | "rule" Identifier ":" MaybeFunctionParameters "->" Type
+ 44 ImplementationDefinition: "implements" IdentifierPath "for" Type "=" "{" ImplementationDefinitionDefinitions "}"
+ 45 | "implements" Type "=" "{" ImplementationDefinitionDefinitions "}"
- 45 Identifier: "identifier"
- 46 | "in"
+ 46 ImplementationDefinitionDefinition: DerivedDefinition
+ 47 | RuleDefinition
- 47 Identifiers: Identifiers "," Identifier
- 48 | Identifier
+ 48 ImplementationDefinitionDefinitions: ImplementationDefinitionDefinitions ImplementationDefinitionDefinition
+ 49 | ImplementationDefinitionDefinition
- 49 DotSeparatedIdentifiers: DotSeparatedIdentifiers "." Identifier
- 50 | Identifier
+ 50 DeclarationDefinition: "derived" Identifier ":" MaybeFunctionParameters "->" Type
+ 51 | "rule" Identifier ":" MaybeFunctionParameters "->" Type
- 51 IdentifierPath: DotSeparatedIdentifiers
- 52 | "." DotSeparatedIdentifiers
+ 52 Identifier: "identifier"
+ 53 | "in"
- 53 Variable: Identifier ":" Type
- 54 | Identifier
+ 54 Identifiers: Identifiers "," Identifier
+ 55 | Identifier
- 55 AttributedVariable: "[" Attributes "]" Variable
- 56 | Variable
+ 56 DotSeparatedIdentifiers: DotSeparatedIdentifiers "." Identifier
+ 57 | Identifier
- 57 Parameters: Parameters "," AttributedVariable
- 58 | AttributedVariable
+ 58 IdentifierPath: DotSeparatedIdentifiers
+ 59 | "." DotSeparatedIdentifiers
+ 60 | "this" "." DotSeparatedIdentifiers
- 59 MaybeParameters: "(" Parameters ")"
- 60 | "(" error ")"
- 61 | %empty
+ 61 Variable: Identifier ":" Type
+ 62 | Identifier
- 62 Type: BasicType
- 63 | ComposedType
- 64 | RelationType
- 65 | FixedSizedType
+ 63 AttributedVariable: "[" Attributes "]" Variable
+ 64 | Variable
- 66 BasicType: IdentifierPath
+ 65 Parameters: Parameters "," AttributedVariable
+ 66 | AttributedVariable
- 67 ComposedType: IdentifierPath "<" Types ">"
+ 67 MaybeParameters: "(" Parameters ")"
+ 68 | "(" error ")"
+ 69 | %empty
- 68 RelationType: IdentifierPath "<" MaybeFunctionParameters "->" Type ">"
+ 70 Type: BasicType
+ 71 | ComposedType
+ 72 | RelationType
+ 73 | FixedSizedType
- 69 FixedSizedType: IdentifierPath "'" Term
+ 74 BasicType: IdentifierPath
- 70 Types: Types "," Type
- 71 | Type
+ 75 ComposedType: IdentifierPath "<" Types ">"
- 72 Atom: Reference
- 73 | BitNumber
- 74 | IntegerNumber
- 75 | FloatingNumber
- 76 | RationalNumber
- 77 | String
- 78 | Undefined
- 79 | Boolean
+ 76 RelationType: IdentifierPath "<" MaybeFunctionParameters "->" Type ">"
- 80 Undefined: "undef"
+ 77 FixedSizedType: IdentifierPath "'" Term
- 81 Boolean: "true"
- 82 | "false"
+ 78 Types: Types "," Type
+ 79 | Type
- 83 String: "string"
+ 80 Atom: Reference
+ 81 | BitNumber
+ 82 | IntegerNumber
+ 83 | FloatingNumber
+ 84 | RationalNumber
+ 85 | String
+ 86 | Undefined
+ 87 | Boolean
- 84 BitNumber: "binary"
- 85 | "hexadecimal"
+ 88 Undefined: "undef"
- 86 IntegerNumber: "integer"
+ 89 Boolean: "true"
+ 90 | "false"
- 87 FloatingNumber: "floating"
+ 91 String: "string"
- 88 RationalNumber: "rational"
+ 92 BitNumber: "binary"
+ 93 | "hexadecimal"
- 89 Reference: "@" IdentifierPath
+ 94 IntegerNumber: "integer"
- 90 Term: DirectCallExpression
- 91 | IndirectCallExpression
- 92 | LetExpression
- 93 | ConditionalExpression
- 94 | ChooseExpression
- 95 | UniversalQuantifierExpression
- 96 | ExistentialQuantifierExpression
- 97 | Expression
- 98 | List
- 99 | Range
- 100 | Atom
+ 95 FloatingNumber: "floating"
- 101 Expression: "(" Term ")"
- 102 | "(" error ")"
- 103 | "+" Term
- 104 | "-" Term
- 105 | Term "+" Term
- 106 | Term "-" Term
- 107 | Term "*" Term
- 108 | Term "/" Term
- 109 | Term "%" Term
- 110 | Term "^" Term
- 111 | Term "!=" Term
- 112 | Term "=" Term
- 113 | Term "<" Term
- 114 | Term ">" Term
- 115 | Term "<=" Term
- 116 | Term ">=" Term
- 117 | Term "or" Term
- 118 | Term "xor" Term
- 119 | Term "and" Term
- 120 | Term "=>" Term
- 121 | Term "implies" Term
- 122 | "not" Term
+ 96 RationalNumber: "rational"
- 123 Range: "[" Term ".." Term "]"
+ 97 Reference: "@" IdentifierPath
- 124 List: "[" "]"
- 125 | "[" Terms "]"
- 126 | "[" error "]"
+ 98 Term: DirectCallExpression
+ 99 | IndirectCallExpression
+ 100 | LetExpression
+ 101 | ConditionalExpression
+ 102 | ChooseExpression
+ 103 | UniversalQuantifierExpression
+ 104 | ExistentialQuantifierExpression
+ 105 | Expression
+ 106 | List
+ 107 | Range
+ 108 | Atom
- 127 Terms: Terms "," Term
- 128 | Term
+ 109 Expression: "(" Term ")"
+ 110 | "(" error ")"
+ 111 | "+" Term
+ 112 | "-" Term
+ 113 | Term "+" Term
+ 114 | Term "-" Term
+ 115 | Term "*" Term
+ 116 | Term "/" Term
+ 117 | Term "%" Term
+ 118 | Term "^" Term
+ 119 | Term "!=" Term
+ 120 | Term "=" Term
+ 121 | Term "<" Term
+ 122 | Term ">" Term
+ 123 | Term "<=" Term
+ 124 | Term ">=" Term
+ 125 | Term "or" Term
+ 126 | Term "xor" Term
+ 127 | Term "and" Term
+ 128 | Term "=>" Term
+ 129 | Term "implies" Term
+ 130 | "not" Term
- 129 Arguments: "(" Terms ")"
- 130 | "(" error ")"
- 131 | "(" ")"
+ 131 Range: "[" Term ".." Term "]"
- 132 TwoOrMoreArguments: "(" Terms "," Term ")"
+ 132 List: "[" "]"
+ 133 | "[" Terms "]"
+ 134 | "[" error "]"
- 133 DirectCallExpression: IdentifierPath
- 134 | IdentifierPath Arguments
+ 135 Terms: Terms "," Term
+ 136 | Term
- 135 IndirectCallExpression: "(" "*" Term ")" Arguments
+ 137 Arguments: "(" Terms ")"
+ 138 | "(" error ")"
+ 139 | "(" ")"
- 136 LetExpression: "let" AttributedVariable "=" Term "in" Term
+ 140 TwoOrMoreArguments: "(" Terms "," Term ")"
- 137 ConditionalExpression: "if" Term "then" Term "else" Term
+ 141 DirectCallExpression: IdentifierPath
+ 142 | IdentifierPath Arguments
- 138 ChooseExpression: "choose" AttributedVariable "in" Term "do" Term
+ 143 IndirectCallExpression: "(" "*" Term ")" Arguments
- 139 UniversalQuantifierExpression: "forall" AttributedVariable "in" Term "holds" Term
+ 144 LetExpression: "let" AttributedVariable "=" Term "in" Term
- 140 ExistentialQuantifierExpression: "exists" AttributedVariable "in" Term "with" Term
+ 145 ConditionalExpression: "if" Term "then" Term "else" Term
- 141 RuleDefinition: "rule" Identifier MaybeParameters "=" Rule
- 142 | "rule" Identifier MaybeParameters "->" Type "=" Rule
+ 146 ChooseExpression: "choose" AttributedVariable "in" Term "do" Term
- 143 Rule: SkipRule
- 144 | ConditionalRule
- 145 | CaseRule
- 146 | LetRule
- 147 | ForallRule
- 148 | ChooseRule
- 149 | IterateRule
- 150 | BlockRule
- 151 | SequenceRule
- 152 | UpdateRule
- 153 | CallRule
+ 147 UniversalQuantifierExpression: "forall" AttributedVariable "in" Term "holds" Term
- 154 Rules: Rules Rule
- 155 | Rule
+ 148 ExistentialQuantifierExpression: "exists" AttributedVariable "in" Term "with" Term
- 156 SkipRule: "skip"
+ 149 RuleDefinition: "rule" Identifier MaybeParameters "=" Rule
+ 150 | "rule" Identifier MaybeParameters "->" Type "=" Rule
- 157 ConditionalRule: "if" Term "then" Rule
- 158 | "if" Term "then" Rule "else" Rule
+ 151 Rule: SkipRule
+ 152 | ConditionalRule
+ 153 | CaseRule
+ 154 | LetRule
+ 155 | ForallRule
+ 156 | ChooseRule
+ 157 | IterateRule
+ 158 | BlockRule
+ 159 | SequenceRule
+ 160 | UpdateRule
+ 161 | CallRule
- 159 CaseRule: "case" Term "of" "{" CaseLabels "}"
- 160 | "case" Term "of" "{" error "}"
+ 162 Rules: Rules Rule
+ 163 | Rule
- 161 CaseLabel: "default" ":" Rule
- 162 | "_" ":" Rule
- 163 | Term ":" Rule
+ 164 SkipRule: "skip"
- 164 CaseLabels: CaseLabel CaseLabels
- 165 | CaseLabel
+ 165 ConditionalRule: "if" Term "then" Rule
+ 166 | "if" Term "then" Rule "else" Rule
- 166 LetRule: "let" AttributedVariable "=" Term "in" Rule
+ 167 CaseRule: "case" Term "of" "{" CaseLabels "}"
+ 168 | "case" Term "of" "{" error "}"
- 167 ForallRule: "forall" AttributedVariable "in" Term "do" Rule
+ 169 CaseLabel: "default" ":" Rule
+ 170 | "_" ":" Rule
+ 171 | Term ":" Rule
- 168 ChooseRule: "choose" AttributedVariable "in" Term "do" Rule
+ 172 CaseLabels: CaseLabel CaseLabels
+ 173 | CaseLabel
- 169 IterateRule: "iterate" Rule
+ 174 LetRule: "let" AttributedVariable "=" Term "in" Rule
- 170 BlockRule: "{" Rules "}"
- 171 | "par" Rules "endpar"
- 172 | "{" error "}"
- 173 | "par" error "endpar"
+ 175 ForallRule: "forall" AttributedVariable "in" Term "do" Rule
- 174 SequenceRule: "{|" Rules "|}"
- 175 | "seq" Rules "endseq"
- 176 | "{|" error "|}"
- 177 | "seq" error "endseq"
+ 176 ChooseRule: "choose" AttributedVariable "in" Term "do" Rule
- 178 UpdateRule: DirectCallExpression ":=" Term
+ 177 IterateRule: "iterate" Rule
- 179 CallRule: "call" DirectCallExpression
- 180 | DirectCallExpression
- 181 | "call" IndirectCallExpression
- 182 | IndirectCallExpression
+ 178 BlockRule: "{" Rules "}"
+ 179 | "par" Rules "endpar"
+ 180 | "{" error "}"
+ 181 | "par" error "endpar"
- 183 Attribute: BasicAttribute
- 184 | ExpressionAttribute
+ 182 SequenceRule: "{|" Rules "|}"
+ 183 | "seq" Rules "endseq"
+ 184 | "{|" error "|}"
+ 185 | "seq" error "endseq"
- 185 Attributes: Attributes "," Attribute
- 186 | Attribute
+ 186 UpdateRule: DirectCallExpression ":=" Term
- 187 BasicAttribute: Identifier
+ 187 CallRule: "call" DirectCallExpression
+ 188 | DirectCallExpression
+ 189 | "call" IndirectCallExpression
+ 190 | IndirectCallExpression
- 188 ExpressionAttribute: Identifier Term
+ 191 Attribute: BasicAttribute
+ 192 | ExpressionAttribute
+
+ 193 Attributes: Attributes "," Attribute
+ 194 | Attribute
+
+ 195 BasicAttribute: Identifier
+
+ 196 ExpressionAttribute: Identifier Term
Terminals, with rules where they appear
"end of file" (0) 0
-error (256) 8 60 102 126 130 160 172 173 176 177
+error (256) 9 68 110 134 138 168 180 181 184 185
"CASM" (258) 1
-"init" (259) 25 26
-"derived" (260) 34 43
-"enum" (261) 35
-"rule" (262) 44 141 142
-"function" (263) 13
-"initially" (264) 17
-"defined" (265) 19
-"structure" (266) 36
-"feature" (267) 37
-"seq" (268) 175 177
-"endseq" (269) 175 177
-"par" (270) 171 173
-"endpar" (271) 171 173
-"skip" (272) 156
-"let" (273) 136 166
-"in" (274) 46 136 138 139 140 166 167 168
-"forall" (275) 139 167
-"choose" (276) 138 168
-"iterate" (277) 169
-"do" (278) 138 167 168
-"call" (279) 179 181
-"if" (280) 137 157 158
-"then" (281) 137 157 158
-"else" (282) 137 158
-"case" (283) 159 160
-"of" (284) 159 160
-"default" (285) 161
-"holds" (286) 139
-"exists" (287) 140
-"with" (288) 140
-"undef" (289) 80
-"false" (290) 82
-"true" (291) 81
-"and" (292) 119
-"or" (293) 117
-"xor" (294) 118
-"implies" (295) 121
-"not" (296) 122
-"+" (297) 103 105
-"-" (298) 104 106
-"=" (299) 34 35 36 37 112 136 141 142 166
-"(" (300) 59 60 101 102 129 130 131 132 135
-")" (301) 59 60 101 102 129 130 131 132 135
-"[" (302) 9 55 123 124 125 126
-"]" (303) 9 55 123 124 125 126
-"{" (304) 17 19 26 35 36 37 159 160 170 172
-"}" (305) 17 19 26 35 36 37 159 160 170 172
-":" (306) 13 43 44 53 161 162 163
-"_" (307) 162
-"@" (308) 89
-"," (309) 15 30 41 47 57 70 127 132 185
-"<" (310) 67 68 113
-">" (311) 67 68 114
-"*" (312) 21 107 135
-"/" (313) 108
-"%" (314) 109
-"^" (315) 110
-"'" (316) 69
-".." (317) 123
-"." (318) 49 52
-"->" (319) 13 28 29 34 43 44 68 142
-"=>" (320) 120
-":=" (321) 178
-"!=" (322) 111
-"<=" (323) 115
-">=" (324) 116
-"{|" (325) 174 176
-"|}" (326) 174 176
-"binary" (327) 84
-"hexadecimal" (328) 85
-"integer" (329) 86
-"rational" (330) 88
-"floating" (331) 87
-"string" (332) 83
-"identifier" (333) 45
-ABSOLUTE_PATH (334)
-UPLUS (335)
-UMINUS (336)
-CALL_WITHOUT_ARGS (337)
+"init" (259) 26 27
+"derived" (260) 35 50
+"enum" (261) 36
+"rule" (262) 51 149 150
+"function" (263) 14
+"initially" (264) 18
+"defined" (265) 20
+"structure" (266) 37
+"feature" (267) 38
+"implements" (268) 44 45
+"for" (269) 44
+"this" (270) 60
+"seq" (271) 183 185
+"endseq" (272) 183 185
+"par" (273) 179 181
+"endpar" (274) 179 181
+"skip" (275) 164
+"let" (276) 144 174
+"in" (277) 53 144 146 147 148 174 175 176
+"forall" (278) 147 175
+"choose" (279) 146 176
+"iterate" (280) 177
+"do" (281) 146 175 176
+"call" (282) 187 189
+"if" (283) 145 165 166
+"then" (284) 145 165 166
+"else" (285) 145 166
+"case" (286) 167 168
+"of" (287) 167 168
+"default" (288) 169
+"holds" (289) 147
+"exists" (290) 148
+"with" (291) 148
+"undef" (292) 88
+"false" (293) 90
+"true" (294) 89
+"and" (295) 127
+"or" (296) 125
+"xor" (297) 126
+"implies" (298) 129
+"not" (299) 130
+"+" (300) 111 113
+"-" (301) 112 114
+"=" (302) 35 36 37 38 44 45 120 144 149 150 174
+"(" (303) 67 68 109 110 137 138 139 140 143
+")" (304) 67 68 109 110 137 138 139 140 143
+"[" (305) 10 63 131 132 133 134
+"]" (306) 10 63 131 132 133 134
+"{" (307) 18 20 27 36 37 38 44 45 167 168 178 180
+"}" (308) 18 20 27 36 37 38 44 45 167 168 178 180
+":" (309) 14 50 51 61 169 170 171
+"_" (310) 170
+"@" (311) 97
+"," (312) 16 31 54 65 78 135 140 193
+"<" (313) 75 76 121
+">" (314) 75 76 122
+"*" (315) 22 115 143
+"/" (316) 116
+"%" (317) 117
+"^" (318) 118
+"'" (319) 77
+".." (320) 131
+"." (321) 56 59 60
+"->" (322) 14 29 30 35 50 51 76 150
+"=>" (323) 128
+":=" (324) 186
+"!=" (325) 119
+"<=" (326) 123
+">=" (327) 124
+"{|" (328) 182 184
+"|}" (329) 182 184
+"binary" (330) 92
+"hexadecimal" (331) 93
+"integer" (332) 94
+"rational" (333) 96
+"floating" (334) 95
+"string" (335) 91
+"identifier" (336) 52
+ABSOLUTE_PATH (337)
+UPLUS (338)
+UMINUS (339)
+CALL_WITHOUT_ARGS (340)
Nonterminals, with rules where they appear
-$accept (83)
+$accept (86)
on left: 0
-Specification (84)
+Specification (87)
on left: 1, on right: 0
-Definition (85)
- on left: 2 3 4 5 6 7 8, on right: 9 10
-AttributedDefinition (86)
- on left: 9 10, on right: 11 12
-Definitions (87)
- on left: 11 12, on right: 1 11
-FunctionDefinition (88)
- on left: 13 14, on right: 2 15 16
-FunctionDefinitions (89)
- on left: 15 16, on right: 15 36
-MaybeInitially (90)
- on left: 17 18, on right: 13
-MaybeDefined (91)
- on left: 19 20, on right: 13
-FunctionParameters (92)
- on left: 21 22, on right: 21 23
-MaybeFunctionParameters (93)
- on left: 23 24, on right: 13 43 44 68
-ProgramFunctionDefinition (94)
- on left: 25 26, on right: 14
-Initializer (95)
- on left: 27 28 29, on right: 30 31
-Initializers (96)
- on left: 30 31, on right: 30 32
-MaybeInitializers (97)
- on left: 32 33, on right: 17 26
-DerivedDefinition (98)
- on left: 34, on right: 3 39
-EnumerationDefinition (99)
- on left: 35, on right: 5
-StructureDefinition (100)
- on left: 36, on right: 6
-FeatureDefinition (101)
- on left: 37, on right: 7
-FeatureDeclarationOrDefinition (102)
- on left: 38 39 40, on right: 41 42
-FeatureDeclarationsAndDefinitions (103)
- on left: 41 42, on right: 37 41
-DeclarationDefinition (104)
- on left: 43 44, on right: 38
-Identifier (105)
- on left: 45 46, on right: 13 34 35 36 37 43 44 47 48 49 50 53 54
- 141 142 187 188
-Identifiers (106)
- on left: 47 48, on right: 35 47
-DotSeparatedIdentifiers (107)
- on left: 49 50, on right: 49 51 52
-IdentifierPath (108)
- on left: 51 52, on right: 25 66 67 68 69 89 133 134
-Variable (109)
- on left: 53 54, on right: 55 56
-AttributedVariable (110)
- on left: 55 56, on right: 57 58 136 138 139 140 166 167 168
-Parameters (111)
- on left: 57 58, on right: 57 59
-MaybeParameters (112)
- on left: 59 60 61, on right: 34 141 142
-Type (113)
- on left: 62 63 64 65, on right: 13 21 22 34 43 44 53 68 70 71 142
-BasicType (114)
- on left: 66, on right: 62
-ComposedType (115)
- on left: 67, on right: 63
-RelationType (116)
- on left: 68, on right: 64
-FixedSizedType (117)
- on left: 69, on right: 65
-Types (118)
- on left: 70 71, on right: 67 70
-Atom (119)
- on left: 72 73 74 75 76 77 78 79, on right: 100
-Undefined (120)
- on left: 80, on right: 78
-Boolean (121)
- on left: 81 82, on right: 79
-String (122)
- on left: 83, on right: 77
-BitNumber (123)
- on left: 84 85, on right: 73
-IntegerNumber (124)
- on left: 86, on right: 74
-FloatingNumber (125)
- on left: 87, on right: 75
-RationalNumber (126)
- on left: 88, on right: 76
-Reference (127)
- on left: 89, on right: 72
-Term (128)
- on left: 90 91 92 93 94 95 96 97 98 99 100, on right: 19 27 28
- 29 34 69 101 103 104 105 106 107 108 109 110 111 112 113 114 115
- 116 117 118 119 120 121 122 123 127 128 132 135 136 137 138 139
- 140 157 158 159 160 163 166 167 168 178 188
-Expression (129)
- on left: 101 102 103 104 105 106 107 108 109 110 111 112 113 114
- 115 116 117 118 119 120 121 122, on right: 97
-Range (130)
- on left: 123, on right: 99
-List (131)
- on left: 124 125 126, on right: 98
-Terms (132)
- on left: 127 128, on right: 125 127 129 132
-Arguments (133)
- on left: 129 130 131, on right: 134 135
-TwoOrMoreArguments (134)
- on left: 132, on right: 29
-DirectCallExpression (135)
- on left: 133 134, on right: 90 178 179 180
-IndirectCallExpression (136)
- on left: 135, on right: 91 181 182
-LetExpression (137)
- on left: 136, on right: 92
-ConditionalExpression (138)
- on left: 137, on right: 93
-ChooseExpression (139)
- on left: 138, on right: 94
-UniversalQuantifierExpression (140)
- on left: 139, on right: 95
-ExistentialQuantifierExpression (141)
- on left: 140, on right: 96
-RuleDefinition (142)
- on left: 141 142, on right: 4 40
-Rule (143)
- on left: 143 144 145 146 147 148 149 150 151 152 153, on right:
- 141 142 154 155 157 158 161 162 163 166 167 168 169
-Rules (144)
- on left: 154 155, on right: 154 170 171 174 175
-SkipRule (145)
- on left: 156, on right: 143
-ConditionalRule (146)
- on left: 157 158, on right: 144
-CaseRule (147)
- on left: 159 160, on right: 145
-CaseLabel (148)
- on left: 161 162 163, on right: 164 165
-CaseLabels (149)
- on left: 164 165, on right: 159 164
-LetRule (150)
- on left: 166, on right: 146
-ForallRule (151)
- on left: 167, on right: 147
-ChooseRule (152)
- on left: 168, on right: 148
-IterateRule (153)
- on left: 169, on right: 149
-BlockRule (154)
- on left: 170 171 172 173, on right: 150
-SequenceRule (155)
- on left: 174 175 176 177, on right: 151
-UpdateRule (156)
- on left: 178, on right: 152
-CallRule (157)
- on left: 179 180 181 182, on right: 153
-Attribute (158)
- on left: 183 184, on right: 185 186
-Attributes (159)
- on left: 185 186, on right: 9 55 185
-BasicAttribute (160)
- on left: 187, on right: 183
-ExpressionAttribute (161)
- on left: 188, on right: 184
+Definition (88)
+ on left: 2 3 4 5 6 7 8 9, on right: 10 11
+AttributedDefinition (89)
+ on left: 10 11, on right: 12 13
+Definitions (90)
+ on left: 12 13, on right: 1 12
+FunctionDefinition (91)
+ on left: 14 15, on right: 2 16 17
+FunctionDefinitions (92)
+ on left: 16 17, on right: 16 37
+MaybeInitially (93)
+ on left: 18 19, on right: 14
+MaybeDefined (94)
+ on left: 20 21, on right: 14
+FunctionParameters (95)
+ on left: 22 23, on right: 22 24
+MaybeFunctionParameters (96)
+ on left: 24 25, on right: 14 50 51 76
+ProgramFunctionDefinition (97)
+ on left: 26 27, on right: 15
+Initializer (98)
+ on left: 28 29 30, on right: 31 32
+Initializers (99)
+ on left: 31 32, on right: 31 33
+MaybeInitializers (100)
+ on left: 33 34, on right: 18 27
+DerivedDefinition (101)
+ on left: 35, on right: 3 40 46
+EnumerationDefinition (102)
+ on left: 36, on right: 5
+StructureDefinition (103)
+ on left: 37, on right: 6
+FeatureDefinition (104)
+ on left: 38, on right: 7
+FeatureDeclarationOrDefinition (105)
+ on left: 39 40 41, on right: 42 43
+FeatureDeclarationsAndDefinitions (106)
+ on left: 42 43, on right: 38 42
+ImplementationDefinition (107)
+ on left: 44 45, on right: 8
+ImplementationDefinitionDefinition (108)
+ on left: 46 47, on right: 48 49
+ImplementationDefinitionDefinitions (109)
+ on left: 48 49, on right: 44 45 48
+DeclarationDefinition (110)
+ on left: 50 51, on right: 39
+Identifier (111)
+ on left: 52 53, on right: 14 35 36 37 38 50 51 54 55 56 57 61 62
+ 149 150 195 196
+Identifiers (112)
+ on left: 54 55, on right: 36 54
+DotSeparatedIdentifiers (113)
+ on left: 56 57, on right: 56 58 59 60
+IdentifierPath (114)
+ on left: 58 59 60, on right: 26 44 74 75 76 77 97 141 142
+Variable (115)
+ on left: 61 62, on right: 63 64
+AttributedVariable (116)
+ on left: 63 64, on right: 65 66 144 146 147 148 174 175 176
+Parameters (117)
+ on left: 65 66, on right: 65 67
+MaybeParameters (118)
+ on left: 67 68 69, on right: 35 149 150
+Type (119)
+ on left: 70 71 72 73, on right: 14 22 23 35 44 45 50 51 61 76 78
+ 79 150
+BasicType (120)
+ on left: 74, on right: 70
+ComposedType (121)
+ on left: 75, on right: 71
+RelationType (122)
+ on left: 76, on right: 72
+FixedSizedType (123)
+ on left: 77, on right: 73
+Types (124)
+ on left: 78 79, on right: 75 78
+Atom (125)
+ on left: 80 81 82 83 84 85 86 87, on right: 108
+Undefined (126)
+ on left: 88, on right: 86
+Boolean (127)
+ on left: 89 90, on right: 87
+String (128)
+ on left: 91, on right: 85
+BitNumber (129)
+ on left: 92 93, on right: 81
+IntegerNumber (130)
+ on left: 94, on right: 82
+FloatingNumber (131)
+ on left: 95, on right: 83
+RationalNumber (132)
+ on left: 96, on right: 84
+Reference (133)
+ on left: 97, on right: 80
+Term (134)
+ on left: 98 99 100 101 102 103 104 105 106 107 108, on right: 20
+ 28 29 30 35 77 109 111 112 113 114 115 116 117 118 119 120 121
+ 122 123 124 125 126 127 128 129 130 131 135 136 140 143 144 145
+ 146 147 148 165 166 167 168 171 174 175 176 186 196
+Expression (135)
+ on left: 109 110 111 112 113 114 115 116 117 118 119 120 121 122
+ 123 124 125 126 127 128 129 130, on right: 105
+Range (136)
+ on left: 131, on right: 107
+List (137)
+ on left: 132 133 134, on right: 106
+Terms (138)
+ on left: 135 136, on right: 133 135 137 140
+Arguments (139)
+ on left: 137 138 139, on right: 142 143
+TwoOrMoreArguments (140)
+ on left: 140, on right: 30
+DirectCallExpression (141)
+ on left: 141 142, on right: 98 186 187 188
+IndirectCallExpression (142)
+ on left: 143, on right: 99 189 190
+LetExpression (143)
+ on left: 144, on right: 100
+ConditionalExpression (144)
+ on left: 145, on right: 101
+ChooseExpression (145)
+ on left: 146, on right: 102
+UniversalQuantifierExpression (146)
+ on left: 147, on right: 103
+ExistentialQuantifierExpression (147)
+ on left: 148, on right: 104
+RuleDefinition (148)
+ on left: 149 150, on right: 4 41 47
+Rule (149)
+ on left: 151 152 153 154 155 156 157 158 159 160 161, on right:
+ 149 150 162 163 165 166 169 170 171 174 175 176 177
+Rules (150)
+ on left: 162 163, on right: 162 178 179 182 183
+SkipRule (151)
+ on left: 164, on right: 151
+ConditionalRule (152)
+ on left: 165 166, on right: 152
+CaseRule (153)
+ on left: 167 168, on right: 153
+CaseLabel (154)
+ on left: 169 170 171, on right: 172 173
+CaseLabels (155)
+ on left: 172 173, on right: 167 172
+LetRule (156)
+ on left: 174, on right: 154
+ForallRule (157)
+ on left: 175, on right: 155
+ChooseRule (158)
+ on left: 176, on right: 156
+IterateRule (159)
+ on left: 177, on right: 157
+BlockRule (160)
+ on left: 178 179 180 181, on right: 158
+SequenceRule (161)
+ on left: 182 183 184 185, on right: 159
+UpdateRule (162)
+ on left: 186, on right: 160
+CallRule (163)
+ on left: 187 188 189 190, on right: 161
+Attribute (164)
+ on left: 191 192, on right: 193 194
+Attributes (165)
+ on left: 193 194, on right: 10 63 193
+BasicAttribute (166)
+ on left: 195, on right: 191
+ExpressionAttribute (167)
+ on left: 196, on right: 192
State 0
@@ -536,8019 +557,8320 @@ State 1
1 Specification: "CASM" . Definitions
- error shift, and go to state 3
- "init" shift, and go to state 4
- "derived" shift, and go to state 5
- "enum" shift, and go to state 6
- "rule" shift, and go to state 7
- "function" shift, and go to state 8
- "structure" shift, and go to state 9
- "feature" shift, and go to state 10
- "[" shift, and go to state 11
-
- Definition go to state 12
- AttributedDefinition go to state 13
- Definitions go to state 14
- FunctionDefinition go to state 15
- ProgramFunctionDefinition go to state 16
- DerivedDefinition go to state 17
- EnumerationDefinition go to state 18
- StructureDefinition go to state 19
- FeatureDefinition go to state 20
- RuleDefinition go to state 21
+ error shift, and go to state 3
+ "init" shift, and go to state 4
+ "derived" shift, and go to state 5
+ "enum" shift, and go to state 6
+ "rule" shift, and go to state 7
+ "function" shift, and go to state 8
+ "structure" shift, and go to state 9
+ "feature" shift, and go to state 10
+ "implements" shift, and go to state 11
+ "[" shift, and go to state 12
+
+ Definition go to state 13
+ AttributedDefinition go to state 14
+ Definitions go to state 15
+ FunctionDefinition go to state 16
+ ProgramFunctionDefinition go to state 17
+ DerivedDefinition go to state 18
+ EnumerationDefinition go to state 19
+ StructureDefinition go to state 20
+ FeatureDefinition go to state 21
+ ImplementationDefinition go to state 22
+ RuleDefinition go to state 23
State 2
0 $accept: Specification . "end of file"
- "end of file" shift, and go to state 22
+ "end of file" shift, and go to state 24
State 3
- 8 Definition: error .
+ 9 Definition: error .
- $default reduce using rule 8 (Definition)
+ $default reduce using rule 9 (Definition)
State 4
- 25 ProgramFunctionDefinition: "init" . IdentifierPath
- 26 | "init" . "{" MaybeInitializers "}"
+ 26 ProgramFunctionDefinition: "init" . IdentifierPath
+ 27 | "init" . "{" MaybeInitializers "}"
- "in" shift, and go to state 23
- "{" shift, and go to state 24
- "." shift, and go to state 25
- "identifier" shift, and go to state 26
+ "this" shift, and go to state 25
+ "in" shift, and go to state 26
+ "{" shift, and go to state 27
+ "." shift, and go to state 28
+ "identifier" shift, and go to state 29
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 29
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 32
State 5
- 34 DerivedDefinition: "derived" . Identifier MaybeParameters "->" Type "=" Term
+ 35 DerivedDefinition: "derived" . Identifier MaybeParameters "->" Type "=" Term
- "in" shift, and go to state 23
- "identifier" shift, and go to state 26
+ "in" shift, and go to state 26
+ "identifier" shift, and go to state 29
- Identifier go to state 30
+ Identifier go to state 33
State 6
- 35 EnumerationDefinition: "enum" . Identifier "=" "{" Identifiers "}"
+ 36 EnumerationDefinition: "enum" . Identifier "=" "{" Identifiers "}"
- "in" shift, and go to state 23
- "identifier" shift, and go to state 26
+ "in" shift, and go to state 26
+ "identifier" shift, and go to state 29
- Identifier go to state 31
+ Identifier go to state 34
State 7
- 141 RuleDefinition: "rule" . Identifier MaybeParameters "=" Rule
- 142 | "rule" . Identifier MaybeParameters "->" Type "=" Rule
+ 149 RuleDefinition: "rule" . Identifier MaybeParameters "=" Rule
+ 150 | "rule" . Identifier MaybeParameters "->" Type "=" Rule
- "in" shift, and go to state 23
- "identifier" shift, and go to state 26
+ "in" shift, and go to state 26
+ "identifier" shift, and go to state 29
- Identifier go to state 32
+ Identifier go to state 35
State 8
- 13 FunctionDefinition: "function" . Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially
+ 14 FunctionDefinition: "function" . Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially
- "in" shift, and go to state 23
- "identifier" shift, and go to state 26
+ "in" shift, and go to state 26
+ "identifier" shift, and go to state 29
- Identifier go to state 33
+ Identifier go to state 36
State 9
- 36 StructureDefinition: "structure" . Identifier "=" "{" FunctionDefinitions "}"
+ 37 StructureDefinition: "structure" . Identifier "=" "{" FunctionDefinitions "}"
- "in" shift, and go to state 23
- "identifier" shift, and go to state 26
+ "in" shift, and go to state 26
+ "identifier" shift, and go to state 29
- Identifier go to state 34
+ Identifier go to state 37
State 10
- 37 FeatureDefinition: "feature" . Identifier "=" "{" FeatureDeclarationsAndDefinitions "}"
+ 38 FeatureDefinition: "feature" . Identifier "=" "{" FeatureDeclarationsAndDefinitions "}"
- "in" shift, and go to state 23
- "identifier" shift, and go to state 26
+ "in" shift, and go to state 26
+ "identifier" shift, and go to state 29
- Identifier go to state 35
+ Identifier go to state 38
State 11
- 9 AttributedDefinition: "[" . Attributes "]" Definition
+ 44 ImplementationDefinition: "implements" . IdentifierPath "for" Type "=" "{" ImplementationDefinitionDefinitions "}"
+ 45 | "implements" . Type "=" "{" ImplementationDefinitionDefinitions "}"
- "in" shift, and go to state 23
- "identifier" shift, and go to state 26
+ "this" shift, and go to state 25
+ "in" shift, and go to state 26
+ "." shift, and go to state 28
+ "identifier" shift, and go to state 29
- Identifier go to state 36
- Attribute go to state 37
- Attributes go to state 38
- BasicAttribute go to state 39
- ExpressionAttribute go to state 40
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 39
+ Type go to state 40
+ BasicType go to state 41
+ ComposedType go to state 42
+ RelationType go to state 43
+ FixedSizedType go to state 44
State 12
- 10 AttributedDefinition: Definition .
+ 10 AttributedDefinition: "[" . Attributes "]" Definition
- $default reduce using rule 10 (AttributedDefinition)
+ "in" shift, and go to state 26
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 45
+ Attribute go to state 46
+ Attributes go to state 47
+ BasicAttribute go to state 48
+ ExpressionAttribute go to state 49
State 13
- 12 Definitions: AttributedDefinition .
+ 11 AttributedDefinition: Definition .
- $default reduce using rule 12 (Definitions)
+ $default reduce using rule 11 (AttributedDefinition)
State 14
+ 13 Definitions: AttributedDefinition .
+
+ $default reduce using rule 13 (Definitions)
+
+
+State 15
+
1 Specification: "CASM" Definitions .
- 11 Definitions: Definitions . AttributedDefinition
-
- error shift, and go to state 3
- "init" shift, and go to state 4
- "derived" shift, and go to state 5
- "enum" shift, and go to state 6
- "rule" shift, and go to state 7
- "function" shift, and go to state 8
- "structure" shift, and go to state 9
- "feature" shift, and go to state 10
- "[" shift, and go to state 11
+ 12 Definitions: Definitions . AttributedDefinition
+
+ error shift, and go to state 3
+ "init" shift, and go to state 4
+ "derived" shift, and go to state 5
+ "enum" shift, and go to state 6
+ "rule" shift, and go to state 7
+ "function" shift, and go to state 8
+ "structure" shift, and go to state 9
+ "feature" shift, and go to state 10
+ "implements" shift, and go to state 11
+ "[" shift, and go to state 12
"end of file" reduce using rule 1 (Specification)
- Definition go to state 12
- AttributedDefinition go to state 41
- FunctionDefinition go to state 15
- ProgramFunctionDefinition go to state 16
- DerivedDefinition go to state 17
- EnumerationDefinition go to state 18
- StructureDefinition go to state 19
- FeatureDefinition go to state 20
- RuleDefinition go to state 21
+ Definition go to state 13
+ AttributedDefinition go to state 50
+ FunctionDefinition go to state 16
+ ProgramFunctionDefinition go to state 17
+ DerivedDefinition go to state 18
+ EnumerationDefinition go to state 19
+ StructureDefinition go to state 20
+ FeatureDefinition go to state 21
+ ImplementationDefinition go to state 22
+ RuleDefinition go to state 23
-State 15
+State 16
2 Definition: FunctionDefinition .
$default reduce using rule 2 (Definition)
-State 16
+State 17
- 14 FunctionDefinition: ProgramFunctionDefinition .
+ 15 FunctionDefinition: ProgramFunctionDefinition .
- $default reduce using rule 14 (FunctionDefinition)
+ $default reduce using rule 15 (FunctionDefinition)
-State 17
+State 18
3 Definition: DerivedDefinition .
$default reduce using rule 3 (Definition)
-State 18
+State 19
5 Definition: EnumerationDefinition .
$default reduce using rule 5 (Definition)
-State 19
+State 20
6 Definition: StructureDefinition .
$default reduce using rule 6 (Definition)
-State 20
+State 21
7 Definition: FeatureDefinition .
$default reduce using rule 7 (Definition)
-State 21
-
- 4 Definition: RuleDefinition .
-
- $default reduce using rule 4 (Definition)
-
-
State 22
- 0 $accept: Specification "end of file" .
+ 8 Definition: ImplementationDefinition .
- $default accept
+ $default reduce using rule 8 (Definition)
State 23
- 46 Identifier: "in" .
+ 4 Definition: RuleDefinition .
- $default reduce using rule 46 (Identifier)
+ $default reduce using rule 4 (Definition)
State 24
- 26 ProgramFunctionDefinition: "init" "{" . MaybeInitializers "}"
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 53
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- $default reduce using rule 33 (MaybeInitializers)
+ 0 $accept: Specification "end of file" .
- Initializer go to state 62
- Initializers go to state 63
- MaybeInitializers go to state 64
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 75
- Expression go to state 76
- Range go to state 77
- List go to state 78
- TwoOrMoreArguments go to state 79
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ $default accept
State 25
- 52 IdentifierPath: "." . DotSeparatedIdentifiers
-
- "in" shift, and go to state 23
- "identifier" shift, and go to state 26
+ 60 IdentifierPath: "this" . "." DotSeparatedIdentifiers
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 87
+ "." shift, and go to state 51
State 26
- 45 Identifier: "identifier" .
+ 53 Identifier: "in" .
- $default reduce using rule 45 (Identifier)
+ $default reduce using rule 53 (Identifier)
State 27
- 50 DotSeparatedIdentifiers: Identifier .
-
- $default reduce using rule 50 (DotSeparatedIdentifiers)
+ 27 ProgramFunctionDefinition: "init" "{" . MaybeInitializers "}"
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 63
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ $default reduce using rule 34 (MaybeInitializers)
+
+ Initializer go to state 72
+ Initializers go to state 73
+ MaybeInitializers go to state 74
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 85
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ TwoOrMoreArguments go to state 89
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 28
- 49 DotSeparatedIdentifiers: DotSeparatedIdentifiers . "." Identifier
- 51 IdentifierPath: DotSeparatedIdentifiers .
+ 59 IdentifierPath: "." . DotSeparatedIdentifiers
- "." shift, and go to state 88
+ "in" shift, and go to state 26
+ "identifier" shift, and go to state 29
- $default reduce using rule 51 (IdentifierPath)
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 97
State 29
- 25 ProgramFunctionDefinition: "init" IdentifierPath .
+ 52 Identifier: "identifier" .
- $default reduce using rule 25 (ProgramFunctionDefinition)
+ $default reduce using rule 52 (Identifier)
State 30
- 34 DerivedDefinition: "derived" Identifier . MaybeParameters "->" Type "=" Term
+ 57 DotSeparatedIdentifiers: Identifier .
- "(" shift, and go to state 89
-
- $default reduce using rule 61 (MaybeParameters)
-
- MaybeParameters go to state 90
+ $default reduce using rule 57 (DotSeparatedIdentifiers)
State 31
- 35 EnumerationDefinition: "enum" Identifier . "=" "{" Identifiers "}"
+ 56 DotSeparatedIdentifiers: DotSeparatedIdentifiers . "." Identifier
+ 58 IdentifierPath: DotSeparatedIdentifiers .
+
+ "." shift, and go to state 98
- "=" shift, and go to state 91
+ $default reduce using rule 58 (IdentifierPath)
State 32
- 141 RuleDefinition: "rule" Identifier . MaybeParameters "=" Rule
- 142 | "rule" Identifier . MaybeParameters "->" Type "=" Rule
+ 26 ProgramFunctionDefinition: "init" IdentifierPath .
- "(" shift, and go to state 89
+ $default reduce using rule 26 (ProgramFunctionDefinition)
- $default reduce using rule 61 (MaybeParameters)
- MaybeParameters go to state 92
+State 33
+ 35 DerivedDefinition: "derived" Identifier . MaybeParameters "->" Type "=" Term
-State 33
+ "(" shift, and go to state 99
- 13 FunctionDefinition: "function" Identifier . ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially
+ $default reduce using rule 69 (MaybeParameters)
- ":" shift, and go to state 93
+ MaybeParameters go to state 100
State 34
- 36 StructureDefinition: "structure" Identifier . "=" "{" FunctionDefinitions "}"
+ 36 EnumerationDefinition: "enum" Identifier . "=" "{" Identifiers "}"
- "=" shift, and go to state 94
+ "=" shift, and go to state 101
State 35
- 37 FeatureDefinition: "feature" Identifier . "=" "{" FeatureDeclarationsAndDefinitions "}"
+ 149 RuleDefinition: "rule" Identifier . MaybeParameters "=" Rule
+ 150 | "rule" Identifier . MaybeParameters "->" Type "=" Rule
- "=" shift, and go to state 95
+ "(" shift, and go to state 99
+
+ $default reduce using rule 69 (MaybeParameters)
+
+ MaybeParameters go to state 102
State 36
- 187 BasicAttribute: Identifier .
- 188 ExpressionAttribute: Identifier . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- $default reduce using rule 187 (BasicAttribute)
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 97
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 14 FunctionDefinition: "function" Identifier . ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially
+
+ ":" shift, and go to state 103
State 37
- 186 Attributes: Attribute .
+ 37 StructureDefinition: "structure" Identifier . "=" "{" FunctionDefinitions "}"
- $default reduce using rule 186 (Attributes)
+ "=" shift, and go to state 104
State 38
- 9 AttributedDefinition: "[" Attributes . "]" Definition
- 185 Attributes: Attributes . "," Attribute
+ 38 FeatureDefinition: "feature" Identifier . "=" "{" FeatureDeclarationsAndDefinitions "}"
- "]" shift, and go to state 98
- "," shift, and go to state 99
+ "=" shift, and go to state 105
State 39
- 183 Attribute: BasicAttribute .
+ 44 ImplementationDefinition: "implements" IdentifierPath . "for" Type "=" "{" ImplementationDefinitionDefinitions "}"
+ 74 BasicType: IdentifierPath .
+ 75 ComposedType: IdentifierPath . "<" Types ">"
+ 76 RelationType: IdentifierPath . "<" MaybeFunctionParameters "->" Type ">"
+ 77 FixedSizedType: IdentifierPath . "'" Term
+
+ "for" shift, and go to state 106
+ "<" shift, and go to state 107
+ "'" shift, and go to state 108
- $default reduce using rule 183 (Attribute)
+ $default reduce using rule 74 (BasicType)
State 40
- 184 Attribute: ExpressionAttribute .
+ 45 ImplementationDefinition: "implements" Type . "=" "{" ImplementationDefinitionDefinitions "}"
- $default reduce using rule 184 (Attribute)
+ "=" shift, and go to state 109
State 41
- 11 Definitions: Definitions AttributedDefinition .
+ 70 Type: BasicType .
- $default reduce using rule 11 (Definitions)
+ $default reduce using rule 70 (Type)
State 42
- 136 LetExpression: "let" . AttributedVariable "=" Term "in" Term
+ 71 Type: ComposedType .
- "in" shift, and go to state 23
- "[" shift, and go to state 100
- "identifier" shift, and go to state 26
-
- Identifier go to state 101
- Variable go to state 102
- AttributedVariable go to state 103
+ $default reduce using rule 71 (Type)
State 43
- 139 UniversalQuantifierExpression: "forall" . AttributedVariable "in" Term "holds" Term
-
- "in" shift, and go to state 23
- "[" shift, and go to state 100
- "identifier" shift, and go to state 26
+ 72 Type: RelationType .
- Identifier go to state 101
- Variable go to state 102
- AttributedVariable go to state 104
+ $default reduce using rule 72 (Type)
State 44
- 138 ChooseExpression: "choose" . AttributedVariable "in" Term "do" Term
-
- "in" shift, and go to state 23
- "[" shift, and go to state 100
- "identifier" shift, and go to state 26
+ 73 Type: FixedSizedType .
- Identifier go to state 101
- Variable go to state 102
- AttributedVariable go to state 105
+ $default reduce using rule 73 (Type)
State 45
- 137 ConditionalExpression: "if" . Term "then" Term "else" Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 106
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 195 BasicAttribute: Identifier .
+ 196 ExpressionAttribute: Identifier . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ $default reduce using rule 195 (BasicAttribute)
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 111
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 46
- 140 ExistentialQuantifierExpression: "exists" . AttributedVariable "in" Term "with" Term
+ 194 Attributes: Attribute .
- "in" shift, and go to state 23
- "[" shift, and go to state 100
- "identifier" shift, and go to state 26
-
- Identifier go to state 101
- Variable go to state 102
- AttributedVariable go to state 107
+ $default reduce using rule 194 (Attributes)
State 47
- 80 Undefined: "undef" .
+ 10 AttributedDefinition: "[" Attributes . "]" Definition
+ 193 Attributes: Attributes . "," Attribute
- $default reduce using rule 80 (Undefined)
+ "]" shift, and go to state 112
+ "," shift, and go to state 113
State 48
- 82 Boolean: "false" .
+ 191 Attribute: BasicAttribute .
- $default reduce using rule 82 (Boolean)
+ $default reduce using rule 191 (Attribute)
State 49
- 81 Boolean: "true" .
+ 192 Attribute: ExpressionAttribute .
- $default reduce using rule 81 (Boolean)
+ $default reduce using rule 192 (Attribute)
State 50
- 122 Expression: "not" . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 108
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 12 Definitions: Definitions AttributedDefinition .
+
+ $default reduce using rule 12 (Definitions)
State 51
- 103 Expression: "+" . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 109
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 60 IdentifierPath: "this" "." . DotSeparatedIdentifiers
+
+ "in" shift, and go to state 26
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 114
State 52
- 104 Expression: "-" . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 110
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 144 LetExpression: "let" . AttributedVariable "=" Term "in" Term
+
+ "in" shift, and go to state 26
+ "[" shift, and go to state 115
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 116
+ Variable go to state 117
+ AttributedVariable go to state 118
State 53
- 101 Expression: "(" . Term ")"
- 102 | "(" . error ")"
- 132 TwoOrMoreArguments: "(" . Terms "," Term ")"
- 135 IndirectCallExpression: "(" . "*" Term ")" Arguments
-
- error shift, and go to state 111
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "*" shift, and go to state 112
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 113
- Expression go to state 76
- Range go to state 77
- List go to state 78
- Terms go to state 114
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 147 UniversalQuantifierExpression: "forall" . AttributedVariable "in" Term "holds" Term
+
+ "in" shift, and go to state 26
+ "[" shift, and go to state 115
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 116
+ Variable go to state 117
+ AttributedVariable go to state 119
State 54
- 123 Range: "[" . Term ".." Term "]"
- 124 List: "[" . "]"
- 125 | "[" . Terms "]"
- 126 | "[" . error "]"
-
- error shift, and go to state 115
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "]" shift, and go to state 116
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 117
- Expression go to state 76
- Range go to state 77
- List go to state 78
- Terms go to state 118
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 146 ChooseExpression: "choose" . AttributedVariable "in" Term "do" Term
+ "in" shift, and go to state 26
+ "[" shift, and go to state 115
+ "identifier" shift, and go to state 29
-State 55
+ Identifier go to state 116
+ Variable go to state 117
+ AttributedVariable go to state 120
- 89 Reference: "@" . IdentifierPath
- "in" shift, and go to state 23
- "." shift, and go to state 25
- "identifier" shift, and go to state 26
+State 55
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 119
+ 145 ConditionalExpression: "if" . Term "then" Term "else" Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 121
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 56
- 84 BitNumber: "binary" .
+ 148 ExistentialQuantifierExpression: "exists" . AttributedVariable "in" Term "with" Term
- $default reduce using rule 84 (BitNumber)
+ "in" shift, and go to state 26
+ "[" shift, and go to state 115
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 116
+ Variable go to state 117
+ AttributedVariable go to state 122
State 57
- 85 BitNumber: "hexadecimal" .
+ 88 Undefined: "undef" .
- $default reduce using rule 85 (BitNumber)
+ $default reduce using rule 88 (Undefined)
State 58
- 86 IntegerNumber: "integer" .
+ 90 Boolean: "false" .
- $default reduce using rule 86 (IntegerNumber)
+ $default reduce using rule 90 (Boolean)
State 59
- 88 RationalNumber: "rational" .
+ 89 Boolean: "true" .
- $default reduce using rule 88 (RationalNumber)
+ $default reduce using rule 89 (Boolean)
State 60
- 87 FloatingNumber: "floating" .
-
- $default reduce using rule 87 (FloatingNumber)
+ 130 Expression: "not" . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 123
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 61
- 83 String: "string" .
-
- $default reduce using rule 83 (String)
+ 111 Expression: "+" . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 124
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 62
- 31 Initializers: Initializer .
-
- $default reduce using rule 31 (Initializers)
+ 112 Expression: "-" . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 125
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 63
- 30 Initializers: Initializers . "," Initializer
- 32 MaybeInitializers: Initializers .
-
- "," shift, and go to state 120
-
- $default reduce using rule 32 (MaybeInitializers)
+ 109 Expression: "(" . Term ")"
+ 110 | "(" . error ")"
+ 140 TwoOrMoreArguments: "(" . Terms "," Term ")"
+ 143 IndirectCallExpression: "(" . "*" Term ")" Arguments
+
+ error shift, and go to state 126
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "*" shift, and go to state 127
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 128
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ Terms go to state 129
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 64
- 26 ProgramFunctionDefinition: "init" "{" MaybeInitializers . "}"
-
- "}" shift, and go to state 121
+ 131 Range: "[" . Term ".." Term "]"
+ 132 List: "[" . "]"
+ 133 | "[" . Terms "]"
+ 134 | "[" . error "]"
+
+ error shift, and go to state 130
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "]" shift, and go to state 131
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 132
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ Terms go to state 133
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 65
- 133 DirectCallExpression: IdentifierPath .
- 134 | IdentifierPath . Arguments
-
- "(" shift, and go to state 122
+ 97 Reference: "@" . IdentifierPath
- $default reduce using rule 133 (DirectCallExpression)
+ "this" shift, and go to state 25
+ "in" shift, and go to state 26
+ "." shift, and go to state 28
+ "identifier" shift, and go to state 29
- Arguments go to state 123
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 134
State 66
- 100 Term: Atom .
+ 92 BitNumber: "binary" .
- $default reduce using rule 100 (Term)
+ $default reduce using rule 92 (BitNumber)
State 67
- 78 Atom: Undefined .
+ 93 BitNumber: "hexadecimal" .
- $default reduce using rule 78 (Atom)
+ $default reduce using rule 93 (BitNumber)
State 68
- 79 Atom: Boolean .
+ 94 IntegerNumber: "integer" .
- $default reduce using rule 79 (Atom)
+ $default reduce using rule 94 (IntegerNumber)
State 69
- 77 Atom: String .
+ 96 RationalNumber: "rational" .
- $default reduce using rule 77 (Atom)
+ $default reduce using rule 96 (RationalNumber)
State 70
- 73 Atom: BitNumber .
+ 95 FloatingNumber: "floating" .
- $default reduce using rule 73 (Atom)
+ $default reduce using rule 95 (FloatingNumber)
State 71
- 74 Atom: IntegerNumber .
+ 91 String: "string" .
- $default reduce using rule 74 (Atom)
+ $default reduce using rule 91 (String)
State 72
- 75 Atom: FloatingNumber .
+ 32 Initializers: Initializer .
- $default reduce using rule 75 (Atom)
+ $default reduce using rule 32 (Initializers)
State 73
- 76 Atom: RationalNumber .
+ 31 Initializers: Initializers . "," Initializer
+ 33 MaybeInitializers: Initializers .
- $default reduce using rule 76 (Atom)
+ "," shift, and go to state 135
+
+ $default reduce using rule 33 (MaybeInitializers)
State 74
- 72 Atom: Reference .
+ 27 ProgramFunctionDefinition: "init" "{" MaybeInitializers . "}"
- $default reduce using rule 72 (Atom)
+ "}" shift, and go to state 136
State 75
- 27 Initializer: Term .
- 28 | Term . "->" Term
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
-
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "implies" shift, and go to state 127
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "->" shift, and go to state 137
- "=>" shift, and go to state 138
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
-
- $default reduce using rule 27 (Initializer)
+ 141 DirectCallExpression: IdentifierPath .
+ 142 | IdentifierPath . Arguments
+
+ "(" shift, and go to state 137
+
+ $default reduce using rule 141 (DirectCallExpression)
+
+ Arguments go to state 138
State 76
- 97 Term: Expression .
+ 108 Term: Atom .
- $default reduce using rule 97 (Term)
+ $default reduce using rule 108 (Term)
State 77
- 99 Term: Range .
+ 86 Atom: Undefined .
- $default reduce using rule 99 (Term)
+ $default reduce using rule 86 (Atom)
State 78
- 98 Term: List .
+ 87 Atom: Boolean .
- $default reduce using rule 98 (Term)
+ $default reduce using rule 87 (Atom)
State 79
- 29 Initializer: TwoOrMoreArguments . "->" Term
+ 85 Atom: String .
- "->" shift, and go to state 142
+ $default reduce using rule 85 (Atom)
State 80
- 90 Term: DirectCallExpression .
+ 81 Atom: BitNumber .
- $default reduce using rule 90 (Term)
+ $default reduce using rule 81 (Atom)
State 81
- 91 Term: IndirectCallExpression .
+ 82 Atom: IntegerNumber .
- $default reduce using rule 91 (Term)
+ $default reduce using rule 82 (Atom)
State 82
- 92 Term: LetExpression .
+ 83 Atom: FloatingNumber .
- $default reduce using rule 92 (Term)
+ $default reduce using rule 83 (Atom)
State 83
- 93 Term: ConditionalExpression .
+ 84 Atom: RationalNumber .
- $default reduce using rule 93 (Term)
+ $default reduce using rule 84 (Atom)
State 84
- 94 Term: ChooseExpression .
+ 80 Atom: Reference .
- $default reduce using rule 94 (Term)
+ $default reduce using rule 80 (Atom)
State 85
- 95 Term: UniversalQuantifierExpression .
+ 28 Initializer: Term .
+ 29 | Term . "->" Term
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "implies" shift, and go to state 142
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "->" shift, and go to state 152
+ "=>" shift, and go to state 153
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
- $default reduce using rule 95 (Term)
+ $default reduce using rule 28 (Initializer)
State 86
- 96 Term: ExistentialQuantifierExpression .
+ 105 Term: Expression .
- $default reduce using rule 96 (Term)
+ $default reduce using rule 105 (Term)
State 87
- 49 DotSeparatedIdentifiers: DotSeparatedIdentifiers . "." Identifier
- 52 IdentifierPath: "." DotSeparatedIdentifiers .
+ 107 Term: Range .
- $default reduce using rule 52 (IdentifierPath)
+ $default reduce using rule 107 (Term)
State 88
- 49 DotSeparatedIdentifiers: DotSeparatedIdentifiers "." . Identifier
-
- "in" shift, and go to state 23
- "identifier" shift, and go to state 26
+ 106 Term: List .
- Identifier go to state 143
+ $default reduce using rule 106 (Term)
State 89
- 59 MaybeParameters: "(" . Parameters ")"
- 60 | "(" . error ")"
+ 30 Initializer: TwoOrMoreArguments . "->" Term
- error shift, and go to state 144
- "in" shift, and go to state 23
- "[" shift, and go to state 100
- "identifier" shift, and go to state 26
-
- Identifier go to state 101
- Variable go to state 102
- AttributedVariable go to state 145
- Parameters go to state 146
+ "->" shift, and go to state 157
State 90
- 34 DerivedDefinition: "derived" Identifier MaybeParameters . "->" Type "=" Term
+ 98 Term: DirectCallExpression .
- "->" shift, and go to state 147
+ $default reduce using rule 98 (Term)
State 91
- 35 EnumerationDefinition: "enum" Identifier "=" . "{" Identifiers "}"
+ 99 Term: IndirectCallExpression .
- "{" shift, and go to state 148
+ $default reduce using rule 99 (Term)
State 92
- 141 RuleDefinition: "rule" Identifier MaybeParameters . "=" Rule
- 142 | "rule" Identifier MaybeParameters . "->" Type "=" Rule
+ 100 Term: LetExpression .
- "=" shift, and go to state 149
- "->" shift, and go to state 150
+ $default reduce using rule 100 (Term)
State 93
- 13 FunctionDefinition: "function" Identifier ":" . MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially
+ 101 Term: ConditionalExpression .
- "in" shift, and go to state 23
- "." shift, and go to state 25
- "identifier" shift, and go to state 26
-
- $default reduce using rule 24 (MaybeFunctionParameters)
-
- FunctionParameters go to state 151
- MaybeFunctionParameters go to state 152
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 153
- Type go to state 154
- BasicType go to state 155
- ComposedType go to state 156
- RelationType go to state 157
- FixedSizedType go to state 158
+ $default reduce using rule 101 (Term)
State 94
- 36 StructureDefinition: "structure" Identifier "=" . "{" FunctionDefinitions "}"
+ 102 Term: ChooseExpression .
- "{" shift, and go to state 159
+ $default reduce using rule 102 (Term)
State 95
- 37 FeatureDefinition: "feature" Identifier "=" . "{" FeatureDeclarationsAndDefinitions "}"
+ 103 Term: UniversalQuantifierExpression .
- "{" shift, and go to state 160
+ $default reduce using rule 103 (Term)
State 96
- 101 Expression: "(" . Term ")"
- 102 | "(" . error ")"
- 135 IndirectCallExpression: "(" . "*" Term ")" Arguments
-
- error shift, and go to state 111
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "*" shift, and go to state 112
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 161
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 104 Term: ExistentialQuantifierExpression .
+
+ $default reduce using rule 104 (Term)
State 97
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
- 188 ExpressionAttribute: Identifier Term .
-
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "implies" shift, and go to state 127
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "=>" shift, and go to state 138
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
-
- $default reduce using rule 188 (ExpressionAttribute)
+ 56 DotSeparatedIdentifiers: DotSeparatedIdentifiers . "." Identifier
+ 59 IdentifierPath: "." DotSeparatedIdentifiers .
+
+ $default reduce using rule 59 (IdentifierPath)
State 98
- 9 AttributedDefinition: "[" Attributes "]" . Definition
+ 56 DotSeparatedIdentifiers: DotSeparatedIdentifiers "." . Identifier
- error shift, and go to state 3
- "init" shift, and go to state 4
- "derived" shift, and go to state 5
- "enum" shift, and go to state 6
- "rule" shift, and go to state 7
- "function" shift, and go to state 8
- "structure" shift, and go to state 9
- "feature" shift, and go to state 10
+ "in" shift, and go to state 26
+ "identifier" shift, and go to state 29
- Definition go to state 162
- FunctionDefinition go to state 15
- ProgramFunctionDefinition go to state 16
- DerivedDefinition go to state 17
- EnumerationDefinition go to state 18
- StructureDefinition go to state 19
- FeatureDefinition go to state 20
- RuleDefinition go to state 21
+ Identifier go to state 158
State 99
- 185 Attributes: Attributes "," . Attribute
+ 67 MaybeParameters: "(" . Parameters ")"
+ 68 | "(" . error ")"
- "in" shift, and go to state 23
- "identifier" shift, and go to state 26
+ error shift, and go to state 159
+ "in" shift, and go to state 26
+ "[" shift, and go to state 115
+ "identifier" shift, and go to state 29
- Identifier go to state 36
- Attribute go to state 163
- BasicAttribute go to state 39
- ExpressionAttribute go to state 40
+ Identifier go to state 116
+ Variable go to state 117
+ AttributedVariable go to state 160
+ Parameters go to state 161
State 100
- 55 AttributedVariable: "[" . Attributes "]" Variable
+ 35 DerivedDefinition: "derived" Identifier MaybeParameters . "->" Type "=" Term
- "in" shift, and go to state 23
- "identifier" shift, and go to state 26
-
- Identifier go to state 36
- Attribute go to state 37
- Attributes go to state 164
- BasicAttribute go to state 39
- ExpressionAttribute go to state 40
+ "->" shift, and go to state 162
State 101
- 53 Variable: Identifier . ":" Type
- 54 | Identifier .
-
- ":" shift, and go to state 165
+ 36 EnumerationDefinition: "enum" Identifier "=" . "{" Identifiers "}"
- $default reduce using rule 54 (Variable)
+ "{" shift, and go to state 163
State 102
- 56 AttributedVariable: Variable .
+ 149 RuleDefinition: "rule" Identifier MaybeParameters . "=" Rule
+ 150 | "rule" Identifier MaybeParameters . "->" Type "=" Rule
- $default reduce using rule 56 (AttributedVariable)
+ "=" shift, and go to state 164
+ "->" shift, and go to state 165
State 103
- 136 LetExpression: "let" AttributedVariable . "=" Term "in" Term
+ 14 FunctionDefinition: "function" Identifier ":" . MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially
+
+ "this" shift, and go to state 25
+ "in" shift, and go to state 26
+ "." shift, and go to state 28
+ "identifier" shift, and go to state 29
- "=" shift, and go to state 166
+ $default reduce using rule 25 (MaybeFunctionParameters)
+
+ FunctionParameters go to state 166
+ MaybeFunctionParameters go to state 167
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 168
+ Type go to state 169
+ BasicType go to state 41
+ ComposedType go to state 42
+ RelationType go to state 43
+ FixedSizedType go to state 44
State 104
- 139 UniversalQuantifierExpression: "forall" AttributedVariable . "in" Term "holds" Term
+ 37 StructureDefinition: "structure" Identifier "=" . "{" FunctionDefinitions "}"
- "in" shift, and go to state 167
+ "{" shift, and go to state 170
State 105
- 138 ChooseExpression: "choose" AttributedVariable . "in" Term "do" Term
+ 38 FeatureDefinition: "feature" Identifier "=" . "{" FeatureDeclarationsAndDefinitions "}"
- "in" shift, and go to state 168
+ "{" shift, and go to state 171
State 106
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
- 137 ConditionalExpression: "if" Term . "then" Term "else" Term
-
- "then" shift, and go to state 169
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "implies" shift, and go to state 127
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "=>" shift, and go to state 138
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
+ 44 ImplementationDefinition: "implements" IdentifierPath "for" . Type "=" "{" ImplementationDefinitionDefinitions "}"
+
+ "this" shift, and go to state 25
+ "in" shift, and go to state 26
+ "." shift, and go to state 28
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 168
+ Type go to state 172
+ BasicType go to state 41
+ ComposedType go to state 42
+ RelationType go to state 43
+ FixedSizedType go to state 44
State 107
- 140 ExistentialQuantifierExpression: "exists" AttributedVariable . "in" Term "with" Term
+ 75 ComposedType: IdentifierPath "<" . Types ">"
+ 76 RelationType: IdentifierPath "<" . MaybeFunctionParameters "->" Type ">"
- "in" shift, and go to state 170
+ "this" shift, and go to state 25
+ "in" shift, and go to state 26
+ "." shift, and go to state 28
+ "identifier" shift, and go to state 29
+ $default reduce using rule 25 (MaybeFunctionParameters)
-State 108
+ FunctionParameters go to state 166
+ MaybeFunctionParameters go to state 173
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 168
+ Type go to state 174
+ BasicType go to state 41
+ ComposedType go to state 42
+ RelationType go to state 43
+ FixedSizedType go to state 44
+ Types go to state 175
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
- 122 | "not" Term .
- $default reduce using rule 122 (Expression)
+State 108
+
+ 77 FixedSizedType: IdentifierPath "'" . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 176
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 109
- 103 Expression: "+" Term .
- 105 | Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
-
- $default reduce using rule 103 (Expression)
+ 45 ImplementationDefinition: "implements" Type "=" . "{" ImplementationDefinitionDefinitions "}"
+
+ "{" shift, and go to state 177
State 110
- 104 Expression: "-" Term .
- 105 | Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
-
- $default reduce using rule 104 (Expression)
+ 109 Expression: "(" . Term ")"
+ 110 | "(" . error ")"
+ 143 IndirectCallExpression: "(" . "*" Term ")" Arguments
+
+ error shift, and go to state 126
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "*" shift, and go to state 127
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 178
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 111
- 102 Expression: "(" error . ")"
-
- ")" shift, and go to state 171
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+ 196 ExpressionAttribute: Identifier Term .
+
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "implies" shift, and go to state 142
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "=>" shift, and go to state 153
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
+
+ $default reduce using rule 196 (ExpressionAttribute)
State 112
- 135 IndirectCallExpression: "(" "*" . Term ")" Arguments
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 172
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 10 AttributedDefinition: "[" Attributes "]" . Definition
+
+ error shift, and go to state 3
+ "init" shift, and go to state 4
+ "derived" shift, and go to state 5
+ "enum" shift, and go to state 6
+ "rule" shift, and go to state 7
+ "function" shift, and go to state 8
+ "structure" shift, and go to state 9
+ "feature" shift, and go to state 10
+ "implements" shift, and go to state 11
+
+ Definition go to state 179
+ FunctionDefinition go to state 16
+ ProgramFunctionDefinition go to state 17
+ DerivedDefinition go to state 18
+ EnumerationDefinition go to state 19
+ StructureDefinition go to state 20
+ FeatureDefinition go to state 21
+ ImplementationDefinition go to state 22
+ RuleDefinition go to state 23
State 113
- 101 Expression: "(" Term . ")"
- 105 | Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
- 128 Terms: Term .
-
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "implies" shift, and go to state 127
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- ")" shift, and go to state 173
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "=>" shift, and go to state 138
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
-
- $default reduce using rule 128 (Terms)
+ 193 Attributes: Attributes "," . Attribute
+
+ "in" shift, and go to state 26
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 45
+ Attribute go to state 180
+ BasicAttribute go to state 48
+ ExpressionAttribute go to state 49
State 114
- 127 Terms: Terms . "," Term
- 132 TwoOrMoreArguments: "(" Terms . "," Term ")"
+ 56 DotSeparatedIdentifiers: DotSeparatedIdentifiers . "." Identifier
+ 60 IdentifierPath: "this" "." DotSeparatedIdentifiers .
- "," shift, and go to state 174
+ $default reduce using rule 60 (IdentifierPath)
State 115
- 126 List: "[" error . "]"
+ 63 AttributedVariable: "[" . Attributes "]" Variable
+
+ "in" shift, and go to state 26
+ "identifier" shift, and go to state 29
- "]" shift, and go to state 175
+ Identifier go to state 45
+ Attribute go to state 46
+ Attributes go to state 181
+ BasicAttribute go to state 48
+ ExpressionAttribute go to state 49
State 116
- 124 List: "[" "]" .
+ 61 Variable: Identifier . ":" Type
+ 62 | Identifier .
+
+ ":" shift, and go to state 182
- $default reduce using rule 124 (List)
+ $default reduce using rule 62 (Variable)
State 117
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
- 123 Range: "[" Term . ".." Term "]"
- 128 Terms: Term .
-
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "implies" shift, and go to state 127
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- ".." shift, and go to state 176
- "=>" shift, and go to state 138
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
-
- $default reduce using rule 128 (Terms)
+ 64 AttributedVariable: Variable .
+
+ $default reduce using rule 64 (AttributedVariable)
State 118
- 125 List: "[" Terms . "]"
- 127 Terms: Terms . "," Term
+ 144 LetExpression: "let" AttributedVariable . "=" Term "in" Term
- "]" shift, and go to state 177
- "," shift, and go to state 178
+ "=" shift, and go to state 183
State 119
- 89 Reference: "@" IdentifierPath .
+ 147 UniversalQuantifierExpression: "forall" AttributedVariable . "in" Term "holds" Term
- $default reduce using rule 89 (Reference)
+ "in" shift, and go to state 184
State 120
- 30 Initializers: Initializers "," . Initializer
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 53
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Initializer go to state 179
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 75
- Expression go to state 76
- Range go to state 77
- List go to state 78
- TwoOrMoreArguments go to state 79
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 146 ChooseExpression: "choose" AttributedVariable . "in" Term "do" Term
+ "in" shift, and go to state 185
-State 121
- 26 ProgramFunctionDefinition: "init" "{" MaybeInitializers "}" .
+State 121
- $default reduce using rule 26 (ProgramFunctionDefinition)
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+ 145 ConditionalExpression: "if" Term . "then" Term "else" Term
+
+ "then" shift, and go to state 186
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "implies" shift, and go to state 142
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "=>" shift, and go to state 153
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
State 122
- 129 Arguments: "(" . Terms ")"
- 130 | "(" . error ")"
- 131 | "(" . ")"
-
- error shift, and go to state 180
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- ")" shift, and go to state 181
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 182
- Expression go to state 76
- Range go to state 77
- List go to state 78
- Terms go to state 183
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 148 ExistentialQuantifierExpression: "exists" AttributedVariable . "in" Term "with" Term
+ "in" shift, and go to state 187
-State 123
- 134 DirectCallExpression: IdentifierPath Arguments .
+State 123
- $default reduce using rule 134 (DirectCallExpression)
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+ 130 | "not" Term .
+
+ $default reduce using rule 130 (Expression)
State 124
- 119 Expression: Term "and" . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 184
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 111 Expression: "+" Term .
+ 113 | Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+
+ $default reduce using rule 111 (Expression)
State 125
- 117 Expression: Term "or" . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 185
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 112 Expression: "-" Term .
+ 113 | Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+
+ $default reduce using rule 112 (Expression)
State 126
- 118 Expression: Term "xor" . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 186
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 110 Expression: "(" error . ")"
+
+ ")" shift, and go to state 188
State 127
- 121 Expression: Term "implies" . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 187
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 143 IndirectCallExpression: "(" "*" . Term ")" Arguments
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 189
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 128
- 105 Expression: Term "+" . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 188
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 109 Expression: "(" Term . ")"
+ 113 | Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+ 136 Terms: Term .
+
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "implies" shift, and go to state 142
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ ")" shift, and go to state 190
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "=>" shift, and go to state 153
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
+
+ $default reduce using rule 136 (Terms)
State 129
- 106 Expression: Term "-" . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 189
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 135 Terms: Terms . "," Term
+ 140 TwoOrMoreArguments: "(" Terms . "," Term ")"
+
+ "," shift, and go to state 191
State 130
- 112 Expression: Term "=" . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 190
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 134 List: "[" error . "]"
+
+ "]" shift, and go to state 192
State 131
- 113 Expression: Term "<" . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 191
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 132 List: "[" "]" .
+
+ $default reduce using rule 132 (List)
State 132
- 114 Expression: Term ">" . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 192
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+ 131 Range: "[" Term . ".." Term "]"
+ 136 Terms: Term .
+
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "implies" shift, and go to state 142
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ ".." shift, and go to state 193
+ "=>" shift, and go to state 153
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
+
+ $default reduce using rule 136 (Terms)
State 133
- 107 Expression: Term "*" . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 193
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 133 List: "[" Terms . "]"
+ 135 Terms: Terms . "," Term
+
+ "]" shift, and go to state 194
+ "," shift, and go to state 195
State 134
- 108 Expression: Term "/" . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 194
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 97 Reference: "@" IdentifierPath .
+
+ $default reduce using rule 97 (Reference)
State 135
- 109 Expression: Term "%" . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 195
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 31 Initializers: Initializers "," . Initializer
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 63
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Initializer go to state 196
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 85
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ TwoOrMoreArguments go to state 89
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 136
- 110 Expression: Term "^" . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 196
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 27 ProgramFunctionDefinition: "init" "{" MaybeInitializers "}" .
+
+ $default reduce using rule 27 (ProgramFunctionDefinition)
State 137
- 28 Initializer: Term "->" . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 197
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 137 Arguments: "(" . Terms ")"
+ 138 | "(" . error ")"
+ 139 | "(" . ")"
+
+ error shift, and go to state 197
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ ")" shift, and go to state 198
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 199
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ Terms go to state 200
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 138
- 120 Expression: Term "=>" . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 198
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 142 DirectCallExpression: IdentifierPath Arguments .
+
+ $default reduce using rule 142 (DirectCallExpression)
State 139
- 111 Expression: Term "!=" . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 199
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 127 Expression: Term "and" . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 201
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 140
- 115 Expression: Term "<=" . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 200
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 125 Expression: Term "or" . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 202
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 141
- 116 Expression: Term ">=" . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 201
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 126 Expression: Term "xor" . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 203
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 142
- 29 Initializer: TwoOrMoreArguments "->" . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 202
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 129 Expression: Term "implies" . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 204
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 143
- 49 DotSeparatedIdentifiers: DotSeparatedIdentifiers "." Identifier .
-
- $default reduce using rule 49 (DotSeparatedIdentifiers)
+ 113 Expression: Term "+" . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 205
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 144
- 60 MaybeParameters: "(" error . ")"
-
- ")" shift, and go to state 203
+ 114 Expression: Term "-" . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 206
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 145
- 58 Parameters: AttributedVariable .
-
- $default reduce using rule 58 (Parameters)
+ 120 Expression: Term "=" . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 207
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 146
- 57 Parameters: Parameters . "," AttributedVariable
- 59 MaybeParameters: "(" Parameters . ")"
-
- ")" shift, and go to state 204
- "," shift, and go to state 205
+ 121 Expression: Term "<" . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 208
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 147
- 34 DerivedDefinition: "derived" Identifier MaybeParameters "->" . Type "=" Term
-
- "in" shift, and go to state 23
- "." shift, and go to state 25
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 153
- Type go to state 206
- BasicType go to state 155
- ComposedType go to state 156
- RelationType go to state 157
- FixedSizedType go to state 158
+ 122 Expression: Term ">" . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 209
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 148
- 35 EnumerationDefinition: "enum" Identifier "=" "{" . Identifiers "}"
-
- "in" shift, and go to state 23
- "identifier" shift, and go to state 26
-
- Identifier go to state 207
- Identifiers go to state 208
+ 115 Expression: Term "*" . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 210
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 149
- 141 RuleDefinition: "rule" Identifier MaybeParameters "=" . Rule
-
- "seq" shift, and go to state 209
- "par" shift, and go to state 210
- "skip" shift, and go to state 211
- "let" shift, and go to state 212
- "in" shift, and go to state 23
- "forall" shift, and go to state 213
- "choose" shift, and go to state 214
- "iterate" shift, and go to state 215
- "call" shift, and go to state 216
- "if" shift, and go to state 217
- "case" shift, and go to state 218
- "(" shift, and go to state 219
- "{" shift, and go to state 220
- "." shift, and go to state 25
- "{|" shift, and go to state 221
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- DirectCallExpression go to state 222
- IndirectCallExpression go to state 223
- Rule go to state 224
- SkipRule go to state 225
- ConditionalRule go to state 226
- CaseRule go to state 227
- LetRule go to state 228
- ForallRule go to state 229
- ChooseRule go to state 230
- IterateRule go to state 231
- BlockRule go to state 232
- SequenceRule go to state 233
- UpdateRule go to state 234
- CallRule go to state 235
+ 116 Expression: Term "/" . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 211
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 150
- 142 RuleDefinition: "rule" Identifier MaybeParameters "->" . Type "=" Rule
-
- "in" shift, and go to state 23
- "." shift, and go to state 25
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 153
- Type go to state 236
- BasicType go to state 155
- ComposedType go to state 156
- RelationType go to state 157
- FixedSizedType go to state 158
+ 117 Expression: Term "%" . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 212
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 151
- 21 FunctionParameters: FunctionParameters . "*" Type
- 23 MaybeFunctionParameters: FunctionParameters .
-
- "*" shift, and go to state 237
-
- $default reduce using rule 23 (MaybeFunctionParameters)
+ 118 Expression: Term "^" . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 213
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 152
- 13 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters . "->" Type MaybeDefined MaybeInitially
-
- "->" shift, and go to state 238
+ 29 Initializer: Term "->" . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 214
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 153
- 66 BasicType: IdentifierPath .
- 67 ComposedType: IdentifierPath . "<" Types ">"
- 68 RelationType: IdentifierPath . "<" MaybeFunctionParameters "->" Type ">"
- 69 FixedSizedType: IdentifierPath . "'" Term
-
- "<" shift, and go to state 239
- "'" shift, and go to state 240
-
- $default reduce using rule 66 (BasicType)
+ 128 Expression: Term "=>" . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 215
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 154
- 22 FunctionParameters: Type .
-
- $default reduce using rule 22 (FunctionParameters)
+ 119 Expression: Term "!=" . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 216
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 155
- 62 Type: BasicType .
-
- $default reduce using rule 62 (Type)
+ 123 Expression: Term "<=" . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 217
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 156
- 63 Type: ComposedType .
-
- $default reduce using rule 63 (Type)
+ 124 Expression: Term ">=" . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 218
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 157
- 64 Type: RelationType .
-
- $default reduce using rule 64 (Type)
+ 30 Initializer: TwoOrMoreArguments "->" . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 219
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 158
- 65 Type: FixedSizedType .
+ 56 DotSeparatedIdentifiers: DotSeparatedIdentifiers "." Identifier .
- $default reduce using rule 65 (Type)
+ $default reduce using rule 56 (DotSeparatedIdentifiers)
State 159
- 36 StructureDefinition: "structure" Identifier "=" "{" . FunctionDefinitions "}"
-
- "init" shift, and go to state 4
- "function" shift, and go to state 8
+ 68 MaybeParameters: "(" error . ")"
- FunctionDefinition go to state 241
- FunctionDefinitions go to state 242
- ProgramFunctionDefinition go to state 16
+ ")" shift, and go to state 220
State 160
- 37 FeatureDefinition: "feature" Identifier "=" "{" . FeatureDeclarationsAndDefinitions "}"
-
- "derived" shift, and go to state 243
- "rule" shift, and go to state 244
+ 66 Parameters: AttributedVariable .
- DerivedDefinition go to state 245
- FeatureDeclarationOrDefinition go to state 246
- FeatureDeclarationsAndDefinitions go to state 247
- DeclarationDefinition go to state 248
- RuleDefinition go to state 249
+ $default reduce using rule 66 (Parameters)
State 161
- 101 Expression: "(" Term . ")"
- 105 | Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
-
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "implies" shift, and go to state 127
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- ")" shift, and go to state 173
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "=>" shift, and go to state 138
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
+ 65 Parameters: Parameters . "," AttributedVariable
+ 67 MaybeParameters: "(" Parameters . ")"
+
+ ")" shift, and go to state 221
+ "," shift, and go to state 222
State 162
- 9 AttributedDefinition: "[" Attributes "]" Definition .
+ 35 DerivedDefinition: "derived" Identifier MaybeParameters "->" . Type "=" Term
+
+ "this" shift, and go to state 25
+ "in" shift, and go to state 26
+ "." shift, and go to state 28
+ "identifier" shift, and go to state 29
- $default reduce using rule 9 (AttributedDefinition)
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 168
+ Type go to state 223
+ BasicType go to state 41
+ ComposedType go to state 42
+ RelationType go to state 43
+ FixedSizedType go to state 44
State 163
- 185 Attributes: Attributes "," Attribute .
+ 36 EnumerationDefinition: "enum" Identifier "=" "{" . Identifiers "}"
- $default reduce using rule 185 (Attributes)
+ "in" shift, and go to state 26
+ "identifier" shift, and go to state 29
+ Identifier go to state 224
+ Identifiers go to state 225
-State 164
- 55 AttributedVariable: "[" Attributes . "]" Variable
- 185 Attributes: Attributes . "," Attribute
+State 164
- "]" shift, and go to state 250
- "," shift, and go to state 99
+ 149 RuleDefinition: "rule" Identifier MaybeParameters "=" . Rule
+
+ "this" shift, and go to state 25
+ "seq" shift, and go to state 226
+ "par" shift, and go to state 227
+ "skip" shift, and go to state 228
+ "let" shift, and go to state 229
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 230
+ "choose" shift, and go to state 231
+ "iterate" shift, and go to state 232
+ "call" shift, and go to state 233
+ "if" shift, and go to state 234
+ "case" shift, and go to state 235
+ "(" shift, and go to state 236
+ "{" shift, and go to state 237
+ "." shift, and go to state 28
+ "{|" shift, and go to state 238
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ DirectCallExpression go to state 239
+ IndirectCallExpression go to state 240
+ Rule go to state 241
+ SkipRule go to state 242
+ ConditionalRule go to state 243
+ CaseRule go to state 244
+ LetRule go to state 245
+ ForallRule go to state 246
+ ChooseRule go to state 247
+ IterateRule go to state 248
+ BlockRule go to state 249
+ SequenceRule go to state 250
+ UpdateRule go to state 251
+ CallRule go to state 252
State 165
- 53 Variable: Identifier ":" . Type
+ 150 RuleDefinition: "rule" Identifier MaybeParameters "->" . Type "=" Rule
- "in" shift, and go to state 23
- "." shift, and go to state 25
- "identifier" shift, and go to state 26
+ "this" shift, and go to state 25
+ "in" shift, and go to state 26
+ "." shift, and go to state 28
+ "identifier" shift, and go to state 29
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 153
- Type go to state 251
- BasicType go to state 155
- ComposedType go to state 156
- RelationType go to state 157
- FixedSizedType go to state 158
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 168
+ Type go to state 253
+ BasicType go to state 41
+ ComposedType go to state 42
+ RelationType go to state 43
+ FixedSizedType go to state 44
State 166
- 136 LetExpression: "let" AttributedVariable "=" . Term "in" Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 252
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 22 FunctionParameters: FunctionParameters . "*" Type
+ 24 MaybeFunctionParameters: FunctionParameters .
+
+ "*" shift, and go to state 254
+
+ $default reduce using rule 24 (MaybeFunctionParameters)
State 167
- 139 UniversalQuantifierExpression: "forall" AttributedVariable "in" . Term "holds" Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 253
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 14 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters . "->" Type MaybeDefined MaybeInitially
+
+ "->" shift, and go to state 255
State 168
- 138 ChooseExpression: "choose" AttributedVariable "in" . Term "do" Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 254
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 74 BasicType: IdentifierPath .
+ 75 ComposedType: IdentifierPath . "<" Types ">"
+ 76 RelationType: IdentifierPath . "<" MaybeFunctionParameters "->" Type ">"
+ 77 FixedSizedType: IdentifierPath . "'" Term
+
+ "<" shift, and go to state 107
+ "'" shift, and go to state 108
+
+ $default reduce using rule 74 (BasicType)
State 169
- 137 ConditionalExpression: "if" Term "then" . Term "else" Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 255
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 23 FunctionParameters: Type .
+
+ $default reduce using rule 23 (FunctionParameters)
State 170
- 140 ExistentialQuantifierExpression: "exists" AttributedVariable "in" . Term "with" Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 256
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 37 StructureDefinition: "structure" Identifier "=" "{" . FunctionDefinitions "}"
+
+ "init" shift, and go to state 4
+ "function" shift, and go to state 8
+
+ FunctionDefinition go to state 256
+ FunctionDefinitions go to state 257
+ ProgramFunctionDefinition go to state 17
State 171
- 102 Expression: "(" error ")" .
+ 38 FeatureDefinition: "feature" Identifier "=" "{" . FeatureDeclarationsAndDefinitions "}"
+
+ "derived" shift, and go to state 258
+ "rule" shift, and go to state 259
- $default reduce using rule 102 (Expression)
+ DerivedDefinition go to state 260
+ FeatureDeclarationOrDefinition go to state 261
+ FeatureDeclarationsAndDefinitions go to state 262
+ DeclarationDefinition go to state 263
+ RuleDefinition go to state 264
State 172
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
- 135 IndirectCallExpression: "(" "*" Term . ")" Arguments
-
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "implies" shift, and go to state 127
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- ")" shift, and go to state 257
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "=>" shift, and go to state 138
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
+ 44 ImplementationDefinition: "implements" IdentifierPath "for" Type . "=" "{" ImplementationDefinitionDefinitions "}"
+
+ "=" shift, and go to state 265
State 173
- 101 Expression: "(" Term ")" .
+ 76 RelationType: IdentifierPath "<" MaybeFunctionParameters . "->" Type ">"
- $default reduce using rule 101 (Expression)
+ "->" shift, and go to state 266
State 174
- 127 Terms: Terms "," . Term
- 132 TwoOrMoreArguments: "(" Terms "," . Term ")"
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 258
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 23 FunctionParameters: Type .
+ 79 Types: Type .
+
+ "," reduce using rule 79 (Types)
+ ">" reduce using rule 79 (Types)
+ $default reduce using rule 23 (FunctionParameters)
State 175
- 126 List: "[" error "]" .
+ 75 ComposedType: IdentifierPath "<" Types . ">"
+ 78 Types: Types . "," Type
- $default reduce using rule 126 (List)
+ "," shift, and go to state 267
+ ">" shift, and go to state 268
State 176
- 123 Range: "[" Term ".." . Term "]"
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 259
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 77 FixedSizedType: IdentifierPath "'" Term .
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "implies" shift, and go to state 142
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "<" shift, and go to state 146
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "=>" shift, and go to state 153
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
+
+ $default reduce using rule 77 (FixedSizedType)
State 177
- 125 List: "[" Terms "]" .
+ 45 ImplementationDefinition: "implements" Type "=" "{" . ImplementationDefinitionDefinitions "}"
+
+ "derived" shift, and go to state 5
+ "rule" shift, and go to state 7
- $default reduce using rule 125 (List)
+ DerivedDefinition go to state 269
+ ImplementationDefinitionDefinition go to state 270
+ ImplementationDefinitionDefinitions go to state 271
+ RuleDefinition go to state 272
State 178
- 127 Terms: Terms "," . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 260
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 109 Expression: "(" Term . ")"
+ 113 | Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "implies" shift, and go to state 142
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ ")" shift, and go to state 190
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "=>" shift, and go to state 153
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
State 179
- 30 Initializers: Initializers "," Initializer .
+ 10 AttributedDefinition: "[" Attributes "]" Definition .
- $default reduce using rule 30 (Initializers)
+ $default reduce using rule 10 (AttributedDefinition)
State 180
- 130 Arguments: "(" error . ")"
+ 193 Attributes: Attributes "," Attribute .
- ")" shift, and go to state 261
+ $default reduce using rule 193 (Attributes)
State 181
- 131 Arguments: "(" ")" .
+ 63 AttributedVariable: "[" Attributes . "]" Variable
+ 193 Attributes: Attributes . "," Attribute
- $default reduce using rule 131 (Arguments)
+ "]" shift, and go to state 273
+ "," shift, and go to state 113
State 182
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
- 128 Terms: Term .
-
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "implies" shift, and go to state 127
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "=>" shift, and go to state 138
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
-
- $default reduce using rule 128 (Terms)
+ 61 Variable: Identifier ":" . Type
+ "this" shift, and go to state 25
+ "in" shift, and go to state 26
+ "." shift, and go to state 28
+ "identifier" shift, and go to state 29
-State 183
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 168
+ Type go to state 274
+ BasicType go to state 41
+ ComposedType go to state 42
+ RelationType go to state 43
+ FixedSizedType go to state 44
- 127 Terms: Terms . "," Term
- 129 Arguments: "(" Terms . ")"
- ")" shift, and go to state 262
- "," shift, and go to state 178
+State 183
+ 144 LetExpression: "let" AttributedVariable "=" . Term "in" Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 275
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
-State 184
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 119 | Term "and" Term .
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
-
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
+State 184
- $default reduce using rule 119 (Expression)
+ 147 UniversalQuantifierExpression: "forall" AttributedVariable "in" . Term "holds" Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 276
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 185
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 117 | Term "or" Term .
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
-
- "and" shift, and go to state 124
- "xor" shift, and go to state 126
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
-
- $default reduce using rule 117 (Expression)
+ 146 ChooseExpression: "choose" AttributedVariable "in" . Term "do" Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 277
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 186
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 118 | Term "xor" Term .
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
-
- "and" shift, and go to state 124
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
-
- $default reduce using rule 118 (Expression)
+ 145 ConditionalExpression: "if" Term "then" . Term "else" Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 278
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 187
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
- 121 | Term "implies" Term .
-
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
-
- $default reduce using rule 121 (Expression)
+ 148 ExistentialQuantifierExpression: "exists" AttributedVariable "in" . Term "with" Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 279
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 188
- 105 Expression: Term . "+" Term
- 105 | Term "+" Term .
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
-
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
-
- $default reduce using rule 105 (Expression)
+ 110 Expression: "(" error ")" .
+
+ $default reduce using rule 110 (Expression)
State 189
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 106 | Term "-" Term .
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
-
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
-
- $default reduce using rule 106 (Expression)
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+ 143 IndirectCallExpression: "(" "*" Term . ")" Arguments
+
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "implies" shift, and go to state 142
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ ")" shift, and go to state 280
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "=>" shift, and go to state 153
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
State 190
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 112 | Term "=" Term .
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
-
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
+ 109 Expression: "(" Term ")" .
- $default reduce using rule 112 (Expression)
+ $default reduce using rule 109 (Expression)
State 191
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 113 | Term "<" Term .
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
-
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
-
- $default reduce using rule 113 (Expression)
+ 135 Terms: Terms "," . Term
+ 140 TwoOrMoreArguments: "(" Terms "," . Term ")"
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 281
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 192
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 114 | Term ">" Term .
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
-
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
+ 134 List: "[" error "]" .
- $default reduce using rule 114 (Expression)
+ $default reduce using rule 134 (List)
State 193
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 107 | Term "*" Term .
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
-
- "^" shift, and go to state 136
-
- $default reduce using rule 107 (Expression)
+ 131 Range: "[" Term ".." . Term "]"
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 282
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 194
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 108 | Term "/" Term .
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
-
- "^" shift, and go to state 136
-
- $default reduce using rule 108 (Expression)
+ 133 List: "[" Terms "]" .
+ $default reduce using rule 133 (List)
-State 195
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 109 | Term "%" Term .
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
-
- "^" shift, and go to state 136
+State 195
- $default reduce using rule 109 (Expression)
+ 135 Terms: Terms "," . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 283
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 196
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 110 | Term "^" Term .
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
+ 31 Initializers: Initializers "," Initializer .
- $default reduce using rule 110 (Expression)
+ $default reduce using rule 31 (Initializers)
State 197
- 28 Initializer: Term "->" Term .
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
-
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "implies" shift, and go to state 127
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "=>" shift, and go to state 138
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
+ 138 Arguments: "(" error . ")"
- $default reduce using rule 28 (Initializer)
+ ")" shift, and go to state 284
State 198
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 120 | Term "=>" Term .
- 121 | Term . "implies" Term
-
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
+ 139 Arguments: "(" ")" .
- $default reduce using rule 120 (Expression)
+ $default reduce using rule 139 (Arguments)
State 199
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 111 | Term "!=" Term .
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
-
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
-
- $default reduce using rule 111 (Expression)
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+ 136 Terms: Term .
+
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "implies" shift, and go to state 142
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "=>" shift, and go to state 153
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
+
+ $default reduce using rule 136 (Terms)
State 200
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 115 | Term "<=" Term .
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
-
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
+ 135 Terms: Terms . "," Term
+ 137 Arguments: "(" Terms . ")"
- $default reduce using rule 115 (Expression)
+ ")" shift, and go to state 285
+ "," shift, and go to state 195
State 201
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 116 | Term ">=" Term .
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
-
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
-
- $default reduce using rule 116 (Expression)
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 127 | Term "and" Term .
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
+
+ $default reduce using rule 127 (Expression)
State 202
- 29 Initializer: TwoOrMoreArguments "->" Term .
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
-
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "implies" shift, and go to state 127
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "=>" shift, and go to state 138
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
-
- $default reduce using rule 29 (Initializer)
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 125 | Term "or" Term .
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+
+ "and" shift, and go to state 139
+ "xor" shift, and go to state 141
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
+
+ $default reduce using rule 125 (Expression)
State 203
- 60 MaybeParameters: "(" error ")" .
-
- $default reduce using rule 60 (MaybeParameters)
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 126 | Term "xor" Term .
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+
+ "and" shift, and go to state 139
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
+
+ $default reduce using rule 126 (Expression)
State 204
- 59 MaybeParameters: "(" Parameters ")" .
-
- $default reduce using rule 59 (MaybeParameters)
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+ 129 | Term "implies" Term .
+
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
+
+ $default reduce using rule 129 (Expression)
State 205
- 57 Parameters: Parameters "," . AttributedVariable
-
- "in" shift, and go to state 23
- "[" shift, and go to state 100
- "identifier" shift, and go to state 26
+ 113 Expression: Term . "+" Term
+ 113 | Term "+" Term .
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
- Identifier go to state 101
- Variable go to state 102
- AttributedVariable go to state 263
+ $default reduce using rule 113 (Expression)
State 206
- 34 DerivedDefinition: "derived" Identifier MaybeParameters "->" Type . "=" Term
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 114 | Term "-" Term .
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
- "=" shift, and go to state 264
+ $default reduce using rule 114 (Expression)
State 207
- 48 Identifiers: Identifier .
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 120 | Term "=" Term .
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
- $default reduce using rule 48 (Identifiers)
+ $default reduce using rule 120 (Expression)
State 208
- 35 EnumerationDefinition: "enum" Identifier "=" "{" Identifiers . "}"
- 47 Identifiers: Identifiers . "," Identifier
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 121 | Term "<" Term .
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
- "}" shift, and go to state 265
- "," shift, and go to state 266
+ $default reduce using rule 121 (Expression)
State 209
- 175 SequenceRule: "seq" . Rules "endseq"
- 177 | "seq" . error "endseq"
-
- error shift, and go to state 267
- "seq" shift, and go to state 209
- "par" shift, and go to state 210
- "skip" shift, and go to state 211
- "let" shift, and go to state 212
- "in" shift, and go to state 23
- "forall" shift, and go to state 213
- "choose" shift, and go to state 214
- "iterate" shift, and go to state 215
- "call" shift, and go to state 216
- "if" shift, and go to state 217
- "case" shift, and go to state 218
- "(" shift, and go to state 219
- "{" shift, and go to state 220
- "." shift, and go to state 25
- "{|" shift, and go to state 221
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- DirectCallExpression go to state 222
- IndirectCallExpression go to state 223
- Rule go to state 268
- Rules go to state 269
- SkipRule go to state 225
- ConditionalRule go to state 226
- CaseRule go to state 227
- LetRule go to state 228
- ForallRule go to state 229
- ChooseRule go to state 230
- IterateRule go to state 231
- BlockRule go to state 232
- SequenceRule go to state 233
- UpdateRule go to state 234
- CallRule go to state 235
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 122 | Term ">" Term .
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+
+ $default reduce using rule 122 (Expression)
State 210
- 171 BlockRule: "par" . Rules "endpar"
- 173 | "par" . error "endpar"
-
- error shift, and go to state 270
- "seq" shift, and go to state 209
- "par" shift, and go to state 210
- "skip" shift, and go to state 211
- "let" shift, and go to state 212
- "in" shift, and go to state 23
- "forall" shift, and go to state 213
- "choose" shift, and go to state 214
- "iterate" shift, and go to state 215
- "call" shift, and go to state 216
- "if" shift, and go to state 217
- "case" shift, and go to state 218
- "(" shift, and go to state 219
- "{" shift, and go to state 220
- "." shift, and go to state 25
- "{|" shift, and go to state 221
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- DirectCallExpression go to state 222
- IndirectCallExpression go to state 223
- Rule go to state 268
- Rules go to state 271
- SkipRule go to state 225
- ConditionalRule go to state 226
- CaseRule go to state 227
- LetRule go to state 228
- ForallRule go to state 229
- ChooseRule go to state 230
- IterateRule go to state 231
- BlockRule go to state 232
- SequenceRule go to state 233
- UpdateRule go to state 234
- CallRule go to state 235
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 115 | Term "*" Term .
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+
+ "^" shift, and go to state 151
+
+ $default reduce using rule 115 (Expression)
State 211
- 156 SkipRule: "skip" .
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 116 | Term "/" Term .
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+
+ "^" shift, and go to state 151
- $default reduce using rule 156 (SkipRule)
+ $default reduce using rule 116 (Expression)
State 212
- 166 LetRule: "let" . AttributedVariable "=" Term "in" Rule
-
- "in" shift, and go to state 23
- "[" shift, and go to state 100
- "identifier" shift, and go to state 26
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 117 | Term "%" Term .
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+
+ "^" shift, and go to state 151
- Identifier go to state 101
- Variable go to state 102
- AttributedVariable go to state 272
+ $default reduce using rule 117 (Expression)
State 213
- 167 ForallRule: "forall" . AttributedVariable "in" Term "do" Rule
-
- "in" shift, and go to state 23
- "[" shift, and go to state 100
- "identifier" shift, and go to state 26
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 118 | Term "^" Term .
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
- Identifier go to state 101
- Variable go to state 102
- AttributedVariable go to state 273
+ $default reduce using rule 118 (Expression)
State 214
- 168 ChooseRule: "choose" . AttributedVariable "in" Term "do" Rule
-
- "in" shift, and go to state 23
- "[" shift, and go to state 100
- "identifier" shift, and go to state 26
+ 29 Initializer: Term "->" Term .
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "implies" shift, and go to state 142
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "=>" shift, and go to state 153
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
- Identifier go to state 101
- Variable go to state 102
- AttributedVariable go to state 274
+ $default reduce using rule 29 (Initializer)
State 215
- 169 IterateRule: "iterate" . Rule
-
- "seq" shift, and go to state 209
- "par" shift, and go to state 210
- "skip" shift, and go to state 211
- "let" shift, and go to state 212
- "in" shift, and go to state 23
- "forall" shift, and go to state 213
- "choose" shift, and go to state 214
- "iterate" shift, and go to state 215
- "call" shift, and go to state 216
- "if" shift, and go to state 217
- "case" shift, and go to state 218
- "(" shift, and go to state 219
- "{" shift, and go to state 220
- "." shift, and go to state 25
- "{|" shift, and go to state 221
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- DirectCallExpression go to state 222
- IndirectCallExpression go to state 223
- Rule go to state 275
- SkipRule go to state 225
- ConditionalRule go to state 226
- CaseRule go to state 227
- LetRule go to state 228
- ForallRule go to state 229
- ChooseRule go to state 230
- IterateRule go to state 231
- BlockRule go to state 232
- SequenceRule go to state 233
- UpdateRule go to state 234
- CallRule go to state 235
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 128 | Term "=>" Term .
+ 129 | Term . "implies" Term
+
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
+
+ $default reduce using rule 128 (Expression)
State 216
- 179 CallRule: "call" . DirectCallExpression
- 181 | "call" . IndirectCallExpression
-
- "in" shift, and go to state 23
- "(" shift, and go to state 219
- "." shift, and go to state 25
- "identifier" shift, and go to state 26
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 119 | Term "!=" Term .
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- DirectCallExpression go to state 276
- IndirectCallExpression go to state 277
+ $default reduce using rule 119 (Expression)
State 217
- 157 ConditionalRule: "if" . Term "then" Rule
- 158 | "if" . Term "then" Rule "else" Rule
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 278
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 123 | Term "<=" Term .
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+
+ $default reduce using rule 123 (Expression)
State 218
- 159 CaseRule: "case" . Term "of" "{" CaseLabels "}"
- 160 | "case" . Term "of" "{" error "}"
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 279
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 124 | Term ">=" Term .
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+
+ $default reduce using rule 124 (Expression)
State 219
- 135 IndirectCallExpression: "(" . "*" Term ")" Arguments
-
- "*" shift, and go to state 112
+ 30 Initializer: TwoOrMoreArguments "->" Term .
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "implies" shift, and go to state 142
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "=>" shift, and go to state 153
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
+
+ $default reduce using rule 30 (Initializer)
State 220
- 170 BlockRule: "{" . Rules "}"
- 172 | "{" . error "}"
-
- error shift, and go to state 280
- "seq" shift, and go to state 209
- "par" shift, and go to state 210
- "skip" shift, and go to state 211
- "let" shift, and go to state 212
- "in" shift, and go to state 23
- "forall" shift, and go to state 213
- "choose" shift, and go to state 214
- "iterate" shift, and go to state 215
- "call" shift, and go to state 216
- "if" shift, and go to state 217
- "case" shift, and go to state 218
- "(" shift, and go to state 219
- "{" shift, and go to state 220
- "." shift, and go to state 25
- "{|" shift, and go to state 221
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- DirectCallExpression go to state 222
- IndirectCallExpression go to state 223
- Rule go to state 268
- Rules go to state 281
- SkipRule go to state 225
- ConditionalRule go to state 226
- CaseRule go to state 227
- LetRule go to state 228
- ForallRule go to state 229
- ChooseRule go to state 230
- IterateRule go to state 231
- BlockRule go to state 232
- SequenceRule go to state 233
- UpdateRule go to state 234
- CallRule go to state 235
+ 68 MaybeParameters: "(" error ")" .
+
+ $default reduce using rule 68 (MaybeParameters)
State 221
- 174 SequenceRule: "{|" . Rules "|}"
- 176 | "{|" . error "|}"
-
- error shift, and go to state 282
- "seq" shift, and go to state 209
- "par" shift, and go to state 210
- "skip" shift, and go to state 211
- "let" shift, and go to state 212
- "in" shift, and go to state 23
- "forall" shift, and go to state 213
- "choose" shift, and go to state 214
- "iterate" shift, and go to state 215
- "call" shift, and go to state 216
- "if" shift, and go to state 217
- "case" shift, and go to state 218
- "(" shift, and go to state 219
- "{" shift, and go to state 220
- "." shift, and go to state 25
- "{|" shift, and go to state 221
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- DirectCallExpression go to state 222
- IndirectCallExpression go to state 223
- Rule go to state 268
- Rules go to state 283
- SkipRule go to state 225
- ConditionalRule go to state 226
- CaseRule go to state 227
- LetRule go to state 228
- ForallRule go to state 229
- ChooseRule go to state 230
- IterateRule go to state 231
- BlockRule go to state 232
- SequenceRule go to state 233
- UpdateRule go to state 234
- CallRule go to state 235
+ 67 MaybeParameters: "(" Parameters ")" .
+
+ $default reduce using rule 67 (MaybeParameters)
State 222
- 178 UpdateRule: DirectCallExpression . ":=" Term
- 180 CallRule: DirectCallExpression .
+ 65 Parameters: Parameters "," . AttributedVariable
- ":=" shift, and go to state 284
+ "in" shift, and go to state 26
+ "[" shift, and go to state 115
+ "identifier" shift, and go to state 29
- $default reduce using rule 180 (CallRule)
+ Identifier go to state 116
+ Variable go to state 117
+ AttributedVariable go to state 286
State 223
- 182 CallRule: IndirectCallExpression .
+ 35 DerivedDefinition: "derived" Identifier MaybeParameters "->" Type . "=" Term
- $default reduce using rule 182 (CallRule)
+ "=" shift, and go to state 287
State 224
- 141 RuleDefinition: "rule" Identifier MaybeParameters "=" Rule .
+ 55 Identifiers: Identifier .
- $default reduce using rule 141 (RuleDefinition)
+ $default reduce using rule 55 (Identifiers)
State 225
- 143 Rule: SkipRule .
+ 36 EnumerationDefinition: "enum" Identifier "=" "{" Identifiers . "}"
+ 54 Identifiers: Identifiers . "," Identifier
- $default reduce using rule 143 (Rule)
+ "}" shift, and go to state 288
+ "," shift, and go to state 289
State 226
- 144 Rule: ConditionalRule .
-
- $default reduce using rule 144 (Rule)
+ 183 SequenceRule: "seq" . Rules "endseq"
+ 185 | "seq" . error "endseq"
+
+ error shift, and go to state 290
+ "this" shift, and go to state 25
+ "seq" shift, and go to state 226
+ "par" shift, and go to state 227
+ "skip" shift, and go to state 228
+ "let" shift, and go to state 229
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 230
+ "choose" shift, and go to state 231
+ "iterate" shift, and go to state 232
+ "call" shift, and go to state 233
+ "if" shift, and go to state 234
+ "case" shift, and go to state 235
+ "(" shift, and go to state 236
+ "{" shift, and go to state 237
+ "." shift, and go to state 28
+ "{|" shift, and go to state 238
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ DirectCallExpression go to state 239
+ IndirectCallExpression go to state 240
+ Rule go to state 291
+ Rules go to state 292
+ SkipRule go to state 242
+ ConditionalRule go to state 243
+ CaseRule go to state 244
+ LetRule go to state 245
+ ForallRule go to state 246
+ ChooseRule go to state 247
+ IterateRule go to state 248
+ BlockRule go to state 249
+ SequenceRule go to state 250
+ UpdateRule go to state 251
+ CallRule go to state 252
State 227
- 145 Rule: CaseRule .
-
- $default reduce using rule 145 (Rule)
+ 179 BlockRule: "par" . Rules "endpar"
+ 181 | "par" . error "endpar"
+
+ error shift, and go to state 293
+ "this" shift, and go to state 25
+ "seq" shift, and go to state 226
+ "par" shift, and go to state 227
+ "skip" shift, and go to state 228
+ "let" shift, and go to state 229
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 230
+ "choose" shift, and go to state 231
+ "iterate" shift, and go to state 232
+ "call" shift, and go to state 233
+ "if" shift, and go to state 234
+ "case" shift, and go to state 235
+ "(" shift, and go to state 236
+ "{" shift, and go to state 237
+ "." shift, and go to state 28
+ "{|" shift, and go to state 238
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ DirectCallExpression go to state 239
+ IndirectCallExpression go to state 240
+ Rule go to state 291
+ Rules go to state 294
+ SkipRule go to state 242
+ ConditionalRule go to state 243
+ CaseRule go to state 244
+ LetRule go to state 245
+ ForallRule go to state 246
+ ChooseRule go to state 247
+ IterateRule go to state 248
+ BlockRule go to state 249
+ SequenceRule go to state 250
+ UpdateRule go to state 251
+ CallRule go to state 252
State 228
- 146 Rule: LetRule .
+ 164 SkipRule: "skip" .
- $default reduce using rule 146 (Rule)
+ $default reduce using rule 164 (SkipRule)
State 229
- 147 Rule: ForallRule .
+ 174 LetRule: "let" . AttributedVariable "=" Term "in" Rule
- $default reduce using rule 147 (Rule)
+ "in" shift, and go to state 26
+ "[" shift, and go to state 115
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 116
+ Variable go to state 117
+ AttributedVariable go to state 295
State 230
- 148 Rule: ChooseRule .
+ 175 ForallRule: "forall" . AttributedVariable "in" Term "do" Rule
+
+ "in" shift, and go to state 26
+ "[" shift, and go to state 115
+ "identifier" shift, and go to state 29
- $default reduce using rule 148 (Rule)
+ Identifier go to state 116
+ Variable go to state 117
+ AttributedVariable go to state 296
State 231
- 149 Rule: IterateRule .
+ 176 ChooseRule: "choose" . AttributedVariable "in" Term "do" Rule
- $default reduce using rule 149 (Rule)
+ "in" shift, and go to state 26
+ "[" shift, and go to state 115
+ "identifier" shift, and go to state 29
+ Identifier go to state 116
+ Variable go to state 117
+ AttributedVariable go to state 297
-State 232
- 150 Rule: BlockRule .
+State 232
- $default reduce using rule 150 (Rule)
+ 177 IterateRule: "iterate" . Rule
+
+ "this" shift, and go to state 25
+ "seq" shift, and go to state 226
+ "par" shift, and go to state 227
+ "skip" shift, and go to state 228
+ "let" shift, and go to state 229
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 230
+ "choose" shift, and go to state 231
+ "iterate" shift, and go to state 232
+ "call" shift, and go to state 233
+ "if" shift, and go to state 234
+ "case" shift, and go to state 235
+ "(" shift, and go to state 236
+ "{" shift, and go to state 237
+ "." shift, and go to state 28
+ "{|" shift, and go to state 238
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ DirectCallExpression go to state 239
+ IndirectCallExpression go to state 240
+ Rule go to state 298
+ SkipRule go to state 242
+ ConditionalRule go to state 243
+ CaseRule go to state 244
+ LetRule go to state 245
+ ForallRule go to state 246
+ ChooseRule go to state 247
+ IterateRule go to state 248
+ BlockRule go to state 249
+ SequenceRule go to state 250
+ UpdateRule go to state 251
+ CallRule go to state 252
State 233
- 151 Rule: SequenceRule .
+ 187 CallRule: "call" . DirectCallExpression
+ 189 | "call" . IndirectCallExpression
- $default reduce using rule 151 (Rule)
+ "this" shift, and go to state 25
+ "in" shift, and go to state 26
+ "(" shift, and go to state 236
+ "." shift, and go to state 28
+ "identifier" shift, and go to state 29
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ DirectCallExpression go to state 299
+ IndirectCallExpression go to state 300
-State 234
- 152 Rule: UpdateRule .
+State 234
- $default reduce using rule 152 (Rule)
+ 165 ConditionalRule: "if" . Term "then" Rule
+ 166 | "if" . Term "then" Rule "else" Rule
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 301
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 235
- 153 Rule: CallRule .
-
- $default reduce using rule 153 (Rule)
+ 167 CaseRule: "case" . Term "of" "{" CaseLabels "}"
+ 168 | "case" . Term "of" "{" error "}"
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 302
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 236
- 142 RuleDefinition: "rule" Identifier MaybeParameters "->" Type . "=" Rule
+ 143 IndirectCallExpression: "(" . "*" Term ")" Arguments
- "=" shift, and go to state 285
+ "*" shift, and go to state 127
State 237
- 21 FunctionParameters: FunctionParameters "*" . Type
-
- "in" shift, and go to state 23
- "." shift, and go to state 25
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 153
- Type go to state 286
- BasicType go to state 155
- ComposedType go to state 156
- RelationType go to state 157
- FixedSizedType go to state 158
+ 178 BlockRule: "{" . Rules "}"
+ 180 | "{" . error "}"
+
+ error shift, and go to state 303
+ "this" shift, and go to state 25
+ "seq" shift, and go to state 226
+ "par" shift, and go to state 227
+ "skip" shift, and go to state 228
+ "let" shift, and go to state 229
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 230
+ "choose" shift, and go to state 231
+ "iterate" shift, and go to state 232
+ "call" shift, and go to state 233
+ "if" shift, and go to state 234
+ "case" shift, and go to state 235
+ "(" shift, and go to state 236
+ "{" shift, and go to state 237
+ "." shift, and go to state 28
+ "{|" shift, and go to state 238
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ DirectCallExpression go to state 239
+ IndirectCallExpression go to state 240
+ Rule go to state 291
+ Rules go to state 304
+ SkipRule go to state 242
+ ConditionalRule go to state 243
+ CaseRule go to state 244
+ LetRule go to state 245
+ ForallRule go to state 246
+ ChooseRule go to state 247
+ IterateRule go to state 248
+ BlockRule go to state 249
+ SequenceRule go to state 250
+ UpdateRule go to state 251
+ CallRule go to state 252
State 238
- 13 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" . Type MaybeDefined MaybeInitially
-
- "in" shift, and go to state 23
- "." shift, and go to state 25
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 153
- Type go to state 287
- BasicType go to state 155
- ComposedType go to state 156
- RelationType go to state 157
- FixedSizedType go to state 158
+ 182 SequenceRule: "{|" . Rules "|}"
+ 184 | "{|" . error "|}"
+
+ error shift, and go to state 305
+ "this" shift, and go to state 25
+ "seq" shift, and go to state 226
+ "par" shift, and go to state 227
+ "skip" shift, and go to state 228
+ "let" shift, and go to state 229
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 230
+ "choose" shift, and go to state 231
+ "iterate" shift, and go to state 232
+ "call" shift, and go to state 233
+ "if" shift, and go to state 234
+ "case" shift, and go to state 235
+ "(" shift, and go to state 236
+ "{" shift, and go to state 237
+ "." shift, and go to state 28
+ "{|" shift, and go to state 238
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ DirectCallExpression go to state 239
+ IndirectCallExpression go to state 240
+ Rule go to state 291
+ Rules go to state 306
+ SkipRule go to state 242
+ ConditionalRule go to state 243
+ CaseRule go to state 244
+ LetRule go to state 245
+ ForallRule go to state 246
+ ChooseRule go to state 247
+ IterateRule go to state 248
+ BlockRule go to state 249
+ SequenceRule go to state 250
+ UpdateRule go to state 251
+ CallRule go to state 252
State 239
- 67 ComposedType: IdentifierPath "<" . Types ">"
- 68 RelationType: IdentifierPath "<" . MaybeFunctionParameters "->" Type ">"
+ 186 UpdateRule: DirectCallExpression . ":=" Term
+ 188 CallRule: DirectCallExpression .
- "in" shift, and go to state 23
- "." shift, and go to state 25
- "identifier" shift, and go to state 26
+ ":=" shift, and go to state 307
- $default reduce using rule 24 (MaybeFunctionParameters)
-
- FunctionParameters go to state 151
- MaybeFunctionParameters go to state 288
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 153
- Type go to state 289
- BasicType go to state 155
- ComposedType go to state 156
- RelationType go to state 157
- FixedSizedType go to state 158
- Types go to state 290
+ $default reduce using rule 188 (CallRule)
State 240
- 69 FixedSizedType: IdentifierPath "'" . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 291
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 190 CallRule: IndirectCallExpression .
+
+ $default reduce using rule 190 (CallRule)
State 241
- 16 FunctionDefinitions: FunctionDefinition .
+ 149 RuleDefinition: "rule" Identifier MaybeParameters "=" Rule .
- $default reduce using rule 16 (FunctionDefinitions)
+ $default reduce using rule 149 (RuleDefinition)
State 242
- 15 FunctionDefinitions: FunctionDefinitions . "," FunctionDefinition
- 36 StructureDefinition: "structure" Identifier "=" "{" FunctionDefinitions . "}"
+ 151 Rule: SkipRule .
- "}" shift, and go to state 292
- "," shift, and go to state 293
+ $default reduce using rule 151 (Rule)
State 243
- 34 DerivedDefinition: "derived" . Identifier MaybeParameters "->" Type "=" Term
- 43 DeclarationDefinition: "derived" . Identifier ":" MaybeFunctionParameters "->" Type
-
- "in" shift, and go to state 23
- "identifier" shift, and go to state 26
+ 152 Rule: ConditionalRule .
- Identifier go to state 294
+ $default reduce using rule 152 (Rule)
State 244
- 44 DeclarationDefinition: "rule" . Identifier ":" MaybeFunctionParameters "->" Type
- 141 RuleDefinition: "rule" . Identifier MaybeParameters "=" Rule
- 142 | "rule" . Identifier MaybeParameters "->" Type "=" Rule
+ 153 Rule: CaseRule .
- "in" shift, and go to state 23
- "identifier" shift, and go to state 26
-
- Identifier go to state 295
+ $default reduce using rule 153 (Rule)
State 245
- 39 FeatureDeclarationOrDefinition: DerivedDefinition .
+ 154 Rule: LetRule .
- $default reduce using rule 39 (FeatureDeclarationOrDefinition)
+ $default reduce using rule 154 (Rule)
State 246
- 42 FeatureDeclarationsAndDefinitions: FeatureDeclarationOrDefinition .
+ 155 Rule: ForallRule .
- $default reduce using rule 42 (FeatureDeclarationsAndDefinitions)
+ $default reduce using rule 155 (Rule)
State 247
- 37 FeatureDefinition: "feature" Identifier "=" "{" FeatureDeclarationsAndDefinitions . "}"
- 41 FeatureDeclarationsAndDefinitions: FeatureDeclarationsAndDefinitions . "," FeatureDeclarationOrDefinition
+ 156 Rule: ChooseRule .
- "}" shift, and go to state 296
- "," shift, and go to state 297
+ $default reduce using rule 156 (Rule)
State 248
- 38 FeatureDeclarationOrDefinition: DeclarationDefinition .
+ 157 Rule: IterateRule .
- $default reduce using rule 38 (FeatureDeclarationOrDefinition)
+ $default reduce using rule 157 (Rule)
State 249
- 40 FeatureDeclarationOrDefinition: RuleDefinition .
+ 158 Rule: BlockRule .
- $default reduce using rule 40 (FeatureDeclarationOrDefinition)
+ $default reduce using rule 158 (Rule)
State 250
- 55 AttributedVariable: "[" Attributes "]" . Variable
-
- "in" shift, and go to state 23
- "identifier" shift, and go to state 26
+ 159 Rule: SequenceRule .
- Identifier go to state 101
- Variable go to state 298
+ $default reduce using rule 159 (Rule)
State 251
- 53 Variable: Identifier ":" Type .
+ 160 Rule: UpdateRule .
- $default reduce using rule 53 (Variable)
+ $default reduce using rule 160 (Rule)
State 252
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
- 136 LetExpression: "let" AttributedVariable "=" Term . "in" Term
-
- "in" shift, and go to state 299
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "implies" shift, and go to state 127
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "=>" shift, and go to state 138
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
+ 161 Rule: CallRule .
+
+ $default reduce using rule 161 (Rule)
State 253
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
- 139 UniversalQuantifierExpression: "forall" AttributedVariable "in" Term . "holds" Term
-
- "holds" shift, and go to state 300
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "implies" shift, and go to state 127
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "=>" shift, and go to state 138
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
+ 150 RuleDefinition: "rule" Identifier MaybeParameters "->" Type . "=" Rule
+
+ "=" shift, and go to state 308
State 254
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
- 138 ChooseExpression: "choose" AttributedVariable "in" Term . "do" Term
-
- "do" shift, and go to state 301
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "implies" shift, and go to state 127
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "=>" shift, and go to state 138
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
+ 22 FunctionParameters: FunctionParameters "*" . Type
+
+ "this" shift, and go to state 25
+ "in" shift, and go to state 26
+ "." shift, and go to state 28
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 168
+ Type go to state 309
+ BasicType go to state 41
+ ComposedType go to state 42
+ RelationType go to state 43
+ FixedSizedType go to state 44
State 255
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
- 137 ConditionalExpression: "if" Term "then" Term . "else" Term
-
- "else" shift, and go to state 302
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "implies" shift, and go to state 127
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "=>" shift, and go to state 138
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
+ 14 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" . Type MaybeDefined MaybeInitially
+
+ "this" shift, and go to state 25
+ "in" shift, and go to state 26
+ "." shift, and go to state 28
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 168
+ Type go to state 310
+ BasicType go to state 41
+ ComposedType go to state 42
+ RelationType go to state 43
+ FixedSizedType go to state 44
State 256
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
- 140 ExistentialQuantifierExpression: "exists" AttributedVariable "in" Term . "with" Term
-
- "with" shift, and go to state 303
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "implies" shift, and go to state 127
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "=>" shift, and go to state 138
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
+ 17 FunctionDefinitions: FunctionDefinition .
+ $default reduce using rule 17 (FunctionDefinitions)
-State 257
- 135 IndirectCallExpression: "(" "*" Term ")" . Arguments
+State 257
- "(" shift, and go to state 122
+ 16 FunctionDefinitions: FunctionDefinitions . "," FunctionDefinition
+ 37 StructureDefinition: "structure" Identifier "=" "{" FunctionDefinitions . "}"
- Arguments go to state 304
+ "}" shift, and go to state 311
+ "," shift, and go to state 312
State 258
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
- 127 Terms: Terms "," Term .
- 132 TwoOrMoreArguments: "(" Terms "," Term . ")"
-
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "implies" shift, and go to state 127
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- ")" shift, and go to state 305
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "=>" shift, and go to state 138
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
-
- $default reduce using rule 127 (Terms)
+ 35 DerivedDefinition: "derived" . Identifier MaybeParameters "->" Type "=" Term
+ 50 DeclarationDefinition: "derived" . Identifier ":" MaybeFunctionParameters "->" Type
+
+ "in" shift, and go to state 26
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 313
State 259
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
- 123 Range: "[" Term ".." Term . "]"
-
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "implies" shift, and go to state 127
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- "]" shift, and go to state 306
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "=>" shift, and go to state 138
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
+ 51 DeclarationDefinition: "rule" . Identifier ":" MaybeFunctionParameters "->" Type
+ 149 RuleDefinition: "rule" . Identifier MaybeParameters "=" Rule
+ 150 | "rule" . Identifier MaybeParameters "->" Type "=" Rule
+
+ "in" shift, and go to state 26
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 314
State 260
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
- 127 Terms: Terms "," Term .
-
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "implies" shift, and go to state 127
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "=>" shift, and go to state 138
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
-
- $default reduce using rule 127 (Terms)
+ 40 FeatureDeclarationOrDefinition: DerivedDefinition .
+
+ $default reduce using rule 40 (FeatureDeclarationOrDefinition)
State 261
- 130 Arguments: "(" error ")" .
+ 43 FeatureDeclarationsAndDefinitions: FeatureDeclarationOrDefinition .
- $default reduce using rule 130 (Arguments)
+ $default reduce using rule 43 (FeatureDeclarationsAndDefinitions)
State 262
- 129 Arguments: "(" Terms ")" .
+ 38 FeatureDefinition: "feature" Identifier "=" "{" FeatureDeclarationsAndDefinitions . "}"
+ 42 FeatureDeclarationsAndDefinitions: FeatureDeclarationsAndDefinitions . FeatureDeclarationOrDefinition
- $default reduce using rule 129 (Arguments)
+ "derived" shift, and go to state 258
+ "rule" shift, and go to state 259
+ "}" shift, and go to state 315
+
+ DerivedDefinition go to state 260
+ FeatureDeclarationOrDefinition go to state 316
+ DeclarationDefinition go to state 263
+ RuleDefinition go to state 264
State 263
- 57 Parameters: Parameters "," AttributedVariable .
+ 39 FeatureDeclarationOrDefinition: DeclarationDefinition .
- $default reduce using rule 57 (Parameters)
+ $default reduce using rule 39 (FeatureDeclarationOrDefinition)
State 264
- 34 DerivedDefinition: "derived" Identifier MaybeParameters "->" Type "=" . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 307
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 41 FeatureDeclarationOrDefinition: RuleDefinition .
+
+ $default reduce using rule 41 (FeatureDeclarationOrDefinition)
State 265
- 35 EnumerationDefinition: "enum" Identifier "=" "{" Identifiers "}" .
+ 44 ImplementationDefinition: "implements" IdentifierPath "for" Type "=" . "{" ImplementationDefinitionDefinitions "}"
- $default reduce using rule 35 (EnumerationDefinition)
+ "{" shift, and go to state 317
State 266
- 47 Identifiers: Identifiers "," . Identifier
+ 76 RelationType: IdentifierPath "<" MaybeFunctionParameters "->" . Type ">"
- "in" shift, and go to state 23
- "identifier" shift, and go to state 26
+ "this" shift, and go to state 25
+ "in" shift, and go to state 26
+ "." shift, and go to state 28
+ "identifier" shift, and go to state 29
- Identifier go to state 308
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 168
+ Type go to state 318
+ BasicType go to state 41
+ ComposedType go to state 42
+ RelationType go to state 43
+ FixedSizedType go to state 44
State 267
- 177 SequenceRule: "seq" error . "endseq"
+ 78 Types: Types "," . Type
+
+ "this" shift, and go to state 25
+ "in" shift, and go to state 26
+ "." shift, and go to state 28
+ "identifier" shift, and go to state 29
- "endseq" shift, and go to state 309
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 168
+ Type go to state 319
+ BasicType go to state 41
+ ComposedType go to state 42
+ RelationType go to state 43
+ FixedSizedType go to state 44
State 268
- 155 Rules: Rule .
+ 75 ComposedType: IdentifierPath "<" Types ">" .
- $default reduce using rule 155 (Rules)
+ $default reduce using rule 75 (ComposedType)
State 269
- 154 Rules: Rules . Rule
- 175 SequenceRule: "seq" Rules . "endseq"
-
- "seq" shift, and go to state 209
- "endseq" shift, and go to state 310
- "par" shift, and go to state 210
- "skip" shift, and go to state 211
- "let" shift, and go to state 212
- "in" shift, and go to state 23
- "forall" shift, and go to state 213
- "choose" shift, and go to state 214
- "iterate" shift, and go to state 215
- "call" shift, and go to state 216
- "if" shift, and go to state 217
- "case" shift, and go to state 218
- "(" shift, and go to state 219
- "{" shift, and go to state 220
- "." shift, and go to state 25
- "{|" shift, and go to state 221
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- DirectCallExpression go to state 222
- IndirectCallExpression go to state 223
- Rule go to state 311
- SkipRule go to state 225
- ConditionalRule go to state 226
- CaseRule go to state 227
- LetRule go to state 228
- ForallRule go to state 229
- ChooseRule go to state 230
- IterateRule go to state 231
- BlockRule go to state 232
- SequenceRule go to state 233
- UpdateRule go to state 234
- CallRule go to state 235
+ 46 ImplementationDefinitionDefinition: DerivedDefinition .
+
+ $default reduce using rule 46 (ImplementationDefinitionDefinition)
State 270
- 173 BlockRule: "par" error . "endpar"
+ 49 ImplementationDefinitionDefinitions: ImplementationDefinitionDefinition .
- "endpar" shift, and go to state 312
+ $default reduce using rule 49 (ImplementationDefinitionDefinitions)
State 271
- 154 Rules: Rules . Rule
- 171 BlockRule: "par" Rules . "endpar"
-
- "seq" shift, and go to state 209
- "par" shift, and go to state 210
- "endpar" shift, and go to state 313
- "skip" shift, and go to state 211
- "let" shift, and go to state 212
- "in" shift, and go to state 23
- "forall" shift, and go to state 213
- "choose" shift, and go to state 214
- "iterate" shift, and go to state 215
- "call" shift, and go to state 216
- "if" shift, and go to state 217
- "case" shift, and go to state 218
- "(" shift, and go to state 219
- "{" shift, and go to state 220
- "." shift, and go to state 25
- "{|" shift, and go to state 221
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- DirectCallExpression go to state 222
- IndirectCallExpression go to state 223
- Rule go to state 311
- SkipRule go to state 225
- ConditionalRule go to state 226
- CaseRule go to state 227
- LetRule go to state 228
- ForallRule go to state 229
- ChooseRule go to state 230
- IterateRule go to state 231
- BlockRule go to state 232
- SequenceRule go to state 233
- UpdateRule go to state 234
- CallRule go to state 235
+ 45 ImplementationDefinition: "implements" Type "=" "{" ImplementationDefinitionDefinitions . "}"
+ 48 ImplementationDefinitionDefinitions: ImplementationDefinitionDefinitions . ImplementationDefinitionDefinition
+
+ "derived" shift, and go to state 5
+ "rule" shift, and go to state 7
+ "}" shift, and go to state 320
+
+ DerivedDefinition go to state 269
+ ImplementationDefinitionDefinition go to state 321
+ RuleDefinition go to state 272
State 272
- 166 LetRule: "let" AttributedVariable . "=" Term "in" Rule
+ 47 ImplementationDefinitionDefinition: RuleDefinition .
- "=" shift, and go to state 314
+ $default reduce using rule 47 (ImplementationDefinitionDefinition)
State 273
- 167 ForallRule: "forall" AttributedVariable . "in" Term "do" Rule
+ 63 AttributedVariable: "[" Attributes "]" . Variable
- "in" shift, and go to state 315
+ "in" shift, and go to state 26
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 116
+ Variable go to state 322
State 274
- 168 ChooseRule: "choose" AttributedVariable . "in" Term "do" Rule
+ 61 Variable: Identifier ":" Type .
- "in" shift, and go to state 316
+ $default reduce using rule 61 (Variable)
State 275
- 169 IterateRule: "iterate" Rule .
-
- $default reduce using rule 169 (IterateRule)
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+ 144 LetExpression: "let" AttributedVariable "=" Term . "in" Term
+
+ "in" shift, and go to state 323
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "implies" shift, and go to state 142
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "=>" shift, and go to state 153
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
State 276
- 179 CallRule: "call" DirectCallExpression .
-
- $default reduce using rule 179 (CallRule)
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+ 147 UniversalQuantifierExpression: "forall" AttributedVariable "in" Term . "holds" Term
+
+ "holds" shift, and go to state 324
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "implies" shift, and go to state 142
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "=>" shift, and go to state 153
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
State 277
- 181 CallRule: "call" IndirectCallExpression .
-
- $default reduce using rule 181 (CallRule)
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+ 146 ChooseExpression: "choose" AttributedVariable "in" Term . "do" Term
+
+ "do" shift, and go to state 325
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "implies" shift, and go to state 142
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "=>" shift, and go to state 153
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
State 278
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
- 157 ConditionalRule: "if" Term . "then" Rule
- 158 | "if" Term . "then" Rule "else" Rule
-
- "then" shift, and go to state 317
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "implies" shift, and go to state 127
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "=>" shift, and go to state 138
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+ 145 ConditionalExpression: "if" Term "then" Term . "else" Term
+
+ "else" shift, and go to state 326
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "implies" shift, and go to state 142
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "=>" shift, and go to state 153
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
State 279
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
- 159 CaseRule: "case" Term . "of" "{" CaseLabels "}"
- 160 | "case" Term . "of" "{" error "}"
-
- "of" shift, and go to state 318
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "implies" shift, and go to state 127
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "=>" shift, and go to state 138
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+ 148 ExistentialQuantifierExpression: "exists" AttributedVariable "in" Term . "with" Term
+
+ "with" shift, and go to state 327
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "implies" shift, and go to state 142
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "=>" shift, and go to state 153
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
State 280
- 172 BlockRule: "{" error . "}"
+ 143 IndirectCallExpression: "(" "*" Term ")" . Arguments
- "}" shift, and go to state 319
+ "(" shift, and go to state 137
+
+ Arguments go to state 328
State 281
- 154 Rules: Rules . Rule
- 170 BlockRule: "{" Rules . "}"
-
- "seq" shift, and go to state 209
- "par" shift, and go to state 210
- "skip" shift, and go to state 211
- "let" shift, and go to state 212
- "in" shift, and go to state 23
- "forall" shift, and go to state 213
- "choose" shift, and go to state 214
- "iterate" shift, and go to state 215
- "call" shift, and go to state 216
- "if" shift, and go to state 217
- "case" shift, and go to state 218
- "(" shift, and go to state 219
- "{" shift, and go to state 220
- "}" shift, and go to state 320
- "." shift, and go to state 25
- "{|" shift, and go to state 221
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- DirectCallExpression go to state 222
- IndirectCallExpression go to state 223
- Rule go to state 311
- SkipRule go to state 225
- ConditionalRule go to state 226
- CaseRule go to state 227
- LetRule go to state 228
- ForallRule go to state 229
- ChooseRule go to state 230
- IterateRule go to state 231
- BlockRule go to state 232
- SequenceRule go to state 233
- UpdateRule go to state 234
- CallRule go to state 235
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+ 135 Terms: Terms "," Term .
+ 140 TwoOrMoreArguments: "(" Terms "," Term . ")"
+
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "implies" shift, and go to state 142
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ ")" shift, and go to state 329
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "=>" shift, and go to state 153
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
+
+ $default reduce using rule 135 (Terms)
State 282
- 176 SequenceRule: "{|" error . "|}"
-
- "|}" shift, and go to state 321
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+ 131 Range: "[" Term ".." Term . "]"
+
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "implies" shift, and go to state 142
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ "]" shift, and go to state 330
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "=>" shift, and go to state 153
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
State 283
- 154 Rules: Rules . Rule
- 174 SequenceRule: "{|" Rules . "|}"
-
- "seq" shift, and go to state 209
- "par" shift, and go to state 210
- "skip" shift, and go to state 211
- "let" shift, and go to state 212
- "in" shift, and go to state 23
- "forall" shift, and go to state 213
- "choose" shift, and go to state 214
- "iterate" shift, and go to state 215
- "call" shift, and go to state 216
- "if" shift, and go to state 217
- "case" shift, and go to state 218
- "(" shift, and go to state 219
- "{" shift, and go to state 220
- "." shift, and go to state 25
- "{|" shift, and go to state 221
- "|}" shift, and go to state 322
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- DirectCallExpression go to state 222
- IndirectCallExpression go to state 223
- Rule go to state 311
- SkipRule go to state 225
- ConditionalRule go to state 226
- CaseRule go to state 227
- LetRule go to state 228
- ForallRule go to state 229
- ChooseRule go to state 230
- IterateRule go to state 231
- BlockRule go to state 232
- SequenceRule go to state 233
- UpdateRule go to state 234
- CallRule go to state 235
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+ 135 Terms: Terms "," Term .
+
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "implies" shift, and go to state 142
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "=>" shift, and go to state 153
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
+
+ $default reduce using rule 135 (Terms)
State 284
- 178 UpdateRule: DirectCallExpression ":=" . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 323
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 138 Arguments: "(" error ")" .
+
+ $default reduce using rule 138 (Arguments)
State 285
- 142 RuleDefinition: "rule" Identifier MaybeParameters "->" Type "=" . Rule
-
- "seq" shift, and go to state 209
- "par" shift, and go to state 210
- "skip" shift, and go to state 211
- "let" shift, and go to state 212
- "in" shift, and go to state 23
- "forall" shift, and go to state 213
- "choose" shift, and go to state 214
- "iterate" shift, and go to state 215
- "call" shift, and go to state 216
- "if" shift, and go to state 217
- "case" shift, and go to state 218
- "(" shift, and go to state 219
- "{" shift, and go to state 220
- "." shift, and go to state 25
- "{|" shift, and go to state 221
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- DirectCallExpression go to state 222
- IndirectCallExpression go to state 223
- Rule go to state 324
- SkipRule go to state 225
- ConditionalRule go to state 226
- CaseRule go to state 227
- LetRule go to state 228
- ForallRule go to state 229
- ChooseRule go to state 230
- IterateRule go to state 231
- BlockRule go to state 232
- SequenceRule go to state 233
- UpdateRule go to state 234
- CallRule go to state 235
+ 137 Arguments: "(" Terms ")" .
+
+ $default reduce using rule 137 (Arguments)
State 286
- 21 FunctionParameters: FunctionParameters "*" Type .
+ 65 Parameters: Parameters "," AttributedVariable .
- $default reduce using rule 21 (FunctionParameters)
+ $default reduce using rule 65 (Parameters)
State 287
- 13 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" Type . MaybeDefined MaybeInitially
-
- "defined" shift, and go to state 325
-
- $default reduce using rule 20 (MaybeDefined)
-
- MaybeDefined go to state 326
+ 35 DerivedDefinition: "derived" Identifier MaybeParameters "->" Type "=" . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 331
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 288
- 68 RelationType: IdentifierPath "<" MaybeFunctionParameters . "->" Type ">"
+ 36 EnumerationDefinition: "enum" Identifier "=" "{" Identifiers "}" .
- "->" shift, and go to state 327
+ $default reduce using rule 36 (EnumerationDefinition)
State 289
- 22 FunctionParameters: Type .
- 71 Types: Type .
+ 54 Identifiers: Identifiers "," . Identifier
- "," reduce using rule 71 (Types)
- ">" reduce using rule 71 (Types)
- $default reduce using rule 22 (FunctionParameters)
+ "in" shift, and go to state 26
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 332
State 290
- 67 ComposedType: IdentifierPath "<" Types . ">"
- 70 Types: Types . "," Type
+ 185 SequenceRule: "seq" error . "endseq"
- "," shift, and go to state 328
- ">" shift, and go to state 329
+ "endseq" shift, and go to state 333
State 291
- 69 FixedSizedType: IdentifierPath "'" Term .
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
-
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "implies" shift, and go to state 127
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "<" shift, and go to state 131
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "=>" shift, and go to state 138
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
-
- $default reduce using rule 69 (FixedSizedType)
+ 163 Rules: Rule .
+ $default reduce using rule 163 (Rules)
-State 292
- 36 StructureDefinition: "structure" Identifier "=" "{" FunctionDefinitions "}" .
+State 292
- $default reduce using rule 36 (StructureDefinition)
+ 162 Rules: Rules . Rule
+ 183 SequenceRule: "seq" Rules . "endseq"
+
+ "this" shift, and go to state 25
+ "seq" shift, and go to state 226
+ "endseq" shift, and go to state 334
+ "par" shift, and go to state 227
+ "skip" shift, and go to state 228
+ "let" shift, and go to state 229
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 230
+ "choose" shift, and go to state 231
+ "iterate" shift, and go to state 232
+ "call" shift, and go to state 233
+ "if" shift, and go to state 234
+ "case" shift, and go to state 235
+ "(" shift, and go to state 236
+ "{" shift, and go to state 237
+ "." shift, and go to state 28
+ "{|" shift, and go to state 238
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ DirectCallExpression go to state 239
+ IndirectCallExpression go to state 240
+ Rule go to state 335
+ SkipRule go to state 242
+ ConditionalRule go to state 243
+ CaseRule go to state 244
+ LetRule go to state 245
+ ForallRule go to state 246
+ ChooseRule go to state 247
+ IterateRule go to state 248
+ BlockRule go to state 249
+ SequenceRule go to state 250
+ UpdateRule go to state 251
+ CallRule go to state 252
State 293
- 15 FunctionDefinitions: FunctionDefinitions "," . FunctionDefinition
+ 181 BlockRule: "par" error . "endpar"
- "init" shift, and go to state 4
- "function" shift, and go to state 8
-
- FunctionDefinition go to state 330
- ProgramFunctionDefinition go to state 16
+ "endpar" shift, and go to state 336
State 294
- 34 DerivedDefinition: "derived" Identifier . MaybeParameters "->" Type "=" Term
- 43 DeclarationDefinition: "derived" Identifier . ":" MaybeFunctionParameters "->" Type
-
- "(" shift, and go to state 89
- ":" shift, and go to state 331
-
- $default reduce using rule 61 (MaybeParameters)
-
- MaybeParameters go to state 90
+ 162 Rules: Rules . Rule
+ 179 BlockRule: "par" Rules . "endpar"
+
+ "this" shift, and go to state 25
+ "seq" shift, and go to state 226
+ "par" shift, and go to state 227
+ "endpar" shift, and go to state 337
+ "skip" shift, and go to state 228
+ "let" shift, and go to state 229
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 230
+ "choose" shift, and go to state 231
+ "iterate" shift, and go to state 232
+ "call" shift, and go to state 233
+ "if" shift, and go to state 234
+ "case" shift, and go to state 235
+ "(" shift, and go to state 236
+ "{" shift, and go to state 237
+ "." shift, and go to state 28
+ "{|" shift, and go to state 238
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ DirectCallExpression go to state 239
+ IndirectCallExpression go to state 240
+ Rule go to state 335
+ SkipRule go to state 242
+ ConditionalRule go to state 243
+ CaseRule go to state 244
+ LetRule go to state 245
+ ForallRule go to state 246
+ ChooseRule go to state 247
+ IterateRule go to state 248
+ BlockRule go to state 249
+ SequenceRule go to state 250
+ UpdateRule go to state 251
+ CallRule go to state 252
State 295
- 44 DeclarationDefinition: "rule" Identifier . ":" MaybeFunctionParameters "->" Type
- 141 RuleDefinition: "rule" Identifier . MaybeParameters "=" Rule
- 142 | "rule" Identifier . MaybeParameters "->" Type "=" Rule
-
- "(" shift, and go to state 89
- ":" shift, and go to state 332
+ 174 LetRule: "let" AttributedVariable . "=" Term "in" Rule
- $default reduce using rule 61 (MaybeParameters)
-
- MaybeParameters go to state 92
+ "=" shift, and go to state 338
State 296
- 37 FeatureDefinition: "feature" Identifier "=" "{" FeatureDeclarationsAndDefinitions "}" .
+ 175 ForallRule: "forall" AttributedVariable . "in" Term "do" Rule
- $default reduce using rule 37 (FeatureDefinition)
+ "in" shift, and go to state 339
State 297
- 41 FeatureDeclarationsAndDefinitions: FeatureDeclarationsAndDefinitions "," . FeatureDeclarationOrDefinition
-
- "derived" shift, and go to state 243
- "rule" shift, and go to state 244
+ 176 ChooseRule: "choose" AttributedVariable . "in" Term "do" Rule
- DerivedDefinition go to state 245
- FeatureDeclarationOrDefinition go to state 333
- DeclarationDefinition go to state 248
- RuleDefinition go to state 249
+ "in" shift, and go to state 340
State 298
- 55 AttributedVariable: "[" Attributes "]" Variable .
+ 177 IterateRule: "iterate" Rule .
- $default reduce using rule 55 (AttributedVariable)
+ $default reduce using rule 177 (IterateRule)
State 299
- 136 LetExpression: "let" AttributedVariable "=" Term "in" . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 334
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 187 CallRule: "call" DirectCallExpression .
+
+ $default reduce using rule 187 (CallRule)
State 300
- 139 UniversalQuantifierExpression: "forall" AttributedVariable "in" Term "holds" . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 335
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 189 CallRule: "call" IndirectCallExpression .
+
+ $default reduce using rule 189 (CallRule)
State 301
- 138 ChooseExpression: "choose" AttributedVariable "in" Term "do" . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 336
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+ 165 ConditionalRule: "if" Term . "then" Rule
+ 166 | "if" Term . "then" Rule "else" Rule
+
+ "then" shift, and go to state 341
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "implies" shift, and go to state 142
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "=>" shift, and go to state 153
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
State 302
- 137 ConditionalExpression: "if" Term "then" Term "else" . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 337
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+ 167 CaseRule: "case" Term . "of" "{" CaseLabels "}"
+ 168 | "case" Term . "of" "{" error "}"
+
+ "of" shift, and go to state 342
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "implies" shift, and go to state 142
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "=>" shift, and go to state 153
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
State 303
- 140 ExistentialQuantifierExpression: "exists" AttributedVariable "in" Term "with" . Term
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 338
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 180 BlockRule: "{" error . "}"
+ "}" shift, and go to state 343
-State 304
- 135 IndirectCallExpression: "(" "*" Term ")" Arguments .
+State 304
- $default reduce using rule 135 (IndirectCallExpression)
+ 162 Rules: Rules . Rule
+ 178 BlockRule: "{" Rules . "}"
+
+ "this" shift, and go to state 25
+ "seq" shift, and go to state 226
+ "par" shift, and go to state 227
+ "skip" shift, and go to state 228
+ "let" shift, and go to state 229
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 230
+ "choose" shift, and go to state 231
+ "iterate" shift, and go to state 232
+ "call" shift, and go to state 233
+ "if" shift, and go to state 234
+ "case" shift, and go to state 235
+ "(" shift, and go to state 236
+ "{" shift, and go to state 237
+ "}" shift, and go to state 344
+ "." shift, and go to state 28
+ "{|" shift, and go to state 238
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ DirectCallExpression go to state 239
+ IndirectCallExpression go to state 240
+ Rule go to state 335
+ SkipRule go to state 242
+ ConditionalRule go to state 243
+ CaseRule go to state 244
+ LetRule go to state 245
+ ForallRule go to state 246
+ ChooseRule go to state 247
+ IterateRule go to state 248
+ BlockRule go to state 249
+ SequenceRule go to state 250
+ UpdateRule go to state 251
+ CallRule go to state 252
State 305
- 132 TwoOrMoreArguments: "(" Terms "," Term ")" .
+ 184 SequenceRule: "{|" error . "|}"
- $default reduce using rule 132 (TwoOrMoreArguments)
+ "|}" shift, and go to state 345
State 306
- 123 Range: "[" Term ".." Term "]" .
-
- $default reduce using rule 123 (Range)
+ 162 Rules: Rules . Rule
+ 182 SequenceRule: "{|" Rules . "|}"
+
+ "this" shift, and go to state 25
+ "seq" shift, and go to state 226
+ "par" shift, and go to state 227
+ "skip" shift, and go to state 228
+ "let" shift, and go to state 229
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 230
+ "choose" shift, and go to state 231
+ "iterate" shift, and go to state 232
+ "call" shift, and go to state 233
+ "if" shift, and go to state 234
+ "case" shift, and go to state 235
+ "(" shift, and go to state 236
+ "{" shift, and go to state 237
+ "." shift, and go to state 28
+ "{|" shift, and go to state 238
+ "|}" shift, and go to state 346
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ DirectCallExpression go to state 239
+ IndirectCallExpression go to state 240
+ Rule go to state 335
+ SkipRule go to state 242
+ ConditionalRule go to state 243
+ CaseRule go to state 244
+ LetRule go to state 245
+ ForallRule go to state 246
+ ChooseRule go to state 247
+ IterateRule go to state 248
+ BlockRule go to state 249
+ SequenceRule go to state 250
+ UpdateRule go to state 251
+ CallRule go to state 252
State 307
- 34 DerivedDefinition: "derived" Identifier MaybeParameters "->" Type "=" Term .
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
-
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "implies" shift, and go to state 127
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "=>" shift, and go to state 138
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
-
- $default reduce using rule 34 (DerivedDefinition)
+ 186 UpdateRule: DirectCallExpression ":=" . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 347
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 308
- 47 Identifiers: Identifiers "," Identifier .
-
- $default reduce using rule 47 (Identifiers)
+ 150 RuleDefinition: "rule" Identifier MaybeParameters "->" Type "=" . Rule
+
+ "this" shift, and go to state 25
+ "seq" shift, and go to state 226
+ "par" shift, and go to state 227
+ "skip" shift, and go to state 228
+ "let" shift, and go to state 229
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 230
+ "choose" shift, and go to state 231
+ "iterate" shift, and go to state 232
+ "call" shift, and go to state 233
+ "if" shift, and go to state 234
+ "case" shift, and go to state 235
+ "(" shift, and go to state 236
+ "{" shift, and go to state 237
+ "." shift, and go to state 28
+ "{|" shift, and go to state 238
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ DirectCallExpression go to state 239
+ IndirectCallExpression go to state 240
+ Rule go to state 348
+ SkipRule go to state 242
+ ConditionalRule go to state 243
+ CaseRule go to state 244
+ LetRule go to state 245
+ ForallRule go to state 246
+ ChooseRule go to state 247
+ IterateRule go to state 248
+ BlockRule go to state 249
+ SequenceRule go to state 250
+ UpdateRule go to state 251
+ CallRule go to state 252
State 309
- 177 SequenceRule: "seq" error "endseq" .
+ 22 FunctionParameters: FunctionParameters "*" Type .
- $default reduce using rule 177 (SequenceRule)
+ $default reduce using rule 22 (FunctionParameters)
State 310
- 175 SequenceRule: "seq" Rules "endseq" .
+ 14 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" Type . MaybeDefined MaybeInitially
+
+ "defined" shift, and go to state 349
+
+ $default reduce using rule 21 (MaybeDefined)
- $default reduce using rule 175 (SequenceRule)
+ MaybeDefined go to state 350
State 311
- 154 Rules: Rules Rule .
+ 37 StructureDefinition: "structure" Identifier "=" "{" FunctionDefinitions "}" .
- $default reduce using rule 154 (Rules)
+ $default reduce using rule 37 (StructureDefinition)
State 312
- 173 BlockRule: "par" error "endpar" .
+ 16 FunctionDefinitions: FunctionDefinitions "," . FunctionDefinition
- $default reduce using rule 173 (BlockRule)
+ "init" shift, and go to state 4
+ "function" shift, and go to state 8
+
+ FunctionDefinition go to state 351
+ ProgramFunctionDefinition go to state 17
State 313
- 171 BlockRule: "par" Rules "endpar" .
+ 35 DerivedDefinition: "derived" Identifier . MaybeParameters "->" Type "=" Term
+ 50 DeclarationDefinition: "derived" Identifier . ":" MaybeFunctionParameters "->" Type
+
+ "(" shift, and go to state 99
+ ":" shift, and go to state 352
- $default reduce using rule 171 (BlockRule)
+ $default reduce using rule 69 (MaybeParameters)
+
+ MaybeParameters go to state 100
State 314
- 166 LetRule: "let" AttributedVariable "=" . Term "in" Rule
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 339
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 51 DeclarationDefinition: "rule" Identifier . ":" MaybeFunctionParameters "->" Type
+ 149 RuleDefinition: "rule" Identifier . MaybeParameters "=" Rule
+ 150 | "rule" Identifier . MaybeParameters "->" Type "=" Rule
+
+ "(" shift, and go to state 99
+ ":" shift, and go to state 353
+
+ $default reduce using rule 69 (MaybeParameters)
+
+ MaybeParameters go to state 102
State 315
- 167 ForallRule: "forall" AttributedVariable "in" . Term "do" Rule
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 340
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 38 FeatureDefinition: "feature" Identifier "=" "{" FeatureDeclarationsAndDefinitions "}" .
+
+ $default reduce using rule 38 (FeatureDefinition)
State 316
- 168 ChooseRule: "choose" AttributedVariable "in" . Term "do" Rule
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 341
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 42 FeatureDeclarationsAndDefinitions: FeatureDeclarationsAndDefinitions FeatureDeclarationOrDefinition .
+
+ $default reduce using rule 42 (FeatureDeclarationsAndDefinitions)
State 317
- 157 ConditionalRule: "if" Term "then" . Rule
- 158 | "if" Term "then" . Rule "else" Rule
-
- "seq" shift, and go to state 209
- "par" shift, and go to state 210
- "skip" shift, and go to state 211
- "let" shift, and go to state 212
- "in" shift, and go to state 23
- "forall" shift, and go to state 213
- "choose" shift, and go to state 214
- "iterate" shift, and go to state 215
- "call" shift, and go to state 216
- "if" shift, and go to state 217
- "case" shift, and go to state 218
- "(" shift, and go to state 219
- "{" shift, and go to state 220
- "." shift, and go to state 25
- "{|" shift, and go to state 221
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- DirectCallExpression go to state 222
- IndirectCallExpression go to state 223
- Rule go to state 342
- SkipRule go to state 225
- ConditionalRule go to state 226
- CaseRule go to state 227
- LetRule go to state 228
- ForallRule go to state 229
- ChooseRule go to state 230
- IterateRule go to state 231
- BlockRule go to state 232
- SequenceRule go to state 233
- UpdateRule go to state 234
- CallRule go to state 235
+ 44 ImplementationDefinition: "implements" IdentifierPath "for" Type "=" "{" . ImplementationDefinitionDefinitions "}"
+
+ "derived" shift, and go to state 5
+ "rule" shift, and go to state 7
+
+ DerivedDefinition go to state 269
+ ImplementationDefinitionDefinition go to state 270
+ ImplementationDefinitionDefinitions go to state 354
+ RuleDefinition go to state 272
State 318
- 159 CaseRule: "case" Term "of" . "{" CaseLabels "}"
- 160 | "case" Term "of" . "{" error "}"
+ 76 RelationType: IdentifierPath "<" MaybeFunctionParameters "->" Type . ">"
- "{" shift, and go to state 343
+ ">" shift, and go to state 355
State 319
- 172 BlockRule: "{" error "}" .
+ 78 Types: Types "," Type .
- $default reduce using rule 172 (BlockRule)
+ $default reduce using rule 78 (Types)
State 320
- 170 BlockRule: "{" Rules "}" .
+ 45 ImplementationDefinition: "implements" Type "=" "{" ImplementationDefinitionDefinitions "}" .
- $default reduce using rule 170 (BlockRule)
+ $default reduce using rule 45 (ImplementationDefinition)
State 321
- 176 SequenceRule: "{|" error "|}" .
+ 48 ImplementationDefinitionDefinitions: ImplementationDefinitionDefinitions ImplementationDefinitionDefinition .
- $default reduce using rule 176 (SequenceRule)
+ $default reduce using rule 48 (ImplementationDefinitionDefinitions)
State 322
- 174 SequenceRule: "{|" Rules "|}" .
+ 63 AttributedVariable: "[" Attributes "]" Variable .
- $default reduce using rule 174 (SequenceRule)
+ $default reduce using rule 63 (AttributedVariable)
State 323
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
- 178 UpdateRule: DirectCallExpression ":=" Term .
-
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "implies" shift, and go to state 127
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "=>" shift, and go to state 138
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
-
- $default reduce using rule 178 (UpdateRule)
+ 144 LetExpression: "let" AttributedVariable "=" Term "in" . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 356
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 324
- 142 RuleDefinition: "rule" Identifier MaybeParameters "->" Type "=" Rule .
-
- $default reduce using rule 142 (RuleDefinition)
+ 147 UniversalQuantifierExpression: "forall" AttributedVariable "in" Term "holds" . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 357
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 325
- 19 MaybeDefined: "defined" . "{" Term "}"
-
- "{" shift, and go to state 344
+ 146 ChooseExpression: "choose" AttributedVariable "in" Term "do" . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 358
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 326
- 13 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined . MaybeInitially
-
- "initially" shift, and go to state 345
-
- $default reduce using rule 18 (MaybeInitially)
-
- MaybeInitially go to state 346
+ 145 ConditionalExpression: "if" Term "then" Term "else" . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 359
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 327
- 68 RelationType: IdentifierPath "<" MaybeFunctionParameters "->" . Type ">"
-
- "in" shift, and go to state 23
- "." shift, and go to state 25
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 153
- Type go to state 347
- BasicType go to state 155
- ComposedType go to state 156
- RelationType go to state 157
- FixedSizedType go to state 158
+ 148 ExistentialQuantifierExpression: "exists" AttributedVariable "in" Term "with" . Term
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 360
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 328
- 70 Types: Types "," . Type
-
- "in" shift, and go to state 23
- "." shift, and go to state 25
- "identifier" shift, and go to state 26
+ 143 IndirectCallExpression: "(" "*" Term ")" Arguments .
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 153
- Type go to state 348
- BasicType go to state 155
- ComposedType go to state 156
- RelationType go to state 157
- FixedSizedType go to state 158
+ $default reduce using rule 143 (IndirectCallExpression)
State 329
- 67 ComposedType: IdentifierPath "<" Types ">" .
+ 140 TwoOrMoreArguments: "(" Terms "," Term ")" .
- $default reduce using rule 67 (ComposedType)
+ $default reduce using rule 140 (TwoOrMoreArguments)
State 330
- 15 FunctionDefinitions: FunctionDefinitions "," FunctionDefinition .
+ 131 Range: "[" Term ".." Term "]" .
- $default reduce using rule 15 (FunctionDefinitions)
+ $default reduce using rule 131 (Range)
State 331
- 43 DeclarationDefinition: "derived" Identifier ":" . MaybeFunctionParameters "->" Type
-
- "in" shift, and go to state 23
- "." shift, and go to state 25
- "identifier" shift, and go to state 26
-
- $default reduce using rule 24 (MaybeFunctionParameters)
-
- FunctionParameters go to state 151
- MaybeFunctionParameters go to state 349
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 153
- Type go to state 154
- BasicType go to state 155
- ComposedType go to state 156
- RelationType go to state 157
- FixedSizedType go to state 158
+ 35 DerivedDefinition: "derived" Identifier MaybeParameters "->" Type "=" Term .
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "implies" shift, and go to state 142
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "=>" shift, and go to state 153
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
+
+ $default reduce using rule 35 (DerivedDefinition)
State 332
- 44 DeclarationDefinition: "rule" Identifier ":" . MaybeFunctionParameters "->" Type
+ 54 Identifiers: Identifiers "," Identifier .
- "in" shift, and go to state 23
- "." shift, and go to state 25
- "identifier" shift, and go to state 26
-
- $default reduce using rule 24 (MaybeFunctionParameters)
-
- FunctionParameters go to state 151
- MaybeFunctionParameters go to state 350
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 153
- Type go to state 154
- BasicType go to state 155
- ComposedType go to state 156
- RelationType go to state 157
- FixedSizedType go to state 158
+ $default reduce using rule 54 (Identifiers)
State 333
- 41 FeatureDeclarationsAndDefinitions: FeatureDeclarationsAndDefinitions "," FeatureDeclarationOrDefinition .
+ 185 SequenceRule: "seq" error "endseq" .
- $default reduce using rule 41 (FeatureDeclarationsAndDefinitions)
+ $default reduce using rule 185 (SequenceRule)
State 334
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
- 136 LetExpression: "let" AttributedVariable "=" Term "in" Term .
-
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "implies" shift, and go to state 127
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "=>" shift, and go to state 138
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
-
- $default reduce using rule 136 (LetExpression)
+ 183 SequenceRule: "seq" Rules "endseq" .
+
+ $default reduce using rule 183 (SequenceRule)
State 335
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
- 139 UniversalQuantifierExpression: "forall" AttributedVariable "in" Term "holds" Term .
-
- $default reduce using rule 139 (UniversalQuantifierExpression)
+ 162 Rules: Rules Rule .
+
+ $default reduce using rule 162 (Rules)
State 336
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
- 138 ChooseExpression: "choose" AttributedVariable "in" Term "do" Term .
-
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "implies" shift, and go to state 127
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "=>" shift, and go to state 138
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
-
- $default reduce using rule 138 (ChooseExpression)
+ 181 BlockRule: "par" error "endpar" .
+
+ $default reduce using rule 181 (BlockRule)
State 337
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
- 137 ConditionalExpression: "if" Term "then" Term "else" Term .
-
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "implies" shift, and go to state 127
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "=>" shift, and go to state 138
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
-
- $default reduce using rule 137 (ConditionalExpression)
+ 179 BlockRule: "par" Rules "endpar" .
+
+ $default reduce using rule 179 (BlockRule)
State 338
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
- 140 ExistentialQuantifierExpression: "exists" AttributedVariable "in" Term "with" Term .
-
- $default reduce using rule 140 (ExistentialQuantifierExpression)
+ 174 LetRule: "let" AttributedVariable "=" . Term "in" Rule
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 361
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 339
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
- 166 LetRule: "let" AttributedVariable "=" Term . "in" Rule
-
- "in" shift, and go to state 351
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "implies" shift, and go to state 127
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "=>" shift, and go to state 138
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
+ 175 ForallRule: "forall" AttributedVariable "in" . Term "do" Rule
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 362
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 340
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
- 167 ForallRule: "forall" AttributedVariable "in" Term . "do" Rule
-
- "do" shift, and go to state 352
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "implies" shift, and go to state 127
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "=>" shift, and go to state 138
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
+ 176 ChooseRule: "choose" AttributedVariable "in" . Term "do" Rule
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 363
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 341
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
- 168 ChooseRule: "choose" AttributedVariable "in" Term . "do" Rule
-
- "do" shift, and go to state 353
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "implies" shift, and go to state 127
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "=>" shift, and go to state 138
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
+ 165 ConditionalRule: "if" Term "then" . Rule
+ 166 | "if" Term "then" . Rule "else" Rule
+
+ "this" shift, and go to state 25
+ "seq" shift, and go to state 226
+ "par" shift, and go to state 227
+ "skip" shift, and go to state 228
+ "let" shift, and go to state 229
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 230
+ "choose" shift, and go to state 231
+ "iterate" shift, and go to state 232
+ "call" shift, and go to state 233
+ "if" shift, and go to state 234
+ "case" shift, and go to state 235
+ "(" shift, and go to state 236
+ "{" shift, and go to state 237
+ "." shift, and go to state 28
+ "{|" shift, and go to state 238
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ DirectCallExpression go to state 239
+ IndirectCallExpression go to state 240
+ Rule go to state 364
+ SkipRule go to state 242
+ ConditionalRule go to state 243
+ CaseRule go to state 244
+ LetRule go to state 245
+ ForallRule go to state 246
+ ChooseRule go to state 247
+ IterateRule go to state 248
+ BlockRule go to state 249
+ SequenceRule go to state 250
+ UpdateRule go to state 251
+ CallRule go to state 252
State 342
- 157 ConditionalRule: "if" Term "then" Rule .
- 158 | "if" Term "then" Rule . "else" Rule
+ 167 CaseRule: "case" Term "of" . "{" CaseLabels "}"
+ 168 | "case" Term "of" . "{" error "}"
- "else" shift, and go to state 354
-
- $default reduce using rule 157 (ConditionalRule)
+ "{" shift, and go to state 365
State 343
- 159 CaseRule: "case" Term "of" "{" . CaseLabels "}"
- 160 | "case" Term "of" "{" . error "}"
-
- error shift, and go to state 355
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "default" shift, and go to state 356
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "_" shift, and go to state 357
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 358
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
- CaseLabel go to state 359
- CaseLabels go to state 360
+ 180 BlockRule: "{" error "}" .
+
+ $default reduce using rule 180 (BlockRule)
State 344
- 19 MaybeDefined: "defined" "{" . Term "}"
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 361
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 178 BlockRule: "{" Rules "}" .
+
+ $default reduce using rule 178 (BlockRule)
State 345
- 17 MaybeInitially: "initially" . "{" MaybeInitializers "}"
+ 184 SequenceRule: "{|" error "|}" .
- "{" shift, and go to state 362
+ $default reduce using rule 184 (SequenceRule)
State 346
- 13 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially .
+ 182 SequenceRule: "{|" Rules "|}" .
- $default reduce using rule 13 (FunctionDefinition)
+ $default reduce using rule 182 (SequenceRule)
State 347
- 68 RelationType: IdentifierPath "<" MaybeFunctionParameters "->" Type . ">"
-
- ">" shift, and go to state 363
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+ 186 UpdateRule: DirectCallExpression ":=" Term .
+
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "implies" shift, and go to state 142
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "=>" shift, and go to state 153
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
+
+ $default reduce using rule 186 (UpdateRule)
State 348
- 70 Types: Types "," Type .
+ 150 RuleDefinition: "rule" Identifier MaybeParameters "->" Type "=" Rule .
- $default reduce using rule 70 (Types)
+ $default reduce using rule 150 (RuleDefinition)
State 349
- 43 DeclarationDefinition: "derived" Identifier ":" MaybeFunctionParameters . "->" Type
+ 20 MaybeDefined: "defined" . "{" Term "}"
- "->" shift, and go to state 364
+ "{" shift, and go to state 366
State 350
- 44 DeclarationDefinition: "rule" Identifier ":" MaybeFunctionParameters . "->" Type
+ 14 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined . MaybeInitially
+
+ "initially" shift, and go to state 367
- "->" shift, and go to state 365
+ $default reduce using rule 19 (MaybeInitially)
+
+ MaybeInitially go to state 368
State 351
- 166 LetRule: "let" AttributedVariable "=" Term "in" . Rule
-
- "seq" shift, and go to state 209
- "par" shift, and go to state 210
- "skip" shift, and go to state 211
- "let" shift, and go to state 212
- "in" shift, and go to state 23
- "forall" shift, and go to state 213
- "choose" shift, and go to state 214
- "iterate" shift, and go to state 215
- "call" shift, and go to state 216
- "if" shift, and go to state 217
- "case" shift, and go to state 218
- "(" shift, and go to state 219
- "{" shift, and go to state 220
- "." shift, and go to state 25
- "{|" shift, and go to state 221
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- DirectCallExpression go to state 222
- IndirectCallExpression go to state 223
- Rule go to state 366
- SkipRule go to state 225
- ConditionalRule go to state 226
- CaseRule go to state 227
- LetRule go to state 228
- ForallRule go to state 229
- ChooseRule go to state 230
- IterateRule go to state 231
- BlockRule go to state 232
- SequenceRule go to state 233
- UpdateRule go to state 234
- CallRule go to state 235
+ 16 FunctionDefinitions: FunctionDefinitions "," FunctionDefinition .
+
+ $default reduce using rule 16 (FunctionDefinitions)
State 352
- 167 ForallRule: "forall" AttributedVariable "in" Term "do" . Rule
-
- "seq" shift, and go to state 209
- "par" shift, and go to state 210
- "skip" shift, and go to state 211
- "let" shift, and go to state 212
- "in" shift, and go to state 23
- "forall" shift, and go to state 213
- "choose" shift, and go to state 214
- "iterate" shift, and go to state 215
- "call" shift, and go to state 216
- "if" shift, and go to state 217
- "case" shift, and go to state 218
- "(" shift, and go to state 219
- "{" shift, and go to state 220
- "." shift, and go to state 25
- "{|" shift, and go to state 221
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- DirectCallExpression go to state 222
- IndirectCallExpression go to state 223
- Rule go to state 367
- SkipRule go to state 225
- ConditionalRule go to state 226
- CaseRule go to state 227
- LetRule go to state 228
- ForallRule go to state 229
- ChooseRule go to state 230
- IterateRule go to state 231
- BlockRule go to state 232
- SequenceRule go to state 233
- UpdateRule go to state 234
- CallRule go to state 235
+ 50 DeclarationDefinition: "derived" Identifier ":" . MaybeFunctionParameters "->" Type
+
+ "this" shift, and go to state 25
+ "in" shift, and go to state 26
+ "." shift, and go to state 28
+ "identifier" shift, and go to state 29
+
+ $default reduce using rule 25 (MaybeFunctionParameters)
+
+ FunctionParameters go to state 166
+ MaybeFunctionParameters go to state 369
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 168
+ Type go to state 169
+ BasicType go to state 41
+ ComposedType go to state 42
+ RelationType go to state 43
+ FixedSizedType go to state 44
State 353
- 168 ChooseRule: "choose" AttributedVariable "in" Term "do" . Rule
-
- "seq" shift, and go to state 209
- "par" shift, and go to state 210
- "skip" shift, and go to state 211
- "let" shift, and go to state 212
- "in" shift, and go to state 23
- "forall" shift, and go to state 213
- "choose" shift, and go to state 214
- "iterate" shift, and go to state 215
- "call" shift, and go to state 216
- "if" shift, and go to state 217
- "case" shift, and go to state 218
- "(" shift, and go to state 219
- "{" shift, and go to state 220
- "." shift, and go to state 25
- "{|" shift, and go to state 221
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- DirectCallExpression go to state 222
- IndirectCallExpression go to state 223
- Rule go to state 368
- SkipRule go to state 225
- ConditionalRule go to state 226
- CaseRule go to state 227
- LetRule go to state 228
- ForallRule go to state 229
- ChooseRule go to state 230
- IterateRule go to state 231
- BlockRule go to state 232
- SequenceRule go to state 233
- UpdateRule go to state 234
- CallRule go to state 235
+ 51 DeclarationDefinition: "rule" Identifier ":" . MaybeFunctionParameters "->" Type
+
+ "this" shift, and go to state 25
+ "in" shift, and go to state 26
+ "." shift, and go to state 28
+ "identifier" shift, and go to state 29
+
+ $default reduce using rule 25 (MaybeFunctionParameters)
+
+ FunctionParameters go to state 166
+ MaybeFunctionParameters go to state 370
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 168
+ Type go to state 169
+ BasicType go to state 41
+ ComposedType go to state 42
+ RelationType go to state 43
+ FixedSizedType go to state 44
State 354
- 158 ConditionalRule: "if" Term "then" Rule "else" . Rule
-
- "seq" shift, and go to state 209
- "par" shift, and go to state 210
- "skip" shift, and go to state 211
- "let" shift, and go to state 212
- "in" shift, and go to state 23
- "forall" shift, and go to state 213
- "choose" shift, and go to state 214
- "iterate" shift, and go to state 215
- "call" shift, and go to state 216
- "if" shift, and go to state 217
- "case" shift, and go to state 218
- "(" shift, and go to state 219
- "{" shift, and go to state 220
- "." shift, and go to state 25
- "{|" shift, and go to state 221
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- DirectCallExpression go to state 222
- IndirectCallExpression go to state 223
- Rule go to state 369
- SkipRule go to state 225
- ConditionalRule go to state 226
- CaseRule go to state 227
- LetRule go to state 228
- ForallRule go to state 229
- ChooseRule go to state 230
- IterateRule go to state 231
- BlockRule go to state 232
- SequenceRule go to state 233
- UpdateRule go to state 234
- CallRule go to state 235
+ 44 ImplementationDefinition: "implements" IdentifierPath "for" Type "=" "{" ImplementationDefinitionDefinitions . "}"
+ 48 ImplementationDefinitionDefinitions: ImplementationDefinitionDefinitions . ImplementationDefinitionDefinition
+
+ "derived" shift, and go to state 5
+ "rule" shift, and go to state 7
+ "}" shift, and go to state 371
+
+ DerivedDefinition go to state 269
+ ImplementationDefinitionDefinition go to state 321
+ RuleDefinition go to state 272
State 355
- 160 CaseRule: "case" Term "of" "{" error . "}"
+ 76 RelationType: IdentifierPath "<" MaybeFunctionParameters "->" Type ">" .
- "}" shift, and go to state 370
+ $default reduce using rule 76 (RelationType)
State 356
- 161 CaseLabel: "default" . ":" Rule
-
- ":" shift, and go to state 371
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+ 144 LetExpression: "let" AttributedVariable "=" Term "in" Term .
+
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "implies" shift, and go to state 142
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "=>" shift, and go to state 153
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
+
+ $default reduce using rule 144 (LetExpression)
State 357
- 162 CaseLabel: "_" . ":" Rule
-
- ":" shift, and go to state 372
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+ 147 UniversalQuantifierExpression: "forall" AttributedVariable "in" Term "holds" Term .
+
+ $default reduce using rule 147 (UniversalQuantifierExpression)
State 358
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
- 163 CaseLabel: Term . ":" Rule
-
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "implies" shift, and go to state 127
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- ":" shift, and go to state 373
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "=>" shift, and go to state 138
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+ 146 ChooseExpression: "choose" AttributedVariable "in" Term "do" Term .
+
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "implies" shift, and go to state 142
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "=>" shift, and go to state 153
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
+
+ $default reduce using rule 146 (ChooseExpression)
State 359
- 164 CaseLabels: CaseLabel . CaseLabels
- 165 | CaseLabel .
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "default" shift, and go to state 356
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 96
- "[" shift, and go to state 54
- "_" shift, and go to state 357
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- $default reduce using rule 165 (CaseLabels)
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 358
- Expression go to state 76
- Range go to state 77
- List go to state 78
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
- CaseLabel go to state 359
- CaseLabels go to state 374
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+ 145 ConditionalExpression: "if" Term "then" Term "else" Term .
+
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "implies" shift, and go to state 142
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "=>" shift, and go to state 153
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
+
+ $default reduce using rule 145 (ConditionalExpression)
State 360
- 159 CaseRule: "case" Term "of" "{" CaseLabels . "}"
-
- "}" shift, and go to state 375
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+ 148 ExistentialQuantifierExpression: "exists" AttributedVariable "in" Term "with" Term .
+
+ $default reduce using rule 148 (ExistentialQuantifierExpression)
State 361
- 19 MaybeDefined: "defined" "{" Term . "}"
- 105 Expression: Term . "+" Term
- 106 | Term . "-" Term
- 107 | Term . "*" Term
- 108 | Term . "/" Term
- 109 | Term . "%" Term
- 110 | Term . "^" Term
- 111 | Term . "!=" Term
- 112 | Term . "=" Term
- 113 | Term . "<" Term
- 114 | Term . ">" Term
- 115 | Term . "<=" Term
- 116 | Term . ">=" Term
- 117 | Term . "or" Term
- 118 | Term . "xor" Term
- 119 | Term . "and" Term
- 120 | Term . "=>" Term
- 121 | Term . "implies" Term
-
- "and" shift, and go to state 124
- "or" shift, and go to state 125
- "xor" shift, and go to state 126
- "implies" shift, and go to state 127
- "+" shift, and go to state 128
- "-" shift, and go to state 129
- "=" shift, and go to state 130
- "}" shift, and go to state 376
- "<" shift, and go to state 131
- ">" shift, and go to state 132
- "*" shift, and go to state 133
- "/" shift, and go to state 134
- "%" shift, and go to state 135
- "^" shift, and go to state 136
- "=>" shift, and go to state 138
- "!=" shift, and go to state 139
- "<=" shift, and go to state 140
- ">=" shift, and go to state 141
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+ 174 LetRule: "let" AttributedVariable "=" Term . "in" Rule
+
+ "in" shift, and go to state 372
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "implies" shift, and go to state 142
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "=>" shift, and go to state 153
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
State 362
- 17 MaybeInitially: "initially" "{" . MaybeInitializers "}"
-
- "let" shift, and go to state 42
- "in" shift, and go to state 23
- "forall" shift, and go to state 43
- "choose" shift, and go to state 44
- "if" shift, and go to state 45
- "exists" shift, and go to state 46
- "undef" shift, and go to state 47
- "false" shift, and go to state 48
- "true" shift, and go to state 49
- "not" shift, and go to state 50
- "+" shift, and go to state 51
- "-" shift, and go to state 52
- "(" shift, and go to state 53
- "[" shift, and go to state 54
- "@" shift, and go to state 55
- "." shift, and go to state 25
- "binary" shift, and go to state 56
- "hexadecimal" shift, and go to state 57
- "integer" shift, and go to state 58
- "rational" shift, and go to state 59
- "floating" shift, and go to state 60
- "string" shift, and go to state 61
- "identifier" shift, and go to state 26
-
- $default reduce using rule 33 (MaybeInitializers)
-
- Initializer go to state 62
- Initializers go to state 63
- MaybeInitializers go to state 377
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- Atom go to state 66
- Undefined go to state 67
- Boolean go to state 68
- String go to state 69
- BitNumber go to state 70
- IntegerNumber go to state 71
- FloatingNumber go to state 72
- RationalNumber go to state 73
- Reference go to state 74
- Term go to state 75
- Expression go to state 76
- Range go to state 77
- List go to state 78
- TwoOrMoreArguments go to state 79
- DirectCallExpression go to state 80
- IndirectCallExpression go to state 81
- LetExpression go to state 82
- ConditionalExpression go to state 83
- ChooseExpression go to state 84
- UniversalQuantifierExpression go to state 85
- ExistentialQuantifierExpression go to state 86
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+ 175 ForallRule: "forall" AttributedVariable "in" Term . "do" Rule
+
+ "do" shift, and go to state 373
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "implies" shift, and go to state 142
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "=>" shift, and go to state 153
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
State 363
- 68 RelationType: IdentifierPath "<" MaybeFunctionParameters "->" Type ">" .
-
- $default reduce using rule 68 (RelationType)
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+ 176 ChooseRule: "choose" AttributedVariable "in" Term . "do" Rule
+
+ "do" shift, and go to state 374
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "implies" shift, and go to state 142
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "=>" shift, and go to state 153
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
State 364
- 43 DeclarationDefinition: "derived" Identifier ":" MaybeFunctionParameters "->" . Type
+ 165 ConditionalRule: "if" Term "then" Rule .
+ 166 | "if" Term "then" Rule . "else" Rule
- "in" shift, and go to state 23
- "." shift, and go to state 25
- "identifier" shift, and go to state 26
+ "else" shift, and go to state 375
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 153
- Type go to state 378
- BasicType go to state 155
- ComposedType go to state 156
- RelationType go to state 157
- FixedSizedType go to state 158
+ $default reduce using rule 165 (ConditionalRule)
State 365
- 44 DeclarationDefinition: "rule" Identifier ":" MaybeFunctionParameters "->" . Type
-
- "in" shift, and go to state 23
- "." shift, and go to state 25
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 153
- Type go to state 379
- BasicType go to state 155
- ComposedType go to state 156
- RelationType go to state 157
- FixedSizedType go to state 158
+ 167 CaseRule: "case" Term "of" "{" . CaseLabels "}"
+ 168 | "case" Term "of" "{" . error "}"
+
+ error shift, and go to state 376
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "default" shift, and go to state 377
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "_" shift, and go to state 378
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 379
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
+ CaseLabel go to state 380
+ CaseLabels go to state 381
State 366
- 166 LetRule: "let" AttributedVariable "=" Term "in" Rule .
-
- $default reduce using rule 166 (LetRule)
+ 20 MaybeDefined: "defined" "{" . Term "}"
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 382
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
State 367
- 167 ForallRule: "forall" AttributedVariable "in" Term "do" Rule .
+ 18 MaybeInitially: "initially" . "{" MaybeInitializers "}"
- $default reduce using rule 167 (ForallRule)
+ "{" shift, and go to state 383
State 368
- 168 ChooseRule: "choose" AttributedVariable "in" Term "do" Rule .
+ 14 FunctionDefinition: "function" Identifier ":" MaybeFunctionParameters "->" Type MaybeDefined MaybeInitially .
- $default reduce using rule 168 (ChooseRule)
+ $default reduce using rule 14 (FunctionDefinition)
State 369
- 158 ConditionalRule: "if" Term "then" Rule "else" Rule .
+ 50 DeclarationDefinition: "derived" Identifier ":" MaybeFunctionParameters . "->" Type
- $default reduce using rule 158 (ConditionalRule)
+ "->" shift, and go to state 384
State 370
- 160 CaseRule: "case" Term "of" "{" error "}" .
+ 51 DeclarationDefinition: "rule" Identifier ":" MaybeFunctionParameters . "->" Type
- $default reduce using rule 160 (CaseRule)
+ "->" shift, and go to state 385
State 371
- 161 CaseLabel: "default" ":" . Rule
-
- "seq" shift, and go to state 209
- "par" shift, and go to state 210
- "skip" shift, and go to state 211
- "let" shift, and go to state 212
- "in" shift, and go to state 23
- "forall" shift, and go to state 213
- "choose" shift, and go to state 214
- "iterate" shift, and go to state 215
- "call" shift, and go to state 216
- "if" shift, and go to state 217
- "case" shift, and go to state 218
- "(" shift, and go to state 219
- "{" shift, and go to state 220
- "." shift, and go to state 25
- "{|" shift, and go to state 221
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- DirectCallExpression go to state 222
- IndirectCallExpression go to state 223
- Rule go to state 380
- SkipRule go to state 225
- ConditionalRule go to state 226
- CaseRule go to state 227
- LetRule go to state 228
- ForallRule go to state 229
- ChooseRule go to state 230
- IterateRule go to state 231
- BlockRule go to state 232
- SequenceRule go to state 233
- UpdateRule go to state 234
- CallRule go to state 235
+ 44 ImplementationDefinition: "implements" IdentifierPath "for" Type "=" "{" ImplementationDefinitionDefinitions "}" .
+
+ $default reduce using rule 44 (ImplementationDefinition)
State 372
- 162 CaseLabel: "_" ":" . Rule
-
- "seq" shift, and go to state 209
- "par" shift, and go to state 210
- "skip" shift, and go to state 211
- "let" shift, and go to state 212
- "in" shift, and go to state 23
- "forall" shift, and go to state 213
- "choose" shift, and go to state 214
- "iterate" shift, and go to state 215
- "call" shift, and go to state 216
- "if" shift, and go to state 217
- "case" shift, and go to state 218
- "(" shift, and go to state 219
- "{" shift, and go to state 220
- "." shift, and go to state 25
- "{|" shift, and go to state 221
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- DirectCallExpression go to state 222
- IndirectCallExpression go to state 223
- Rule go to state 381
- SkipRule go to state 225
- ConditionalRule go to state 226
- CaseRule go to state 227
- LetRule go to state 228
- ForallRule go to state 229
- ChooseRule go to state 230
- IterateRule go to state 231
- BlockRule go to state 232
- SequenceRule go to state 233
- UpdateRule go to state 234
- CallRule go to state 235
+ 174 LetRule: "let" AttributedVariable "=" Term "in" . Rule
+
+ "this" shift, and go to state 25
+ "seq" shift, and go to state 226
+ "par" shift, and go to state 227
+ "skip" shift, and go to state 228
+ "let" shift, and go to state 229
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 230
+ "choose" shift, and go to state 231
+ "iterate" shift, and go to state 232
+ "call" shift, and go to state 233
+ "if" shift, and go to state 234
+ "case" shift, and go to state 235
+ "(" shift, and go to state 236
+ "{" shift, and go to state 237
+ "." shift, and go to state 28
+ "{|" shift, and go to state 238
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ DirectCallExpression go to state 239
+ IndirectCallExpression go to state 240
+ Rule go to state 386
+ SkipRule go to state 242
+ ConditionalRule go to state 243
+ CaseRule go to state 244
+ LetRule go to state 245
+ ForallRule go to state 246
+ ChooseRule go to state 247
+ IterateRule go to state 248
+ BlockRule go to state 249
+ SequenceRule go to state 250
+ UpdateRule go to state 251
+ CallRule go to state 252
State 373
- 163 CaseLabel: Term ":" . Rule
-
- "seq" shift, and go to state 209
- "par" shift, and go to state 210
- "skip" shift, and go to state 211
- "let" shift, and go to state 212
- "in" shift, and go to state 23
- "forall" shift, and go to state 213
- "choose" shift, and go to state 214
- "iterate" shift, and go to state 215
- "call" shift, and go to state 216
- "if" shift, and go to state 217
- "case" shift, and go to state 218
- "(" shift, and go to state 219
- "{" shift, and go to state 220
- "." shift, and go to state 25
- "{|" shift, and go to state 221
- "identifier" shift, and go to state 26
-
- Identifier go to state 27
- DotSeparatedIdentifiers go to state 28
- IdentifierPath go to state 65
- DirectCallExpression go to state 222
- IndirectCallExpression go to state 223
- Rule go to state 382
- SkipRule go to state 225
- ConditionalRule go to state 226
- CaseRule go to state 227
- LetRule go to state 228
- ForallRule go to state 229
- ChooseRule go to state 230
- IterateRule go to state 231
- BlockRule go to state 232
- SequenceRule go to state 233
- UpdateRule go to state 234
- CallRule go to state 235
+ 175 ForallRule: "forall" AttributedVariable "in" Term "do" . Rule
+
+ "this" shift, and go to state 25
+ "seq" shift, and go to state 226
+ "par" shift, and go to state 227
+ "skip" shift, and go to state 228
+ "let" shift, and go to state 229
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 230
+ "choose" shift, and go to state 231
+ "iterate" shift, and go to state 232
+ "call" shift, and go to state 233
+ "if" shift, and go to state 234
+ "case" shift, and go to state 235
+ "(" shift, and go to state 236
+ "{" shift, and go to state 237
+ "." shift, and go to state 28
+ "{|" shift, and go to state 238
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ DirectCallExpression go to state 239
+ IndirectCallExpression go to state 240
+ Rule go to state 387
+ SkipRule go to state 242
+ ConditionalRule go to state 243
+ CaseRule go to state 244
+ LetRule go to state 245
+ ForallRule go to state 246
+ ChooseRule go to state 247
+ IterateRule go to state 248
+ BlockRule go to state 249
+ SequenceRule go to state 250
+ UpdateRule go to state 251
+ CallRule go to state 252
State 374
- 164 CaseLabels: CaseLabel CaseLabels .
-
- $default reduce using rule 164 (CaseLabels)
+ 176 ChooseRule: "choose" AttributedVariable "in" Term "do" . Rule
+
+ "this" shift, and go to state 25
+ "seq" shift, and go to state 226
+ "par" shift, and go to state 227
+ "skip" shift, and go to state 228
+ "let" shift, and go to state 229
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 230
+ "choose" shift, and go to state 231
+ "iterate" shift, and go to state 232
+ "call" shift, and go to state 233
+ "if" shift, and go to state 234
+ "case" shift, and go to state 235
+ "(" shift, and go to state 236
+ "{" shift, and go to state 237
+ "." shift, and go to state 28
+ "{|" shift, and go to state 238
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ DirectCallExpression go to state 239
+ IndirectCallExpression go to state 240
+ Rule go to state 388
+ SkipRule go to state 242
+ ConditionalRule go to state 243
+ CaseRule go to state 244
+ LetRule go to state 245
+ ForallRule go to state 246
+ ChooseRule go to state 247
+ IterateRule go to state 248
+ BlockRule go to state 249
+ SequenceRule go to state 250
+ UpdateRule go to state 251
+ CallRule go to state 252
State 375
- 159 CaseRule: "case" Term "of" "{" CaseLabels "}" .
-
- $default reduce using rule 159 (CaseRule)
+ 166 ConditionalRule: "if" Term "then" Rule "else" . Rule
+
+ "this" shift, and go to state 25
+ "seq" shift, and go to state 226
+ "par" shift, and go to state 227
+ "skip" shift, and go to state 228
+ "let" shift, and go to state 229
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 230
+ "choose" shift, and go to state 231
+ "iterate" shift, and go to state 232
+ "call" shift, and go to state 233
+ "if" shift, and go to state 234
+ "case" shift, and go to state 235
+ "(" shift, and go to state 236
+ "{" shift, and go to state 237
+ "." shift, and go to state 28
+ "{|" shift, and go to state 238
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ DirectCallExpression go to state 239
+ IndirectCallExpression go to state 240
+ Rule go to state 389
+ SkipRule go to state 242
+ ConditionalRule go to state 243
+ CaseRule go to state 244
+ LetRule go to state 245
+ ForallRule go to state 246
+ ChooseRule go to state 247
+ IterateRule go to state 248
+ BlockRule go to state 249
+ SequenceRule go to state 250
+ UpdateRule go to state 251
+ CallRule go to state 252
State 376
- 19 MaybeDefined: "defined" "{" Term "}" .
+ 168 CaseRule: "case" Term "of" "{" error . "}"
- $default reduce using rule 19 (MaybeDefined)
+ "}" shift, and go to state 390
State 377
- 17 MaybeInitially: "initially" "{" MaybeInitializers . "}"
+ 169 CaseLabel: "default" . ":" Rule
- "}" shift, and go to state 383
+ ":" shift, and go to state 391
State 378
- 43 DeclarationDefinition: "derived" Identifier ":" MaybeFunctionParameters "->" Type .
+ 170 CaseLabel: "_" . ":" Rule
- $default reduce using rule 43 (DeclarationDefinition)
+ ":" shift, and go to state 392
State 379
- 44 DeclarationDefinition: "rule" Identifier ":" MaybeFunctionParameters "->" Type .
-
- $default reduce using rule 44 (DeclarationDefinition)
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+ 171 CaseLabel: Term . ":" Rule
+
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "implies" shift, and go to state 142
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ ":" shift, and go to state 393
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "=>" shift, and go to state 153
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
State 380
- 161 CaseLabel: "default" ":" Rule .
-
- $default reduce using rule 161 (CaseLabel)
+ 172 CaseLabels: CaseLabel . CaseLabels
+ 173 | CaseLabel .
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "default" shift, and go to state 377
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 110
+ "[" shift, and go to state 64
+ "_" shift, and go to state 378
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ $default reduce using rule 173 (CaseLabels)
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 379
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
+ CaseLabel go to state 380
+ CaseLabels go to state 394
State 381
- 162 CaseLabel: "_" ":" Rule .
+ 167 CaseRule: "case" Term "of" "{" CaseLabels . "}"
- $default reduce using rule 162 (CaseLabel)
+ "}" shift, and go to state 395
State 382
- 163 CaseLabel: Term ":" Rule .
-
- $default reduce using rule 163 (CaseLabel)
+ 20 MaybeDefined: "defined" "{" Term . "}"
+ 113 Expression: Term . "+" Term
+ 114 | Term . "-" Term
+ 115 | Term . "*" Term
+ 116 | Term . "/" Term
+ 117 | Term . "%" Term
+ 118 | Term . "^" Term
+ 119 | Term . "!=" Term
+ 120 | Term . "=" Term
+ 121 | Term . "<" Term
+ 122 | Term . ">" Term
+ 123 | Term . "<=" Term
+ 124 | Term . ">=" Term
+ 125 | Term . "or" Term
+ 126 | Term . "xor" Term
+ 127 | Term . "and" Term
+ 128 | Term . "=>" Term
+ 129 | Term . "implies" Term
+
+ "and" shift, and go to state 139
+ "or" shift, and go to state 140
+ "xor" shift, and go to state 141
+ "implies" shift, and go to state 142
+ "+" shift, and go to state 143
+ "-" shift, and go to state 144
+ "=" shift, and go to state 145
+ "}" shift, and go to state 396
+ "<" shift, and go to state 146
+ ">" shift, and go to state 147
+ "*" shift, and go to state 148
+ "/" shift, and go to state 149
+ "%" shift, and go to state 150
+ "^" shift, and go to state 151
+ "=>" shift, and go to state 153
+ "!=" shift, and go to state 154
+ "<=" shift, and go to state 155
+ ">=" shift, and go to state 156
State 383
- 17 MaybeInitially: "initially" "{" MaybeInitializers "}" .
+ 18 MaybeInitially: "initially" "{" . MaybeInitializers "}"
+
+ "this" shift, and go to state 25
+ "let" shift, and go to state 52
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 53
+ "choose" shift, and go to state 54
+ "if" shift, and go to state 55
+ "exists" shift, and go to state 56
+ "undef" shift, and go to state 57
+ "false" shift, and go to state 58
+ "true" shift, and go to state 59
+ "not" shift, and go to state 60
+ "+" shift, and go to state 61
+ "-" shift, and go to state 62
+ "(" shift, and go to state 63
+ "[" shift, and go to state 64
+ "@" shift, and go to state 65
+ "." shift, and go to state 28
+ "binary" shift, and go to state 66
+ "hexadecimal" shift, and go to state 67
+ "integer" shift, and go to state 68
+ "rational" shift, and go to state 69
+ "floating" shift, and go to state 70
+ "string" shift, and go to state 71
+ "identifier" shift, and go to state 29
+
+ $default reduce using rule 34 (MaybeInitializers)
+
+ Initializer go to state 72
+ Initializers go to state 73
+ MaybeInitializers go to state 397
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ Atom go to state 76
+ Undefined go to state 77
+ Boolean go to state 78
+ String go to state 79
+ BitNumber go to state 80
+ IntegerNumber go to state 81
+ FloatingNumber go to state 82
+ RationalNumber go to state 83
+ Reference go to state 84
+ Term go to state 85
+ Expression go to state 86
+ Range go to state 87
+ List go to state 88
+ TwoOrMoreArguments go to state 89
+ DirectCallExpression go to state 90
+ IndirectCallExpression go to state 91
+ LetExpression go to state 92
+ ConditionalExpression go to state 93
+ ChooseExpression go to state 94
+ UniversalQuantifierExpression go to state 95
+ ExistentialQuantifierExpression go to state 96
+
+
+State 384
+
+ 50 DeclarationDefinition: "derived" Identifier ":" MaybeFunctionParameters "->" . Type
+
+ "this" shift, and go to state 25
+ "in" shift, and go to state 26
+ "." shift, and go to state 28
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 168
+ Type go to state 398
+ BasicType go to state 41
+ ComposedType go to state 42
+ RelationType go to state 43
+ FixedSizedType go to state 44
+
+
+State 385
+
+ 51 DeclarationDefinition: "rule" Identifier ":" MaybeFunctionParameters "->" . Type
+
+ "this" shift, and go to state 25
+ "in" shift, and go to state 26
+ "." shift, and go to state 28
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 168
+ Type go to state 399
+ BasicType go to state 41
+ ComposedType go to state 42
+ RelationType go to state 43
+ FixedSizedType go to state 44
+
+
+State 386
+
+ 174 LetRule: "let" AttributedVariable "=" Term "in" Rule .
+
+ $default reduce using rule 174 (LetRule)
+
+
+State 387
+
+ 175 ForallRule: "forall" AttributedVariable "in" Term "do" Rule .
+
+ $default reduce using rule 175 (ForallRule)
+
+
+State 388
+
+ 176 ChooseRule: "choose" AttributedVariable "in" Term "do" Rule .
+
+ $default reduce using rule 176 (ChooseRule)
+
+
+State 389
+
+ 166 ConditionalRule: "if" Term "then" Rule "else" Rule .
+
+ $default reduce using rule 166 (ConditionalRule)
+
+
+State 390
+
+ 168 CaseRule: "case" Term "of" "{" error "}" .
+
+ $default reduce using rule 168 (CaseRule)
+
+
+State 391
+
+ 169 CaseLabel: "default" ":" . Rule
+
+ "this" shift, and go to state 25
+ "seq" shift, and go to state 226
+ "par" shift, and go to state 227
+ "skip" shift, and go to state 228
+ "let" shift, and go to state 229
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 230
+ "choose" shift, and go to state 231
+ "iterate" shift, and go to state 232
+ "call" shift, and go to state 233
+ "if" shift, and go to state 234
+ "case" shift, and go to state 235
+ "(" shift, and go to state 236
+ "{" shift, and go to state 237
+ "." shift, and go to state 28
+ "{|" shift, and go to state 238
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ DirectCallExpression go to state 239
+ IndirectCallExpression go to state 240
+ Rule go to state 400
+ SkipRule go to state 242
+ ConditionalRule go to state 243
+ CaseRule go to state 244
+ LetRule go to state 245
+ ForallRule go to state 246
+ ChooseRule go to state 247
+ IterateRule go to state 248
+ BlockRule go to state 249
+ SequenceRule go to state 250
+ UpdateRule go to state 251
+ CallRule go to state 252
+
+
+State 392
+
+ 170 CaseLabel: "_" ":" . Rule
+
+ "this" shift, and go to state 25
+ "seq" shift, and go to state 226
+ "par" shift, and go to state 227
+ "skip" shift, and go to state 228
+ "let" shift, and go to state 229
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 230
+ "choose" shift, and go to state 231
+ "iterate" shift, and go to state 232
+ "call" shift, and go to state 233
+ "if" shift, and go to state 234
+ "case" shift, and go to state 235
+ "(" shift, and go to state 236
+ "{" shift, and go to state 237
+ "." shift, and go to state 28
+ "{|" shift, and go to state 238
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ DirectCallExpression go to state 239
+ IndirectCallExpression go to state 240
+ Rule go to state 401
+ SkipRule go to state 242
+ ConditionalRule go to state 243
+ CaseRule go to state 244
+ LetRule go to state 245
+ ForallRule go to state 246
+ ChooseRule go to state 247
+ IterateRule go to state 248
+ BlockRule go to state 249
+ SequenceRule go to state 250
+ UpdateRule go to state 251
+ CallRule go to state 252
+
+
+State 393
+
+ 171 CaseLabel: Term ":" . Rule
+
+ "this" shift, and go to state 25
+ "seq" shift, and go to state 226
+ "par" shift, and go to state 227
+ "skip" shift, and go to state 228
+ "let" shift, and go to state 229
+ "in" shift, and go to state 26
+ "forall" shift, and go to state 230
+ "choose" shift, and go to state 231
+ "iterate" shift, and go to state 232
+ "call" shift, and go to state 233
+ "if" shift, and go to state 234
+ "case" shift, and go to state 235
+ "(" shift, and go to state 236
+ "{" shift, and go to state 237
+ "." shift, and go to state 28
+ "{|" shift, and go to state 238
+ "identifier" shift, and go to state 29
+
+ Identifier go to state 30
+ DotSeparatedIdentifiers go to state 31
+ IdentifierPath go to state 75
+ DirectCallExpression go to state 239
+ IndirectCallExpression go to state 240
+ Rule go to state 402
+ SkipRule go to state 242
+ ConditionalRule go to state 243
+ CaseRule go to state 244
+ LetRule go to state 245
+ ForallRule go to state 246
+ ChooseRule go to state 247
+ IterateRule go to state 248
+ BlockRule go to state 249
+ SequenceRule go to state 250
+ UpdateRule go to state 251
+ CallRule go to state 252
+
+
+State 394
+
+ 172 CaseLabels: CaseLabel CaseLabels .
+
+ $default reduce using rule 172 (CaseLabels)
+
+
+State 395
+
+ 167 CaseRule: "case" Term "of" "{" CaseLabels "}" .
+
+ $default reduce using rule 167 (CaseRule)
+
+
+State 396
+
+ 20 MaybeDefined: "defined" "{" Term "}" .
+
+ $default reduce using rule 20 (MaybeDefined)
+
- $default reduce using rule 17 (MaybeInitially)
+State 397
+
+ 18 MaybeInitially: "initially" "{" MaybeInitializers . "}"
+
+ "}" shift, and go to state 403
+
+
+State 398
+
+ 50 DeclarationDefinition: "derived" Identifier ":" MaybeFunctionParameters "->" Type .
+
+ $default reduce using rule 50 (DeclarationDefinition)
+
+
+State 399
+
+ 51 DeclarationDefinition: "rule" Identifier ":" MaybeFunctionParameters "->" Type .
+
+ $default reduce using rule 51 (DeclarationDefinition)
+
+
+State 400
+
+ 169 CaseLabel: "default" ":" Rule .
+
+ $default reduce using rule 169 (CaseLabel)
+
+
+State 401
+
+ 170 CaseLabel: "_" ":" Rule .
+
+ $default reduce using rule 170 (CaseLabel)
+
+
+State 402
+
+ 171 CaseLabel: Term ":" Rule .
+
+ $default reduce using rule 171 (CaseLabel)
+
+
+State 403
+
+ 18 MaybeInitially: "initially" "{" MaybeInitializers "}" .
+
+ $default reduce using rule 18 (MaybeInitially)
diff --git a/src/various/GrammarParser.tab.h b/src/various/GrammarParser.tab.h
index c58b79702..0e99fde05 100644
--- a/src/various/GrammarParser.tab.h
+++ b/src/various/GrammarParser.tab.h
@@ -348,10 +348,12 @@ namespace libcasm_fe {
// Definition
// AttributedDefinition
// FeatureDeclarationOrDefinition
+ // ImplementationDefinitionDefinition
char dummy16[sizeof(Definition::Ptr)];
// Definitions
// FeatureDeclarationsAndDefinitions
+ // ImplementationDefinitionDefinitions
char dummy17[sizeof(Definitions::Ptr)];
// DerivedDefinition
@@ -406,77 +408,80 @@ namespace libcasm_fe {
// DotSeparatedIdentifiers
char dummy32[sizeof(Identifiers::Ptr)];
+ // ImplementationDefinition
+ char dummy33[sizeof(ImplementationDefinition::Ptr)];
+
// IndirectCallExpression
- char dummy33[sizeof(IndirectCallExpression::Ptr)];
+ char dummy34[sizeof(IndirectCallExpression::Ptr)];
// IterateRule
- char dummy34[sizeof(IterateRule::Ptr)];
+ char dummy35[sizeof(IterateRule::Ptr)];
// LetExpression
- char dummy35[sizeof(LetExpression::Ptr)];
+ char dummy36[sizeof(LetExpression::Ptr)];
// LetRule
- char dummy36[sizeof(LetRule::Ptr)];
+ char dummy37[sizeof(LetRule::Ptr)];
// List
- char dummy37[sizeof(ListExpression::Ptr)];
+ char dummy38[sizeof(ListExpression::Ptr)];
// MaybeInitially
// Initializers
// MaybeInitializers
- char dummy38[sizeof(NodeList< UpdateRule >::Ptr)];
+ char dummy39[sizeof(NodeList< UpdateRule >::Ptr)];
// Parameters
// MaybeParameters
- char dummy39[sizeof(NodeList< VariableDefinition >::Ptr)];
+ char dummy40[sizeof(NodeList< VariableDefinition >::Ptr)];
// Range
- char dummy40[sizeof(RangeExpression::Ptr)];
+ char dummy41[sizeof(RangeExpression::Ptr)];
// Reference
- char dummy41[sizeof(ReferenceAtom::Ptr)];
+ char dummy42[sizeof(ReferenceAtom::Ptr)];
// RelationType
- char dummy42[sizeof(RelationType::Ptr)];
+ char dummy43[sizeof(RelationType::Ptr)];
// Rule
- char dummy43[sizeof(Rule::Ptr)];
+ char dummy44[sizeof(Rule::Ptr)];
// RuleDefinition
- char dummy44[sizeof(RuleDefinition::Ptr)];
+ char dummy45[sizeof(RuleDefinition::Ptr)];
// Rules
- char dummy45[sizeof(Rules::Ptr)];
+ char dummy46[sizeof(Rules::Ptr)];
// SequenceRule
- char dummy46[sizeof(SequenceRule::Ptr)];
+ char dummy47[sizeof(SequenceRule::Ptr)];
// SkipRule
- char dummy47[sizeof(SkipRule::Ptr)];
+ char dummy48[sizeof(SkipRule::Ptr)];
// Specification
- char dummy48[sizeof(Specification::Ptr)];
+ char dummy49[sizeof(Specification::Ptr)];
// StructureDefinition
- char dummy49[sizeof(StructureDefinition::Ptr)];
+ char dummy50[sizeof(StructureDefinition::Ptr)];
// Type
- char dummy50[sizeof(Type::Ptr)];
+ char dummy51[sizeof(Type::Ptr)];
// FunctionParameters
// MaybeFunctionParameters
// Types
- char dummy51[sizeof(Types::Ptr)];
+ char dummy52[sizeof(Types::Ptr)];
// Undefined
- char dummy52[sizeof(UndefAtom::Ptr)];
+ char dummy53[sizeof(UndefAtom::Ptr)];
// UniversalQuantifierExpression
- char dummy53[sizeof(UniversalQuantifierExpression::Ptr)];
+ char dummy54[sizeof(UniversalQuantifierExpression::Ptr)];
// Initializer
// UpdateRule
- char dummy54[sizeof(UpdateRule::Ptr)];
+ char dummy55[sizeof(UpdateRule::Ptr)];
// Boolean
// String
@@ -484,11 +489,11 @@ namespace libcasm_fe {
// IntegerNumber
// FloatingNumber
// RationalNumber
- char dummy55[sizeof(ValueAtom::Ptr)];
+ char dummy56[sizeof(ValueAtom::Ptr)];
// Variable
// AttributedVariable
- char dummy56[sizeof(VariableDefinition::Ptr)];
+ char dummy57[sizeof(VariableDefinition::Ptr)];
// "binary"
// "hexadecimal"
@@ -497,7 +502,7 @@ namespace libcasm_fe {
// "floating"
// "string"
// "identifier"
- char dummy57[sizeof(std::string)];
+ char dummy58[sizeof(std::string)];
};
/// Symbol semantic values.
@@ -531,76 +536,79 @@ namespace libcasm_fe {
DEFINED = 265,
STRUCTURE = 266,
FEATURE = 267,
- SEQ = 268,
- ENDSEQ = 269,
- PAR = 270,
- ENDPAR = 271,
- SKIP = 272,
- LET = 273,
- IN = 274,
- FORALL = 275,
- CHOOSE = 276,
- ITERATE = 277,
- DO = 278,
- CALL = 279,
- IF = 280,
- THEN = 281,
- ELSE = 282,
- CASE = 283,
- OF = 284,
- DEFAULT = 285,
- HOLDS = 286,
- EXISTS = 287,
- WITH = 288,
- UNDEF = 289,
- FALSE = 290,
- TRUE = 291,
- AND = 292,
- OR = 293,
- XOR = 294,
- IMPLIES = 295,
- NOT = 296,
- PLUS = 297,
- MINUS = 298,
- EQUAL = 299,
- LPAREN = 300,
- RPAREN = 301,
- LSQPAREN = 302,
- RSQPAREN = 303,
- LCURPAREN = 304,
- RCURPAREN = 305,
- COLON = 306,
- UNDERLINE = 307,
- AT = 308,
- COMMA = 309,
- LESSER = 310,
- GREATER = 311,
- ASTERIX = 312,
- SLASH = 313,
- PERCENT = 314,
- CARET = 315,
- MARK = 316,
- DOTDOT = 317,
- DOT = 318,
- MAPS = 319,
- ARROW = 320,
- UPDATE = 321,
- NEQUAL = 322,
- LESSEQ = 323,
- GREATEREQ = 324,
- SEQ_BRACKET = 325,
- ENDSEQ_BRACKET = 326,
- BINARY = 327,
- HEXADECIMAL = 328,
- INTEGER = 329,
- RATIONAL = 330,
- FLOATING = 331,
- STRING = 332,
- IDENTIFIER = 333,
- ABSOLUTE_PATH = 334,
- UPLUS = 335,
- UMINUS = 336,
- CALL_WITHOUT_ARGS = 337
+ IMPLEMENTS = 268,
+ FOR = 269,
+ THIS = 270,
+ SEQ = 271,
+ ENDSEQ = 272,
+ PAR = 273,
+ ENDPAR = 274,
+ SKIP = 275,
+ LET = 276,
+ IN = 277,
+ FORALL = 278,
+ CHOOSE = 279,
+ ITERATE = 280,
+ DO = 281,
+ CALL = 282,
+ IF = 283,
+ THEN = 284,
+ ELSE = 285,
+ CASE = 286,
+ OF = 287,
+ DEFAULT = 288,
+ HOLDS = 289,
+ EXISTS = 290,
+ WITH = 291,
+ UNDEF = 292,
+ FALSE = 293,
+ TRUE = 294,
+ AND = 295,
+ OR = 296,
+ XOR = 297,
+ IMPLIES = 298,
+ NOT = 299,
+ PLUS = 300,
+ MINUS = 301,
+ EQUAL = 302,
+ LPAREN = 303,
+ RPAREN = 304,
+ LSQPAREN = 305,
+ RSQPAREN = 306,
+ LCURPAREN = 307,
+ RCURPAREN = 308,
+ COLON = 309,
+ UNDERLINE = 310,
+ AT = 311,
+ COMMA = 312,
+ LESSER = 313,
+ GREATER = 314,
+ ASTERIX = 315,
+ SLASH = 316,
+ PERCENT = 317,
+ CARET = 318,
+ MARK = 319,
+ DOTDOT = 320,
+ DOT = 321,
+ MAPS = 322,
+ ARROW = 323,
+ UPDATE = 324,
+ NEQUAL = 325,
+ LESSEQ = 326,
+ GREATEREQ = 327,
+ SEQ_BRACKET = 328,
+ ENDSEQ_BRACKET = 329,
+ BINARY = 330,
+ HEXADECIMAL = 331,
+ INTEGER = 332,
+ RATIONAL = 333,
+ FLOATING = 334,
+ STRING = 335,
+ IDENTIFIER = 336,
+ ABSOLUTE_PATH = 337,
+ UPLUS = 338,
+ UMINUS = 339,
+ CALL_WITHOUT_ARGS = 340
};
};
@@ -702,6 +710,8 @@ namespace libcasm_fe {
basic_symbol (typename Base::kind_type t, const Identifiers::Ptr v, const location_type& l);
+ basic_symbol (typename Base::kind_type t, const ImplementationDefinition::Ptr v, const location_type& l);
+
basic_symbol (typename Base::kind_type t, const IndirectCallExpression::Ptr v, const location_type& l);
basic_symbol (typename Base::kind_type t, const IterateRule::Ptr v, const location_type& l);
@@ -863,6 +873,18 @@ namespace libcasm_fe {
symbol_type
make_FEATURE (const location_type& l);
+ static inline
+ symbol_type
+ make_IMPLEMENTS (const location_type& l);
+
+ static inline
+ symbol_type
+ make_FOR (const location_type& l);
+
+ static inline
+ symbol_type
+ make_THIS (const location_type& l);
+
static inline
symbol_type
make_SEQ (const location_type& l);
@@ -1348,12 +1370,12 @@ namespace libcasm_fe {
enum
{
yyeof_ = 0,
- yylast_ = 1904, ///< Last index in yytable_.
- yynnts_ = 79, ///< Number of nonterminal symbols.
- yyfinal_ = 22, ///< Termination state number.
+ yylast_ = 1992, ///< Last index in yytable_.
+ yynnts_ = 82, ///< Number of nonterminal symbols.
+ yyfinal_ = 24, ///< Termination state number.
yyterror_ = 1,
yyerrcode_ = 256,
- yyntokens_ = 83 ///< Number of tokens.
+ yyntokens_ = 86 ///< Number of tokens.
};
@@ -1406,9 +1428,10 @@ namespace libcasm_fe {
45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
- 75, 76, 77, 78, 79, 80, 81, 82
+ 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
+ 85
};
- const unsigned int user_token_number_max_ = 337;
+ const unsigned int user_token_number_max_ = 340;
const token_number_type undef_token_ = 2;
if (static_cast(t) <= yyeof_)
@@ -1441,259 +1464,265 @@ namespace libcasm_fe {
{
switch (other.type_get ())
{
- case 158: // Attribute
+ case 164: // Attribute
value.copy< Attribute::Ptr > (other.value);
break;
- case 159: // Attributes
+ case 165: // Attributes
value.copy< Attributes::Ptr > (other.value);
break;
- case 160: // BasicAttribute
+ case 166: // BasicAttribute
value.copy< BasicAttribute::Ptr > (other.value);
break;
- case 114: // BasicType
+ case 120: // BasicType
value.copy< BasicType::Ptr > (other.value);
break;
- case 154: // BlockRule
+ case 160: // BlockRule
value.copy< BlockRule::Ptr > (other.value);
break;
- case 157: // CallRule
+ case 163: // CallRule
value.copy< CallRule::Ptr > (other.value);
break;
- case 148: // CaseLabel
+ case 154: // CaseLabel
value.copy< Case::Ptr > (other.value);
break;
- case 147: // CaseRule
+ case 153: // CaseRule
value.copy< CaseRule::Ptr > (other.value);
break;
- case 149: // CaseLabels
+ case 155: // CaseLabels
value.copy< Cases::Ptr > (other.value);
break;
- case 139: // ChooseExpression
+ case 145: // ChooseExpression
value.copy< ChooseExpression::Ptr > (other.value);
break;
- case 152: // ChooseRule
+ case 158: // ChooseRule
value.copy< ChooseRule::Ptr > (other.value);
break;
- case 115: // ComposedType
+ case 121: // ComposedType
value.copy< ComposedType::Ptr > (other.value);
break;
- case 138: // ConditionalExpression
+ case 144: // ConditionalExpression
value.copy< ConditionalExpression::Ptr > (other.value);
break;
- case 146: // ConditionalRule
+ case 152: // ConditionalRule
value.copy< ConditionalRule::Ptr > (other.value);
break;
- case 104: // DeclarationDefinition
+ case 110: // DeclarationDefinition
value.copy< DeclarationDefinition::Ptr > (other.value);
break;
- case 85: // Definition
- case 86: // AttributedDefinition
- case 102: // FeatureDeclarationOrDefinition
+ case 88: // Definition
+ case 89: // AttributedDefinition
+ case 105: // FeatureDeclarationOrDefinition
+ case 108: // ImplementationDefinitionDefinition
value.copy< Definition::Ptr > (other.value);
break;
- case 87: // Definitions
- case 103: // FeatureDeclarationsAndDefinitions
+ case 90: // Definitions
+ case 106: // FeatureDeclarationsAndDefinitions
+ case 109: // ImplementationDefinitionDefinitions
value.copy< Definitions::Ptr > (other.value);
break;
- case 98: // DerivedDefinition
+ case 101: // DerivedDefinition
value.copy< DerivedDefinition::Ptr > (other.value);
break;
- case 135: // DirectCallExpression
+ case 141: // DirectCallExpression
value.copy< DirectCallExpression::Ptr > (other.value);
break;
- case 99: // EnumerationDefinition
+ case 102: // EnumerationDefinition
value.copy< EnumerationDefinition::Ptr > (other.value);
break;
- case 141: // ExistentialQuantifierExpression
+ case 147: // ExistentialQuantifierExpression
value.copy< ExistentialQuantifierExpression::Ptr > (other.value);
break;
- case 91: // MaybeDefined
- case 119: // Atom
- case 128: // Term
- case 129: // Expression
+ case 94: // MaybeDefined
+ case 125: // Atom
+ case 134: // Term
+ case 135: // Expression
value.copy< Expression::Ptr > (other.value);
break;
- case 161: // ExpressionAttribute
+ case 167: // ExpressionAttribute
value.copy< ExpressionAttribute::Ptr > (other.value);
break;
- case 132: // Terms
- case 133: // Arguments
- case 134: // TwoOrMoreArguments
+ case 138: // Terms
+ case 139: // Arguments
+ case 140: // TwoOrMoreArguments
value.copy< Expressions::Ptr > (other.value);
break;
- case 101: // FeatureDefinition
+ case 104: // FeatureDefinition
value.copy< FeatureDefinition::Ptr > (other.value);
break;
- case 117: // FixedSizedType
+ case 123: // FixedSizedType
value.copy< FixedSizedType::Ptr > (other.value);
break;
- case 151: // ForallRule
+ case 157: // ForallRule
value.copy< ForallRule::Ptr > (other.value);
break;
- case 88: // FunctionDefinition
- case 94: // ProgramFunctionDefinition
+ case 91: // FunctionDefinition
+ case 97: // ProgramFunctionDefinition
value.copy< FunctionDefinition::Ptr > (other.value);
break;
- case 89: // FunctionDefinitions
+ case 92: // FunctionDefinitions
value.copy< FunctionDefinitions::Ptr > (other.value);
break;
- case 105: // Identifier
+ case 111: // Identifier
value.copy< Identifier::Ptr > (other.value);
break;
- case 108: // IdentifierPath
+ case 114: // IdentifierPath
value.copy< IdentifierPath::Ptr > (other.value);
break;
- case 106: // Identifiers
- case 107: // DotSeparatedIdentifiers
+ case 112: // Identifiers
+ case 113: // DotSeparatedIdentifiers
value.copy< Identifiers::Ptr > (other.value);
break;
- case 136: // IndirectCallExpression
+ case 107: // ImplementationDefinition
+ value.copy< ImplementationDefinition::Ptr > (other.value);
+ break;
+
+ case 142: // IndirectCallExpression
value.copy< IndirectCallExpression::Ptr > (other.value);
break;
- case 153: // IterateRule
+ case 159: // IterateRule
value.copy< IterateRule::Ptr > (other.value);
break;
- case 137: // LetExpression
+ case 143: // LetExpression
value.copy< LetExpression::Ptr > (other.value);
break;
- case 150: // LetRule
+ case 156: // LetRule
value.copy< LetRule::Ptr > (other.value);
break;
- case 131: // List
+ case 137: // List
value.copy< ListExpression::Ptr > (other.value);
break;
- case 90: // MaybeInitially
- case 96: // Initializers
- case 97: // MaybeInitializers
+ case 93: // MaybeInitially
+ case 99: // Initializers
+ case 100: // MaybeInitializers
value.copy< NodeList< UpdateRule >::Ptr > (other.value);
break;
- case 111: // Parameters
- case 112: // MaybeParameters
+ case 117: // Parameters
+ case 118: // MaybeParameters
value.copy< NodeList< VariableDefinition >::Ptr > (other.value);
break;
- case 130: // Range
+ case 136: // Range
value.copy< RangeExpression::Ptr > (other.value);
break;
- case 127: // Reference
+ case 133: // Reference
value.copy< ReferenceAtom::Ptr > (other.value);
break;
- case 116: // RelationType
+ case 122: // RelationType
value.copy< RelationType::Ptr > (other.value);
break;
- case 143: // Rule
+ case 149: // Rule
value.copy< Rule::Ptr > (other.value);
break;
- case 142: // RuleDefinition
+ case 148: // RuleDefinition
value.copy< RuleDefinition::Ptr > (other.value);
break;
- case 144: // Rules
+ case 150: // Rules
value.copy< Rules::Ptr > (other.value);
break;
- case 155: // SequenceRule
+ case 161: // SequenceRule
value.copy< SequenceRule::Ptr > (other.value);
break;
- case 145: // SkipRule
+ case 151: // SkipRule
value.copy< SkipRule::Ptr > (other.value);
break;
- case 84: // Specification
+ case 87: // Specification
value.copy< Specification::Ptr > (other.value);
break;
- case 100: // StructureDefinition
+ case 103: // StructureDefinition
value.copy< StructureDefinition::Ptr > (other.value);
break;
- case 113: // Type
+ case 119: // Type
value.copy< Type::Ptr > (other.value);
break;
- case 92: // FunctionParameters
- case 93: // MaybeFunctionParameters
- case 118: // Types
+ case 95: // FunctionParameters
+ case 96: // MaybeFunctionParameters
+ case 124: // Types
value.copy< Types::Ptr > (other.value);
break;
- case 120: // Undefined
+ case 126: // Undefined
value.copy< UndefAtom::Ptr > (other.value);
break;
- case 140: // UniversalQuantifierExpression
+ case 146: // UniversalQuantifierExpression
value.copy< UniversalQuantifierExpression::Ptr > (other.value);
break;
- case 95: // Initializer
- case 156: // UpdateRule
+ case 98: // Initializer
+ case 162: // UpdateRule
value.copy< UpdateRule::Ptr > (other.value);
break;
- case 121: // Boolean
- case 122: // String
- case 123: // BitNumber
- case 124: // IntegerNumber
- case 125: // FloatingNumber
- case 126: // RationalNumber
+ case 127: // Boolean
+ case 128: // String
+ case 129: // BitNumber
+ case 130: // IntegerNumber
+ case 131: // FloatingNumber
+ case 132: // RationalNumber
value.copy< ValueAtom::Ptr > (other.value);
break;
- case 109: // Variable
- case 110: // AttributedVariable
+ case 115: // Variable
+ case 116: // AttributedVariable
value.copy< VariableDefinition::Ptr > (other.value);
break;
- case 72: // "binary"
- case 73: // "hexadecimal"
- case 74: // "integer"
- case 75: // "rational"
- case 76: // "floating"
- case 77: // "string"
- case 78: // "identifier"
+ case 75: // "binary"
+ case 76: // "hexadecimal"
+ case 77: // "integer"
+ case 78: // "rational"
+ case 79: // "floating"
+ case 80: // "string"
+ case 81: // "identifier"
value.copy< std::string > (other.value);
break;
@@ -1714,259 +1743,265 @@ namespace libcasm_fe {
(void) v;
switch (this->type_get ())
{
- case 158: // Attribute
+ case 164: // Attribute
value.copy< Attribute::Ptr > (v);
break;
- case 159: // Attributes
+ case 165: // Attributes
value.copy< Attributes::Ptr > (v);
break;
- case 160: // BasicAttribute
+ case 166: // BasicAttribute
value.copy< BasicAttribute::Ptr > (v);
break;
- case 114: // BasicType
+ case 120: // BasicType
value.copy< BasicType::Ptr > (v);
break;
- case 154: // BlockRule
+ case 160: // BlockRule
value.copy< BlockRule::Ptr > (v);
break;
- case 157: // CallRule
+ case 163: // CallRule
value.copy< CallRule::Ptr > (v);
break;
- case 148: // CaseLabel
+ case 154: // CaseLabel
value.copy< Case::Ptr > (v);
break;
- case 147: // CaseRule
+ case 153: // CaseRule
value.copy< CaseRule::Ptr > (v);
break;
- case 149: // CaseLabels
+ case 155: // CaseLabels
value.copy< Cases::Ptr > (v);
break;
- case 139: // ChooseExpression
+ case 145: // ChooseExpression
value.copy< ChooseExpression::Ptr > (v);
break;
- case 152: // ChooseRule
+ case 158: // ChooseRule
value.copy< ChooseRule::Ptr > (v);
break;
- case 115: // ComposedType
+ case 121: // ComposedType
value.copy< ComposedType::Ptr > (v);
break;
- case 138: // ConditionalExpression
+ case 144: // ConditionalExpression
value.copy< ConditionalExpression::Ptr > (v);
break;
- case 146: // ConditionalRule
+ case 152: // ConditionalRule
value.copy< ConditionalRule::Ptr > (v);
break;
- case 104: // DeclarationDefinition
+ case 110: // DeclarationDefinition
value.copy< DeclarationDefinition::Ptr > (v);
break;
- case 85: // Definition
- case 86: // AttributedDefinition
- case 102: // FeatureDeclarationOrDefinition
+ case 88: // Definition
+ case 89: // AttributedDefinition
+ case 105: // FeatureDeclarationOrDefinition
+ case 108: // ImplementationDefinitionDefinition
value.copy< Definition::Ptr > (v);
break;
- case 87: // Definitions
- case 103: // FeatureDeclarationsAndDefinitions
+ case 90: // Definitions
+ case 106: // FeatureDeclarationsAndDefinitions
+ case 109: // ImplementationDefinitionDefinitions
value.copy< Definitions::Ptr > (v);
break;
- case 98: // DerivedDefinition
+ case 101: // DerivedDefinition
value.copy< DerivedDefinition::Ptr > (v);
break;
- case 135: // DirectCallExpression
+ case 141: // DirectCallExpression
value.copy< DirectCallExpression::Ptr > (v);
break;
- case 99: // EnumerationDefinition
+ case 102: // EnumerationDefinition
value.copy< EnumerationDefinition::Ptr > (v);
break;
- case 141: // ExistentialQuantifierExpression
+ case 147: // ExistentialQuantifierExpression
value.copy< ExistentialQuantifierExpression::Ptr > (v);
break;
- case 91: // MaybeDefined
- case 119: // Atom
- case 128: // Term
- case 129: // Expression
+ case 94: // MaybeDefined
+ case 125: // Atom
+ case 134: // Term
+ case 135: // Expression
value.copy< Expression::Ptr > (v);
break;
- case 161: // ExpressionAttribute
+ case 167: // ExpressionAttribute
value.copy< ExpressionAttribute::Ptr > (v);
break;
- case 132: // Terms
- case 133: // Arguments
- case 134: // TwoOrMoreArguments
+ case 138: // Terms
+ case 139: // Arguments
+ case 140: // TwoOrMoreArguments
value.copy< Expressions::Ptr > (v);
break;
- case 101: // FeatureDefinition
+ case 104: // FeatureDefinition
value.copy< FeatureDefinition::Ptr > (v);
break;
- case 117: // FixedSizedType
+ case 123: // FixedSizedType
value.copy< FixedSizedType::Ptr > (v);
break;
- case 151: // ForallRule
+ case 157: // ForallRule
value.copy< ForallRule::Ptr > (v);
break;
- case 88: // FunctionDefinition
- case 94: // ProgramFunctionDefinition
+ case 91: // FunctionDefinition
+ case 97: // ProgramFunctionDefinition
value.copy< FunctionDefinition::Ptr > (v);
break;
- case 89: // FunctionDefinitions
+ case 92: // FunctionDefinitions
value.copy< FunctionDefinitions::Ptr > (v);
break;
- case 105: // Identifier
+ case 111: // Identifier
value.copy< Identifier::Ptr > (v);
break;
- case 108: // IdentifierPath
+ case 114: // IdentifierPath
value.copy< IdentifierPath::Ptr > (v);
break;
- case 106: // Identifiers
- case 107: // DotSeparatedIdentifiers
+ case 112: // Identifiers
+ case 113: // DotSeparatedIdentifiers
value.copy< Identifiers::Ptr > (v);
break;
- case 136: // IndirectCallExpression
+ case 107: // ImplementationDefinition
+ value.copy< ImplementationDefinition::Ptr > (v);
+ break;
+
+ case 142: // IndirectCallExpression
value.copy< IndirectCallExpression::Ptr > (v);
break;
- case 153: // IterateRule
+ case 159: // IterateRule
value.copy< IterateRule::Ptr > (v);
break;
- case 137: // LetExpression
+ case 143: // LetExpression
value.copy< LetExpression::Ptr > (v);
break;
- case 150: // LetRule
+ case 156: // LetRule
value.copy< LetRule::Ptr > (v);
break;
- case 131: // List
+ case 137: // List
value.copy< ListExpression::Ptr > (v);
break;
- case 90: // MaybeInitially
- case 96: // Initializers
- case 97: // MaybeInitializers
+ case 93: // MaybeInitially
+ case 99: // Initializers
+ case 100: // MaybeInitializers
value.copy< NodeList< UpdateRule >::Ptr > (v);
break;
- case 111: // Parameters
- case 112: // MaybeParameters
+ case 117: // Parameters
+ case 118: // MaybeParameters
value.copy< NodeList< VariableDefinition >::Ptr > (v);
break;
- case 130: // Range
+ case 136: // Range
value.copy< RangeExpression::Ptr > (v);
break;
- case 127: // Reference
+ case 133: // Reference
value.copy< ReferenceAtom::Ptr > (v);
break;
- case 116: // RelationType
+ case 122: // RelationType
value.copy< RelationType::Ptr > (v);
break;
- case 143: // Rule
+ case 149: // Rule
value.copy< Rule::Ptr > (v);
break;
- case 142: // RuleDefinition
+ case 148: // RuleDefinition
value.copy< RuleDefinition::Ptr > (v);
break;
- case 144: // Rules
+ case 150: // Rules
value.copy< Rules::Ptr > (v);
break;
- case 155: // SequenceRule
+ case 161: // SequenceRule
value.copy< SequenceRule::Ptr > (v);
break;
- case 145: // SkipRule
+ case 151: // SkipRule
value.copy< SkipRule::Ptr > (v);
break;
- case 84: // Specification
+ case 87: // Specification
value.copy< Specification::Ptr > (v);
break;
- case 100: // StructureDefinition
+ case 103: // StructureDefinition
value.copy< StructureDefinition::Ptr > (v);
break;
- case 113: // Type
+ case 119: // Type
value.copy< Type::Ptr > (v);
break;
- case 92: // FunctionParameters
- case 93: // MaybeFunctionParameters
- case 118: // Types
+ case 95: // FunctionParameters
+ case 96: // MaybeFunctionParameters
+ case 124: // Types
value.copy< Types::Ptr > (v);
break;
- case 120: // Undefined
+ case 126: // Undefined
value.copy< UndefAtom::Ptr > (v);
break;
- case 140: // UniversalQuantifierExpression
+ case 146: // UniversalQuantifierExpression
value.copy< UniversalQuantifierExpression::Ptr > (v);
break;
- case 95: // Initializer
- case 156: // UpdateRule
+ case 98: // Initializer
+ case 162: // UpdateRule
value.copy< UpdateRule::Ptr > (v);
break;
- case 121: // Boolean
- case 122: // String
- case 123: // BitNumber
- case 124: // IntegerNumber
- case 125: // FloatingNumber
- case 126: // RationalNumber
+ case 127: // Boolean
+ case 128: // String
+ case 129: // BitNumber
+ case 130: // IntegerNumber
+ case 131: // FloatingNumber
+ case 132: // RationalNumber
value.copy< ValueAtom::Ptr > (v);
break;
- case 109: // Variable
- case 110: // AttributedVariable
+ case 115: // Variable
+ case 116: // AttributedVariable
value.copy< VariableDefinition::Ptr > (v);
break;
- case 72: // "binary"
- case 73: // "hexadecimal"
- case 74: // "integer"
- case 75: // "rational"
- case 76: // "floating"
- case 77: // "string"
- case 78: // "identifier"
+ case 75: // "binary"
+ case 76: // "hexadecimal"
+ case 77: // "integer"
+ case 78: // "rational"
+ case 79: // "floating"
+ case 80: // "string"
+ case 81: // "identifier"
value.copy< std::string > (v);
break;
@@ -2209,6 +2244,13 @@ namespace libcasm_fe {
, location (l)
{}
+ template
+ Parser::basic_symbol::basic_symbol (typename Base::kind_type t, const ImplementationDefinition::Ptr v, const location_type& l)
+ : Base (t)
+ , value (v)
+ , location (l)
+ {}
+
template
Parser::basic_symbol::basic_symbol (typename Base::kind_type t, const IndirectCallExpression::Ptr v, const location_type& l)
: Base (t)
@@ -2410,259 +2452,265 @@ namespace libcasm_fe {
// Type destructor.
switch (yytype)
{
- case 158: // Attribute
+ case 164: // Attribute
value.template destroy< Attribute::Ptr > ();
break;
- case 159: // Attributes
+ case 165: // Attributes
value.template destroy< Attributes::Ptr > ();
break;
- case 160: // BasicAttribute
+ case 166: // BasicAttribute
value.template destroy< BasicAttribute::Ptr > ();
break;
- case 114: // BasicType
+ case 120: // BasicType
value.template destroy< BasicType::Ptr > ();
break;
- case 154: // BlockRule
+ case 160: // BlockRule
value.template destroy< BlockRule::Ptr > ();
break;
- case 157: // CallRule
+ case 163: // CallRule
value.template destroy< CallRule::Ptr > ();
break;
- case 148: // CaseLabel
+ case 154: // CaseLabel
value.template destroy< Case::Ptr > ();
break;
- case 147: // CaseRule
+ case 153: // CaseRule
value.template destroy< CaseRule::Ptr > ();
break;
- case 149: // CaseLabels
+ case 155: // CaseLabels
value.template destroy< Cases::Ptr > ();
break;
- case 139: // ChooseExpression
+ case 145: // ChooseExpression
value.template destroy< ChooseExpression::Ptr > ();
break;
- case 152: // ChooseRule
+ case 158: // ChooseRule
value.template destroy< ChooseRule::Ptr > ();
break;
- case 115: // ComposedType
+ case 121: // ComposedType
value.template destroy< ComposedType::Ptr > ();
break;
- case 138: // ConditionalExpression
+ case 144: // ConditionalExpression
value.template destroy< ConditionalExpression::Ptr > ();
break;
- case 146: // ConditionalRule
+ case 152: // ConditionalRule
value.template destroy< ConditionalRule::Ptr > ();
break;
- case 104: // DeclarationDefinition
+ case 110: // DeclarationDefinition
value.template destroy< DeclarationDefinition::Ptr > ();
break;
- case 85: // Definition
- case 86: // AttributedDefinition
- case 102: // FeatureDeclarationOrDefinition
+ case 88: // Definition
+ case 89: // AttributedDefinition
+ case 105: // FeatureDeclarationOrDefinition
+ case 108: // ImplementationDefinitionDefinition
value.template destroy< Definition::Ptr > ();
break;
- case 87: // Definitions
- case 103: // FeatureDeclarationsAndDefinitions
+ case 90: // Definitions
+ case 106: // FeatureDeclarationsAndDefinitions
+ case 109: // ImplementationDefinitionDefinitions
value.template destroy< Definitions::Ptr > ();
break;
- case 98: // DerivedDefinition
+ case 101: // DerivedDefinition
value.template destroy< DerivedDefinition::Ptr > ();
break;
- case 135: // DirectCallExpression
+ case 141: // DirectCallExpression
value.template destroy< DirectCallExpression::Ptr > ();
break;
- case 99: // EnumerationDefinition
+ case 102: // EnumerationDefinition
value.template destroy< EnumerationDefinition::Ptr > ();
break;
- case 141: // ExistentialQuantifierExpression
+ case 147: // ExistentialQuantifierExpression
value.template destroy< ExistentialQuantifierExpression::Ptr > ();
break;
- case 91: // MaybeDefined
- case 119: // Atom
- case 128: // Term
- case 129: // Expression
+ case 94: // MaybeDefined
+ case 125: // Atom
+ case 134: // Term
+ case 135: // Expression
value.template destroy< Expression::Ptr > ();
break;
- case 161: // ExpressionAttribute
+ case 167: // ExpressionAttribute
value.template destroy< ExpressionAttribute::Ptr > ();
break;
- case 132: // Terms
- case 133: // Arguments
- case 134: // TwoOrMoreArguments
+ case 138: // Terms
+ case 139: // Arguments
+ case 140: // TwoOrMoreArguments
value.template destroy< Expressions::Ptr > ();
break;
- case 101: // FeatureDefinition
+ case 104: // FeatureDefinition
value.template destroy< FeatureDefinition::Ptr > ();
break;
- case 117: // FixedSizedType
+ case 123: // FixedSizedType
value.template destroy< FixedSizedType::Ptr > ();
break;
- case 151: // ForallRule
+ case 157: // ForallRule
value.template destroy< ForallRule::Ptr > ();
break;
- case 88: // FunctionDefinition
- case 94: // ProgramFunctionDefinition
+ case 91: // FunctionDefinition
+ case 97: // ProgramFunctionDefinition
value.template destroy< FunctionDefinition::Ptr > ();
break;
- case 89: // FunctionDefinitions
+ case 92: // FunctionDefinitions
value.template destroy< FunctionDefinitions::Ptr > ();
break;
- case 105: // Identifier
+ case 111: // Identifier
value.template destroy< Identifier::Ptr > ();
break;
- case 108: // IdentifierPath
+ case 114: // IdentifierPath
value.template destroy< IdentifierPath::Ptr > ();
break;
- case 106: // Identifiers
- case 107: // DotSeparatedIdentifiers
+ case 112: // Identifiers
+ case 113: // DotSeparatedIdentifiers
value.template destroy< Identifiers::Ptr > ();
break;
- case 136: // IndirectCallExpression
+ case 107: // ImplementationDefinition
+ value.template destroy< ImplementationDefinition::Ptr > ();
+ break;
+
+ case 142: // IndirectCallExpression
value.template destroy< IndirectCallExpression::Ptr > ();
break;
- case 153: // IterateRule
+ case 159: // IterateRule
value.template destroy< IterateRule::Ptr > ();
break;
- case 137: // LetExpression
+ case 143: // LetExpression
value.template destroy< LetExpression::Ptr > ();
break;
- case 150: // LetRule
+ case 156: // LetRule
value.template destroy< LetRule::Ptr > ();
break;
- case 131: // List
+ case 137: // List
value.template destroy< ListExpression::Ptr > ();
break;
- case 90: // MaybeInitially
- case 96: // Initializers
- case 97: // MaybeInitializers
+ case 93: // MaybeInitially
+ case 99: // Initializers
+ case 100: // MaybeInitializers
value.template destroy< NodeList< UpdateRule >::Ptr > ();
break;
- case 111: // Parameters
- case 112: // MaybeParameters
+ case 117: // Parameters
+ case 118: // MaybeParameters
value.template destroy< NodeList< VariableDefinition >::Ptr > ();
break;
- case 130: // Range
+ case 136: // Range
value.template destroy< RangeExpression::Ptr > ();
break;
- case 127: // Reference
+ case 133: // Reference
value.template destroy< ReferenceAtom::Ptr > ();
break;
- case 116: // RelationType
+ case 122: // RelationType
value.template destroy< RelationType::Ptr > ();
break;
- case 143: // Rule
+ case 149: // Rule
value.template destroy< Rule::Ptr > ();
break;
- case 142: // RuleDefinition
+ case 148: // RuleDefinition
value.template destroy< RuleDefinition::Ptr > ();
break;
- case 144: // Rules
+ case 150: // Rules
value.template destroy< Rules::Ptr > ();
break;
- case 155: // SequenceRule
+ case 161: // SequenceRule
value.template destroy< SequenceRule::Ptr > ();
break;
- case 145: // SkipRule
+ case 151: // SkipRule
value.template destroy< SkipRule::Ptr > ();
break;
- case 84: // Specification
+ case 87: // Specification
value.template destroy< Specification::Ptr > ();
break;
- case 100: // StructureDefinition
+ case 103: // StructureDefinition
value.template destroy< StructureDefinition::Ptr > ();
break;
- case 113: // Type
+ case 119: // Type
value.template destroy< Type::Ptr > ();
break;
- case 92: // FunctionParameters
- case 93: // MaybeFunctionParameters
- case 118: // Types
+ case 95: // FunctionParameters
+ case 96: // MaybeFunctionParameters
+ case 124: // Types
value.template destroy< Types::Ptr > ();
break;
- case 120: // Undefined
+ case 126: // Undefined
value.template destroy< UndefAtom::Ptr > ();
break;
- case 140: // UniversalQuantifierExpression
+ case 146: // UniversalQuantifierExpression
value.template destroy< UniversalQuantifierExpression::Ptr > ();
break;
- case 95: // Initializer
- case 156: // UpdateRule
+ case 98: // Initializer
+ case 162: // UpdateRule
value.template destroy< UpdateRule::Ptr > ();
break;
- case 121: // Boolean
- case 122: // String
- case 123: // BitNumber
- case 124: // IntegerNumber
- case 125: // FloatingNumber
- case 126: // RationalNumber
+ case 127: // Boolean
+ case 128: // String
+ case 129: // BitNumber
+ case 130: // IntegerNumber
+ case 131: // FloatingNumber
+ case 132: // RationalNumber
value.template destroy< ValueAtom::Ptr > ();
break;
- case 109: // Variable
- case 110: // AttributedVariable
+ case 115: // Variable
+ case 116: // AttributedVariable
value.template destroy< VariableDefinition::Ptr > ();
break;
- case 72: // "binary"
- case 73: // "hexadecimal"
- case 74: // "integer"
- case 75: // "rational"
- case 76: // "floating"
- case 77: // "string"
- case 78: // "identifier"
+ case 75: // "binary"
+ case 76: // "hexadecimal"
+ case 77: // "integer"
+ case 78: // "rational"
+ case 79: // "floating"
+ case 80: // "string"
+ case 81: // "identifier"
value.template destroy< std::string > ();
break;
@@ -2689,259 +2737,265 @@ namespace libcasm_fe {
super_type::move(s);
switch (this->type_get ())
{
- case 158: // Attribute
+ case 164: // Attribute
value.move< Attribute::Ptr > (s.value);
break;
- case 159: // Attributes
+ case 165: // Attributes
value.move< Attributes::Ptr > (s.value);
break;
- case 160: // BasicAttribute
+ case 166: // BasicAttribute
value.move< BasicAttribute::Ptr > (s.value);
break;
- case 114: // BasicType
+ case 120: // BasicType
value.move< BasicType::Ptr > (s.value);
break;
- case 154: // BlockRule
+ case 160: // BlockRule
value.move< BlockRule::Ptr > (s.value);
break;
- case 157: // CallRule
+ case 163: // CallRule
value.move< CallRule::Ptr > (s.value);
break;
- case 148: // CaseLabel
+ case 154: // CaseLabel
value.move< Case::Ptr > (s.value);
break;
- case 147: // CaseRule
+ case 153: // CaseRule
value.move< CaseRule::Ptr > (s.value);
break;
- case 149: // CaseLabels
+ case 155: // CaseLabels
value.move< Cases::Ptr > (s.value);
break;
- case 139: // ChooseExpression
+ case 145: // ChooseExpression
value.move< ChooseExpression::Ptr > (s.value);
break;
- case 152: // ChooseRule
+ case 158: // ChooseRule
value.move< ChooseRule::Ptr > (s.value);
break;
- case 115: // ComposedType
+ case 121: // ComposedType
value.move< ComposedType::Ptr > (s.value);
break;
- case 138: // ConditionalExpression
+ case 144: // ConditionalExpression
value.move< ConditionalExpression::Ptr > (s.value);
break;
- case 146: // ConditionalRule
+ case 152: // ConditionalRule
value.move< ConditionalRule::Ptr > (s.value);
break;
- case 104: // DeclarationDefinition
+ case 110: // DeclarationDefinition
value.move< DeclarationDefinition::Ptr > (s.value);
break;
- case 85: // Definition
- case 86: // AttributedDefinition
- case 102: // FeatureDeclarationOrDefinition
+ case 88: // Definition
+ case 89: // AttributedDefinition
+ case 105: // FeatureDeclarationOrDefinition
+ case 108: // ImplementationDefinitionDefinition
value.move< Definition::Ptr > (s.value);
break;
- case 87: // Definitions
- case 103: // FeatureDeclarationsAndDefinitions
+ case 90: // Definitions
+ case 106: // FeatureDeclarationsAndDefinitions
+ case 109: // ImplementationDefinitionDefinitions
value.move< Definitions::Ptr > (s.value);
break;
- case 98: // DerivedDefinition
+ case 101: // DerivedDefinition
value.move< DerivedDefinition::Ptr > (s.value);
break;
- case 135: // DirectCallExpression
+ case 141: // DirectCallExpression
value.move< DirectCallExpression::Ptr > (s.value);
break;
- case 99: // EnumerationDefinition
+ case 102: // EnumerationDefinition
value.move< EnumerationDefinition::Ptr > (s.value);
break;
- case 141: // ExistentialQuantifierExpression
+ case 147: // ExistentialQuantifierExpression
value.move< ExistentialQuantifierExpression::Ptr > (s.value);
break;
- case 91: // MaybeDefined
- case 119: // Atom
- case 128: // Term
- case 129: // Expression
+ case 94: // MaybeDefined
+ case 125: // Atom
+ case 134: // Term
+ case 135: // Expression
value.move< Expression::Ptr > (s.value);
break;
- case 161: // ExpressionAttribute
+ case 167: // ExpressionAttribute
value.move< ExpressionAttribute::Ptr > (s.value);
break;
- case 132: // Terms
- case 133: // Arguments
- case 134: // TwoOrMoreArguments
+ case 138: // Terms
+ case 139: // Arguments
+ case 140: // TwoOrMoreArguments
value.move< Expressions::Ptr > (s.value);
break;
- case 101: // FeatureDefinition
+ case 104: // FeatureDefinition
value.move< FeatureDefinition::Ptr > (s.value);
break;
- case 117: // FixedSizedType
+ case 123: // FixedSizedType
value.move< FixedSizedType::Ptr > (s.value);
break;
- case 151: // ForallRule
+ case 157: // ForallRule
value.move< ForallRule::Ptr > (s.value);
break;
- case 88: // FunctionDefinition
- case 94: // ProgramFunctionDefinition
+ case 91: // FunctionDefinition
+ case 97: // ProgramFunctionDefinition
value.move< FunctionDefinition::Ptr > (s.value);
break;
- case 89: // FunctionDefinitions
+ case 92: // FunctionDefinitions
value.move< FunctionDefinitions::Ptr > (s.value);
break;
- case 105: // Identifier
+ case 111: // Identifier
value.move< Identifier::Ptr > (s.value);
break;
- case 108: // IdentifierPath
+ case 114: // IdentifierPath
value.move< IdentifierPath::Ptr > (s.value);
break;
- case 106: // Identifiers
- case 107: // DotSeparatedIdentifiers
+ case 112: // Identifiers
+ case 113: // DotSeparatedIdentifiers
value.move< Identifiers::Ptr > (s.value);
break;
- case 136: // IndirectCallExpression
+ case 107: // ImplementationDefinition
+ value.move< ImplementationDefinition::Ptr > (s.value);
+ break;
+
+ case 142: // IndirectCallExpression
value.move< IndirectCallExpression::Ptr > (s.value);
break;
- case 153: // IterateRule
+ case 159: // IterateRule
value.move< IterateRule::Ptr > (s.value);
break;
- case 137: // LetExpression
+ case 143: // LetExpression
value.move< LetExpression::Ptr > (s.value);
break;
- case 150: // LetRule
+ case 156: // LetRule
value.move< LetRule::Ptr > (s.value);
break;
- case 131: // List
+ case 137: // List
value.move< ListExpression::Ptr > (s.value);
break;
- case 90: // MaybeInitially
- case 96: // Initializers
- case 97: // MaybeInitializers
+ case 93: // MaybeInitially
+ case 99: // Initializers
+ case 100: // MaybeInitializers
value.move< NodeList< UpdateRule >::Ptr > (s.value);
break;
- case 111: // Parameters
- case 112: // MaybeParameters
+ case 117: // Parameters
+ case 118: // MaybeParameters
value.move< NodeList< VariableDefinition >::Ptr > (s.value);
break;
- case 130: // Range
+ case 136: // Range
value.move< RangeExpression::Ptr > (s.value);
break;
- case 127: // Reference
+ case 133: // Reference
value.move< ReferenceAtom::Ptr > (s.value);
break;
- case 116: // RelationType
+ case 122: // RelationType
value.move< RelationType::Ptr > (s.value);
break;
- case 143: // Rule
+ case 149: // Rule
value.move< Rule::Ptr > (s.value);
break;
- case 142: // RuleDefinition
+ case 148: // RuleDefinition
value.move< RuleDefinition::Ptr > (s.value);
break;
- case 144: // Rules
+ case 150: // Rules
value.move< Rules::Ptr > (s.value);
break;
- case 155: // SequenceRule
+ case 161: // SequenceRule
value.move< SequenceRule::Ptr > (s.value);
break;
- case 145: // SkipRule
+ case 151: // SkipRule
value.move< SkipRule::Ptr > (s.value);
break;
- case 84: // Specification
+ case 87: // Specification
value.move< Specification::Ptr > (s.value);
break;
- case 100: // StructureDefinition
+ case 103: // StructureDefinition
value.move< StructureDefinition::Ptr > (s.value);
break;
- case 113: // Type
+ case 119: // Type
value.move< Type::Ptr > (s.value);
break;
- case 92: // FunctionParameters
- case 93: // MaybeFunctionParameters
- case 118: // Types
+ case 95: // FunctionParameters
+ case 96: // MaybeFunctionParameters
+ case 124: // Types
value.move< Types::Ptr > (s.value);
break;
- case 120: // Undefined
+ case 126: // Undefined
value.move< UndefAtom::Ptr > (s.value);
break;
- case 140: // UniversalQuantifierExpression
+ case 146: // UniversalQuantifierExpression
value.move< UniversalQuantifierExpression::Ptr > (s.value);
break;
- case 95: // Initializer
- case 156: // UpdateRule
+ case 98: // Initializer
+ case 162: // UpdateRule
value.move< UpdateRule::Ptr > (s.value);
break;
- case 121: // Boolean
- case 122: // String
- case 123: // BitNumber
- case 124: // IntegerNumber
- case 125: // FloatingNumber
- case 126: // RationalNumber
+ case 127: // Boolean
+ case 128: // String
+ case 129: // BitNumber
+ case 130: // IntegerNumber
+ case 131: // FloatingNumber
+ case 132: // RationalNumber
value.move< ValueAtom::Ptr > (s.value);
break;
- case 109: // Variable
- case 110: // AttributedVariable
+ case 115: // Variable
+ case 116: // AttributedVariable
value.move< VariableDefinition::Ptr > (s.value);
break;
- case 72: // "binary"
- case 73: // "hexadecimal"
- case 74: // "integer"
- case 75: // "rational"
- case 76: // "floating"
- case 77: // "string"
- case 78: // "identifier"
+ case 75: // "binary"
+ case 76: // "hexadecimal"
+ case 77: // "integer"
+ case 78: // "rational"
+ case 79: // "floating"
+ case 80: // "string"
+ case 81: // "identifier"
value.move< std::string > (s.value);
break;
@@ -3008,7 +3062,7 @@ namespace libcasm_fe {
305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
- 335, 336, 337
+ 335, 336, 337, 338, 339, 340
};
return static_cast (yytoken_number_[type]);
}
@@ -3079,6 +3133,24 @@ namespace libcasm_fe {
return symbol_type (token::FEATURE, l);
}
+ Parser::symbol_type
+ Parser::make_IMPLEMENTS (const location_type& l)
+ {
+ return symbol_type (token::IMPLEMENTS, l);
+ }
+
+ Parser::symbol_type
+ Parser::make_FOR (const location_type& l)
+ {
+ return symbol_type (token::FOR, l);
+ }
+
+ Parser::symbol_type
+ Parser::make_THIS (const location_type& l)
+ {
+ return symbol_type (token::THIS, l);
+ }
+
Parser::symbol_type
Parser::make_SEQ (const location_type& l)
{
@@ -3502,7 +3574,7 @@ namespace libcasm_fe {
#line 31 "../../obj/src/GrammarParser.yy" // lalr1.cc:377
} // libcasm_fe
-#line 3506 "GrammarParser.tab.h" // lalr1.cc:377
+#line 3578 "GrammarParser.tab.h" // lalr1.cc:377