Feature Definition and Declarations

* added new AST feature definition node and the new syntax to define a named feature - related to ref #35 * added new AST declaration definition node (needed by feature etc.)
casm-lang · Jul 29, 2017 · fce06e4 · emmanuel099 · Jul 30, 2017 · emmanuel099
1 parent 6997e6d
commit fce06e4
Show file tree

Hide file tree

Showing 17 changed files with 9,353 additions and 8,562 deletions.
diff --git a/src/GrammarParser.yy b/src/GrammarParser.yy
@@ -172,6 +172,10 @@ END       0 "end of file"
 %type <RuleDefinition::Ptr> RuleDefinition
 %type <EnumerationDefinition::Ptr> EnumerationDefinition
 %type <StructureDefinition::Ptr> StructureDefinition
+%type <FeatureDefinition::Ptr> FeatureDefinition
+%type <Definition::Ptr> FeatureDeclarationOrDefinition
+%type <Definitions::Ptr> FeatureDeclarationsAndDefinitions
+%type <DeclarationDefinition::Ptr> DeclarationDefinition
 
 // expressions
 %type <Expression::Ptr> Expression Term Atom
@@ -303,6 +307,10 @@ Definition
   {
       $$ = $1;
   }
+| FeatureDefinition
+  {
+      $$ = $1;
+  }
 | error // error recovery
   {
       $$ = nullptr;
@@ -554,6 +562,62 @@ StructureDefinition
 ;
 
 
+FeatureDefinition
+: FEATURE Identifier EQUAL LCURPAREN FeatureDeclarationsAndDefinitions RCURPAREN
+  {
+      $$ = Ast::make< FeatureDefinition >( @$, $2, $5 );
+  }
+;
+
+
+FeatureDeclarationOrDefinition
+: DeclarationDefinition
+  {
+      $$ = $1;
+  }
+| DerivedDefinition
+  {
+      $$ = $1;
+  }
+| RuleDefinition
+  {
+      $$ = $1;
+  }
+;
+
+
+FeatureDeclarationsAndDefinitions
+: FeatureDeclarationsAndDefinitions COMMA FeatureDeclarationOrDefinition
+  {
+      auto definitions = $1;
+      definitions->add( $3 );
+      $$ = definitions;
+  }
+| FeatureDeclarationOrDefinition
+  {
+      auto definitions = Ast::make< Definitions >( @$ );
+      definitions->add( $1 );
+      $$ = definitions;
+  }
+;
+
+
+DeclarationDefinition
+: DERIVED Identifier COLON MaybeFunctionParameters MAPS Type
+  {
+      auto declaration = Ast::make< DeclarationDefinition >( @$, $2, $4, $6 );
+      declaration->setKind( DeclarationDefinition::Kind::DERIVED );
+      $$ = declaration;
+  }
+| RULE Identifier COLON MaybeFunctionParameters MAPS Type
+  {
+      auto declaration = Ast::make< DeclarationDefinition >( @$, $2, $4, $6 );
+      declaration->setKind( DeclarationDefinition::Kind::RULE );
+      $$ = declaration;
+  }
+;
+
+
 Identifier
 : IDENTIFIER
   {

diff --git a/src/GrammarToken.hpp b/src/GrammarToken.hpp
@@ -36,6 +36,7 @@ INITIALLY       "initially"     { return Parser::make_INITIALLY(loc); }
 DEFINED         "defined"       { return Parser::make_DEFINED(loc); }
 
 STRUCTURE       "structure"     { return Parser::make_STRUCTURE(loc); }
+FEATURE         "feature"       { return Parser::make_FEATURE(loc); }
 
 SEQ             "seq"           { return Parser::make_SEQ(loc); }
 ENDSEQ          "endseq"        { return Parser::make_ENDSEQ(loc); }

diff --git a/src/ast/Definition.cpp b/src/ast/Definition.cpp
@@ -330,6 +330,85 @@ void StructureDefinition::accept( Visitor& visitor )
     visitor.visit( *this );
 }
 
+//
+//
+// FeatureDefinition
+//
+
+FeatureDefinition::FeatureDefinition(
+    const Identifier::Ptr& identifier, const Definitions::Ptr& definitions )
+: Definition( Node::ID::FEATURE_DEFINITION, identifier )
+, m_definitions( definitions )
+{
+}
+
+const Definitions::Ptr& FeatureDefinition::definitions( void ) const
+{
+    return m_definitions;
+}
+
+void FeatureDefinition::accept( Visitor& visitor )
+{
+    visitor.visit( *this );
+}
+
+//
+//
+// DeclarationDefinition
+//
+
+DeclarationDefinition::DeclarationDefinition( const Identifier::Ptr& identifier,
+    const Types::Ptr& argumentTypes,
+    const Type::Ptr& returnType )
+: Definition( Node::ID::DECLARATION_DEFINITION, identifier )
+, m_argumentTypes( argumentTypes )
+, m_returnType( returnType )
+{
+}
+
+const Types::Ptr& DeclarationDefinition::argumentTypes( void ) const
+{
+    return m_argumentTypes;
+}
+
+const Type::Ptr& DeclarationDefinition::returnType( void ) const
+{
+    return m_returnType;
+}
+
+void DeclarationDefinition::setKind( const Kind kind )
+{
+    m_kind = kind;
+}
+
+DeclarationDefinition::Kind DeclarationDefinition::kind( void ) const
+{
+    return m_kind;
+}
+
+std::string DeclarationDefinition::kindName( void ) const
+{
+    switch( kind() )
+    {
+        case DeclarationDefinition::Kind::DERIVED:
+        {
+            return "derived";
+        }
+        case DeclarationDefinition::Kind::RULE:
+        {
+            return "rule";
+        }
+    }
+
+    assert( !" internal error! " );
+    return std::string();
+}
+
+void DeclarationDefinition::accept( Visitor& visitor )
+{
+    visitor.visit( *this );
+}
+
 //
 //  Local variables:
 //  mode: c++

diff --git a/src/ast/Definition.h b/src/ast/Definition.h
@@ -234,6 +234,57 @@ namespace libcasm_fe
           private:
             const NodeList< FunctionDefinition >::Ptr m_functions;
         };
+
+        class FeatureDefinition final : public Definition
+        {
+          public:
+            using Ptr = std::shared_ptr< FeatureDefinition >;
+
+            FeatureDefinition( const Identifier::Ptr& identifier,
+                const Definitions::Ptr& definitions );
+
+            const Definitions::Ptr& definitions( void ) const;
+
+            void accept( Visitor& visitor ) override final;
+
+          private:
+            const Definitions::Ptr m_definitions;
+        };
+
+        class DeclarationDefinition final : public Definition
+        {
+          public:
+            using Ptr = std::shared_ptr< DeclarationDefinition >;
+
+            enum class Kind
+            {
+                DERIVED = 1,
+                RULE
+            };
+
+            DeclarationDefinition( const Identifier::Ptr& identifier,
+                const Types::Ptr& argumentTypes,
+                const Type::Ptr& returnType );
+
+            const Types::Ptr& argumentTypes( void ) const;
+
+            const Type::Ptr& returnType( void ) const;
+
+            void setKind( const Kind kind );
+
+            Kind kind( void ) const;
+
+            std::string kindName( void ) const;
+
+            void accept( Visitor& visitor ) override final;
+
+          private:
+            const Types::Ptr m_argumentTypes;
+            const Type::Ptr m_returnType;
+            Kind m_kind;
+        };
+
+        using DeclarationDefinitions = NodeList< DeclarationDefinition >;
     }
 }
 

diff --git a/src/ast/EmptyVisitor.cpp b/src/ast/EmptyVisitor.cpp
@@ -58,6 +58,14 @@ void EmptyVisitor::visit( StructureDefinition& )
 {
 }
 
+void EmptyVisitor::visit( FeatureDefinition& )
+{
+}
+
+void EmptyVisitor::visit( DeclarationDefinition& )
+{
+}
+
 void EmptyVisitor::visit( ValueAtom& )
 {
 }

diff --git a/src/ast/EmptyVisitor.h b/src/ast/EmptyVisitor.h
@@ -43,6 +43,8 @@ namespace libcasm_fe
             void visit( RuleDefinition& node ) override;
             void visit( EnumerationDefinition& node ) override;
             void visit( StructureDefinition& node ) override;
+            void visit( FeatureDefinition& node ) override;
+            void visit( DeclarationDefinition& node ) override;
 
             void visit( ValueAtom& node ) override;
             void visit( ReferenceAtom& node ) override;

diff --git a/src/ast/Node.cpp b/src/ast/Node.cpp
@@ -81,6 +81,14 @@ std::string Node::description( void ) const
         {
             return "structure";
         }
+        case ID::FEATURE_DEFINITION:
+        {
+            return "feature";
+        }
+        case ID::DECLARATION_DEFINITION:
+        {
+            return "declaration";
+        }
         case ID::VALUE_ATOM:
         {
             return "value";

diff --git a/src/ast/Node.h b/src/ast/Node.h
@@ -56,6 +56,8 @@ namespace libcasm_fe
                 RULE_DEFINITION,
                 ENUMERATION_DEFINITION,
                 STRUCTURE_DEFINITION,
+                FEATURE_DEFINITION,
+                DECLARATION_DEFINITION,
 
                 // expressions
                 VALUE_ATOM,

diff --git a/src/ast/RecursiveVisitor.cpp b/src/ast/RecursiveVisitor.cpp
@@ -84,6 +84,19 @@ void RecursiveVisitor::visit( StructureDefinition& node )
     node.functions()->accept( *this );
 }
 
+void RecursiveVisitor::visit( FeatureDefinition& node )
+{
+    node.identifier()->accept( *this );
+    node.definitions()->accept( *this );
+}
+
+void RecursiveVisitor::visit( DeclarationDefinition& node )
+{
+    node.identifier()->accept( *this );
+    node.argumentTypes()->accept( *this );
+    node.returnType()->accept( *this );
+}
+
 void RecursiveVisitor::visit( ValueAtom& node )
 {
 }

diff --git a/src/ast/RecursiveVisitor.h b/src/ast/RecursiveVisitor.h
@@ -43,6 +43,8 @@ namespace libcasm_fe
             void visit( RuleDefinition& node ) override;
             void visit( EnumerationDefinition& node ) override;
             void visit( StructureDefinition& node ) override;
+            void visit( FeatureDefinition& node ) override;
+            void visit( DeclarationDefinition& node ) override;
 
             void visit( ValueAtom& node ) override;
             void visit( ReferenceAtom& node ) override;

diff --git a/src/ast/Visitor.h b/src/ast/Visitor.h
@@ -38,6 +38,8 @@ namespace libcasm_fe
         class RuleDefinition;
         class EnumerationDefinition;
         class StructureDefinition;
+        class FeatureDefinition;
+        class DeclarationDefinition;
 
         class ValueAtom;
         class ReferenceAtom;
@@ -96,6 +98,8 @@ namespace libcasm_fe
             virtual void visit( RuleDefinition& node ) = 0;
             virtual void visit( EnumerationDefinition& node ) = 0;
             virtual void visit( StructureDefinition& node ) = 0;
+            virtual void visit( FeatureDefinition& node ) = 0;
+            virtual void visit( DeclarationDefinition& node ) = 0;
 
             virtual void visit( ValueAtom& node ) = 0;
             virtual void visit( ReferenceAtom& node ) = 0;

diff --git a/src/transform/AstDumpSourcePass.cpp b/src/transform/AstDumpSourcePass.cpp
@@ -131,6 +131,8 @@ class AstDumpSourceVisitor final : public Visitor
     void visit( RuleDefinition& node ) override;
     void visit( EnumerationDefinition& node ) override;
     void visit( StructureDefinition& node ) override;
+    void visit( FeatureDefinition& node ) override;
+    void visit( DeclarationDefinition& node ) override;
 
     void visit( ValueAtom& node ) override;
     void visit( ReferenceAtom& node ) override;
@@ -337,6 +339,38 @@ void AstDumpSourceVisitor::visit( StructureDefinition& node )
     m_stream << "}";
 }
 
+void AstDumpSourceVisitor::visit( FeatureDefinition& node )
+{
+    m_stream << "feature ";
+    node.identifier()->accept( *this );
+    m_stream << " =\n{";
+    for( auto& e : *node.definitions() )
+    {
+        m_stream << "\n    ";
+        e->accept( *this );
+    }
+    m_stream << "}";
+}
+
+void AstDumpSourceVisitor::visit( DeclarationDefinition& node )
+{
+    m_stream << " ";
+    node.identifier()->accept( *this );
+    m_stream << " : ";
+    bool firstArgType = true;
+    for( auto& t : *node.argumentTypes() )
+    {
+        if( not firstArgType )
+        {
+            m_stream << " * ";
+        }
+        t->accept( *this );
+        firstArgType = false;
+    }
+    m_stream << " -> ";
+    node.returnType()->accept( *this );
+}
+
 void AstDumpSourceVisitor::visit( ValueAtom& node )
 {
     m_stream << node.value()->name();