Changeset 374cb117

Timestamp:

Apr 19, 2022, 3:53:53 PM (20 months ago)

Author:

JiadaL <j82liang@…>

Branches:

ADT, ast-experimental, master, pthread-emulation, qualifiedEnum

Children:

2686bc7

Parents:

75cd27b

Message:

Replace the interface for EnumDecl? node construction to support generic enum types

Location:

src

Files:

• AST/Convert.cpp (modified) (1 diff)
• Parser/DeclarationNode.cc (modified) (2 diffs)
• Parser/InitializerNode.cc (modified) (1 diff)
• Parser/ParseNode.h (modified) (1 diff)
• Parser/parser.yy (modified) (6 diffs)
• SynTree/Visitor.h (modified) (2 diffs)

src/AST/Convert.cpp

@@ -2775 +2775 @@
         }
 
-        virtual void visit( const EnumInstType * old ) override final { // Here is visiting the EnumInst Decl not the usage.
+        virtual void visit( const EnumInstType * old ) override final {
                 ast::EnumInstType * ty; 
                 if ( old->baseEnum ) {
-                        ty = new ast::EnumInstType{ // Probably here: missing the specification of the base
+                        ty = new ast::EnumInstType{
                                 GET_ACCEPT_1( baseEnum, EnumDecl ),
                                 cv( old ),

src/Parser/DeclarationNode.cc

@@ -253 +253 @@
 } // DeclarationNode::newAggregate
 
-DeclarationNode * DeclarationNode::newEnum( const string * name, DeclarationNode * constants, bool body, bool typed) {
+DeclarationNode * DeclarationNode::newEnum( const string * name, DeclarationNode * constants, bool body) {
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Enum );
@@ -272 +272 @@
 } // DeclarationNode::newName
 
-DeclarationNode * DeclarationNode::newEnumConstant( const string * name, ExpressionNode * constant ) { // Marker
+DeclarationNode * DeclarationNode::newEnumConstant( const string * name, ExpressionNode * constant ) {
         DeclarationNode * newnode = newName( name );
         newnode->enumeratorValue.reset( constant );
         return newnode;
 } // DeclarationNode::newEnumConstant
+
+DeclarationNode * DeclarationNode::newEnumValueGeneric( const string * name, InitializerNode * init ) {
+        if ( init ) { // list init {} or a singleInit
+                if ( init->get_expression() ) { // singleInit
+                        return newEnumConstant( name, init->get_expression() );
+                } else { // TODO: listInit
+                        DeclarationNode * newnode = newName( name );
+                        newnode->initializer = init;
+                        return newnode;
+                } // if
+        } else {
+                return newName( name ); // Not explicitly inited enum value;
+        } // if
+} // DeclarationNode::newEnumGeneric
 
 DeclarationNode * DeclarationNode::newFromTypedef( const string * name ) {

src/Parser/InitializerNode.cc

@@ -101 +101 @@
         } else {
                 if ( get_expression() ) {
+                        assertf( get_expression()->expr, "The expression of initializer must have value" );
                         return new SingleInit( maybeBuild< Expression >( get_expression() ), maybeConstructed );
                 } // if

src/Parser/ParseNode.h

@@ -235 +235 @@
         static DeclarationNode * newFunction( const std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body );
         static DeclarationNode * newAggregate( AggregateDecl::Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
-        static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body, bool typed );
+        static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body );
         static DeclarationNode * newEnumConstant( const std::string * name, ExpressionNode * constant );
+        static DeclarationNode * newEnumValueGeneric( const std::string * name, InitializerNode * init );
         static DeclarationNode * newName( const std::string * );
         static DeclarationNode * newFromTypeGen( const std::string *, ExpressionNode * params );

src/Parser/parser.yy

@@ -380 +380 @@
 
 %type<decl> enumerator_list enum_type enum_type_nobody
-%type<en> enumerator_value_opt
+%type<in> enumerator_value_opt
 
 %type<decl> external_definition external_definition_list external_definition_list_opt
@@ -2305 +2305 @@
 enum_type: // static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body, bool typed );                                                                                         // enum
         ENUM attribute_list_opt '{' enumerator_list comma_opt '}'
-                { $$ = DeclarationNode::newEnum( nullptr, $4, true, false )->addQualifiers( $2 ); }
+                { $$ = DeclarationNode::newEnum( nullptr, $4, true )->addQualifiers( $2 ); }
         | ENUM attribute_list_opt identifier
                 { typedefTable.makeTypedef( *$3 ); }
           '{' enumerator_list comma_opt '}'
-                { $$ = DeclarationNode::newEnum( $3, $6, true, false )->addQualifiers( $2 ); }
+                { $$ = DeclarationNode::newEnum( $3, $6, true )->addQualifiers( $2 ); }
         | ENUM attribute_list_opt typedef_name                          // unqualified type name
           '{' enumerator_list comma_opt '}'
-                { $$ = DeclarationNode::newEnum( $3->name, $5, true, false )->addQualifiers( $2 ); }
+                { $$ = DeclarationNode::newEnum( $3->name, $5, true )->addQualifiers( $2 ); }
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt '{' enumerator_list comma_opt '}'
                 {
                         if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 ) 
                         { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
-                        // SemanticError( yylloc, "Typed enumeration is currently unimplemented." ); $$ = nullptr;
-
-                        $$ = DeclarationNode::newEnum( nullptr, $7, true, true ) ->addQualifiers( $5 )  -> addEnumBase( $3 );
-                        // $$ = DeclarationNode::newEnum( nullptr, $7, true, true ) ->addQualifiers( $5 );
+
+                        $$ = DeclarationNode::newEnum( nullptr, $7, true ) ->addQualifiers( $5 )  -> addEnumBase( $3 );
                 }
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt // Question: why attributes/qualifier after identifier
@@ -2329 +2327 @@
           '{' enumerator_list comma_opt '}'
                 {
-                        $$ = DeclarationNode::newEnum( $6, $10, true, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 ) -> addEnumBase( $3 );
-                        // $$ = DeclarationNode::newEnum( $6, $10, true, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 );
+                        $$ = DeclarationNode::newEnum( $6, $10, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 ) -> addEnumBase( $3 );
                 }
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt typedef_name attribute_list_opt '{' enumerator_list comma_opt '}'
@@ -2336 +2333 @@
                         if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
                         typedefTable.makeTypedef( *$6->name );
-                        $$ = DeclarationNode::newEnum( $6->name, $9, true, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 ) -> addEnumBase( $3 );
-                        // $$ = DeclarationNode::newEnum( $6->name, $9, true, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 );
+                        $$ = DeclarationNode::newEnum( $6->name, $9, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 ) -> addEnumBase( $3 );
                 }
         | enum_type_nobody
@@ -2344 +2340 @@
 enum_type_nobody:                                                                               // enum - {...}
         ENUM attribute_list_opt identifier
-                { typedefTable.makeTypedef( *$3 ); $$ = DeclarationNode::newEnum( $3, 0, false, false )->addQualifiers( $2 ); }
+                { typedefTable.makeTypedef( *$3 ); $$ = DeclarationNode::newEnum( $3, 0, false )->addQualifiers( $2 ); }
         | ENUM attribute_list_opt type_name                                     // qualified type name
-                { typedefTable.makeTypedef( *$3->type->symbolic.name ); $$ = DeclarationNode::newEnum( $3->type->symbolic.name, 0, false, false )->addQualifiers( $2 ); }
+                { typedefTable.makeTypedef( *$3->type->symbolic.name ); $$ = DeclarationNode::newEnum( $3->type->symbolic.name, 0, false )->addQualifiers( $2 ); }
         ;
 
 enumerator_list:
         identifier_or_type_name enumerator_value_opt
-                { $$ = DeclarationNode::newEnumConstant( $1, $2 ); }
+                { $$ = DeclarationNode::newEnumValueGeneric( $1, $2 ); }
         | INLINE type_name
-                { $$ = DeclarationNode::newEnumConstant( new string("inline"), nullptr ); }
+                { $$ = DeclarationNode::newEnumValueGeneric( new string("inline"), nullptr ); }
         | enumerator_list ',' identifier_or_type_name enumerator_value_opt
-                { $$ = $1->appendList( DeclarationNode::newEnumConstant( $3, $4 ) ); }
+                { $$ = $1->appendList( DeclarationNode::newEnumValueGeneric( $3, $4 ) ); }
         | enumerator_list ',' INLINE type_name enumerator_value_opt
-                { $$ = $1->appendList( DeclarationNode::newEnumConstant( new string("inline"), nullptr ) ); }
+                { $$ = $1->appendList( DeclarationNode::newEnumValueGeneric( new string("inline"), nullptr ) ); }
         ;
 
@@ -2366 +2362 @@
         //      { $$ = $2; }
         | simple_assignment_operator initializer
-                { $$ = $2->get_expression(); }                                  // FIX ME: enum only deals with constant_expression
+                { $$ = $1 == OperKinds::Assign ? $2 : $2->set_maybeConstructed( false ); }
         ;
 

src/SynTree/Visitor.h

@@ -35 +35 @@
         virtual void visit( UnionDecl * node ) { visit( const_cast<const UnionDecl *>(node) ); }
         virtual void visit( const UnionDecl * aggregateDecl ) = 0;
-        virtual void visit( EnumDecl * node ) { visit( const_cast<const EnumDecl *>(node) ); } // Marker 1
+        virtual void visit( EnumDecl * node ) { visit( const_cast<const EnumDecl *>(node) ); }
         virtual void visit( const EnumDecl * aggregateDecl ) = 0;
         virtual void visit( TraitDecl * node ) { visit( const_cast<const TraitDecl *>(node) ); }
@@ -190 +190 @@
         virtual void visit( UnionInstType * node ) { visit( const_cast<const UnionInstType *>(node) ); }
         virtual void visit( const UnionInstType * aggregateUseType ) = 0;
-        virtual void visit( EnumInstType * node ) { visit( const_cast<const EnumInstType *>(node) ); } // Marker 2
+        virtual void visit( EnumInstType * node ) { visit( const_cast<const EnumInstType *>(node) ); }
         virtual void visit( const EnumInstType * aggregateUseType ) = 0;
         virtual void visit( TraitInstType * node ) { visit( const_cast<const TraitInstType *>(node) ); }