Changes in src/Parser/DeclarationNode.cc [45e753c:561354f]

File:

• src/Parser/DeclarationNode.cc (modified) (3 diffs)

src/Parser/DeclarationNode.cc

@@ -279 +279 @@
 } // DeclarationNode::newEnum
 
+DeclarationNode * DeclarationNode::newAdt( const string * name, DeclarationNode * constructors ) {
+        assert( name );
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->type = new TypeData( TypeData::Adt );
+        newnode->type->adt.name = name;
+        newnode->type->adt.data_constructors = constructors;
+        return newnode;
+} // DeclarationNode::newAdt
+
+
 DeclarationNode * DeclarationNode::newName( const string * name ) {
         DeclarationNode * newnode = new DeclarationNode;
@@ -305 +315 @@
         } // if
 } // DeclarationNode::newEnumValueGeneric
+
+DeclarationNode * DeclarationNode::newDataConstructor( const string * name ) {
+        DeclarationNode * newnode = newName(name);
+        return newnode;
+}
 
 DeclarationNode * DeclarationNode::newEnumInLine( const string name ) {
@@ -1083 +1098 @@
         }
         return nullptr;
+}
+
+std::vector<ast::ptr<ast::StructDecl>> buildDataConstructors( DeclarationNode * firstNode ) {
+        std::vector<ast::ptr<ast::StructDecl>> outputList;
+        std::back_insert_iterator<std::vector<ast::ptr<ast::StructDecl>>> out( outputList );
+        for ( const DeclarationNode * cur = firstNode; cur; cur = strict_next( cur ) ) {
+                // td->kind == TypeData::Symbolic
+                assert( cur->type->kind == TypeData::Symbolic );
+                const std::string * name = cur->name;
+                auto ctor = new ast::StructDecl( cur->location,
+                        std::string(*name),
+                        ast::AggregateDecl::Aggregate::Struct
+                );
+                ctor->set_body(true);
+                TypeData * td = cur->type;
+                TypeData::Symbolic_t st = td->symbolic;
+                DeclarationNode * params = st.params;
+                
+                if ( params ) {
+                        buildList( params, ctor->members );
+                }
+
+                for ( std::size_t i = 0; i < ctor->members.size(); ++i ) {
+                        assert(ctor->members[i]->name == "");
+                        ast::Decl * member = ctor->members[i].get_and_mutate();
+                        member->name = "field_" + std::to_string(i);
+                }
+                *out++ = ctor;          
+        }
+        return outputList;
+}
+
+ast::UnionDecl * buildDataUnion( const CodeLocation & loc, const std::vector<ast::ptr<ast::StructDecl>> & typeList ) {
+        ast::UnionDecl * out = new ast::UnionDecl( loc, "temp_data_union" );
+        // size_t index = 0;
+        if ( typeList.size() > 0 ) out->set_body( true );
+        size_t i = 0;
+        for (const ast::ptr<ast::StructDecl> structDecl : typeList ) {
+                ast::StructInstType * inst = new ast::StructInstType(structDecl);
+                ast::ObjectDecl * instObj = new ast::ObjectDecl(
+                        structDecl->location,
+                        "option_" + std::to_string(i),
+                        inst
+                );
+                i++;
+                out->members.push_back( instObj );
+
+        }
+        return out;
+}
+
+ast::EnumDecl * buildTag( const CodeLocation & loc, std::vector<ast::ptr<ast::StructDecl>> & typeList ) {
+        ast::EnumDecl * out = new ast::EnumDecl( loc, "temp_data_tag" );
+        if ( typeList.size() > 0 ) out->set_body( true );
+        for ( const ast::ptr<ast::StructDecl> structDecl : typeList ) {
+                ast::EnumInstType * inst = new ast::EnumInstType( out );
+                assert( inst->base != nullptr );
+                ast::ObjectDecl * instObj = new ast::ObjectDecl(
+                        structDecl->location,
+                        structDecl->name,
+                        inst
+                );
+                out->members.push_back( instObj );
+        }
+        return out;
+}
+
+ast::StructDecl * buildTaggedUnions( const TypeData * data, const ast::EnumDecl * tags, const ast::UnionDecl * data_union ) {
+        assert( tags->members.size() == data_union->members.size() );
+        ast::StructDecl * out = new ast::StructDecl( data->location, *(data->adt.name) );
+        out->kind = ast::AggregateDecl::Adt;
+
+        out->set_body( true );
+
+        ast::EnumInstType * tag = new ast::EnumInstType( tags );
+        ast::ObjectDecl * tag_obj = new ast::ObjectDecl(
+                data->location,
+                "tag",
+                tag
+        );
+        ast::UnionInstType * value = new ast::UnionInstType( data_union );
+        ast::ObjectDecl * value_obj = new ast::ObjectDecl(
+                data->location,
+                "value",
+                value
+        );
+
+        out->members.push_back( value_obj );
+        out->members.push_back( tag_obj );
+        return out;
 }