Changeset 9e7236f4 for src/Parser

Timestamp:

May 2, 2022, 3:18:32 AM (2 years ago)

Author:

JiadaL <j82liang@…>

Branches:

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

Children:

24ceace

Parents:

2686bc7

Message:

Resolution of struct enum. The codegen of struct enum will be in the next commit

Location:

src/Parser

Files:

• DeclarationNode.cc (modified) (3 diffs)
• ParseNode.h (modified) (1 diff)
• TypeData.cc (modified) (2 diffs)
• parser.yy (modified) (4 diffs)

src/Parser/DeclarationNode.cc

@@ -253 +253 @@
 } // DeclarationNode::newAggregate
 
-DeclarationNode * DeclarationNode::newEnum( const string * name, DeclarationNode * constants, bool body) {
+DeclarationNode * DeclarationNode::newEnum( const string * name, DeclarationNode * constants, bool body, DeclarationNode * base) {
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Enum );
@@ -260 +260 @@
         newnode->type->enumeration.body = body;
         newnode->type->enumeration.anon = name == nullptr;
+        if ( base && base->type)  {
+                newnode->type->base = base->type;       
+        } // if
+
+        // Check: if base has TypeData
         return newnode;
 } // DeclarationNode::newEnum
@@ -290 +295 @@
                 return newName( name ); // Not explicitly inited enum value;
         } // if
-} // DeclarationNode::newEnumGeneric
+} // DeclarationNode::newEnumValueGeneric
 
 DeclarationNode * DeclarationNode::newFromTypedef( const string * name ) {

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 );
+        static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body, DeclarationNode * base = nullptr );
         static DeclarationNode * newEnumConstant( const std::string * name, ExpressionNode * constant );
         static DeclarationNode * newEnumValueGeneric( const std::string * name, InitializerNode * init );

src/Parser/TypeData.cc

@@ -388 +388 @@
                 if ( enumeration.body ) {
                         os << string( indent + 2, ' ' ) << " with body" << endl;
+                } // if
+                if ( base ) {
+                        os << "for ";
+                        base->print( os, indent + 2 );
                 } // if
                 break;
@@ -926 +930 @@
                         ObjectDecl * member = dynamic_cast< ObjectDecl * >(* members);
                         member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ) ) );
-                } else {
+                } else if ( !cur->initializer ) {
                         if ( baseType && (!dynamic_cast<BasicType *>(baseType) || !dynamic_cast<BasicType *>(baseType)->isWholeNumber())) {
                                 SemanticError( td->location, "A non whole number enum value decl must be explicitly initialized." );
                         }
-                } // if
+                }
+                // else cur is a List Initializer and has been set as init in buildList()
+                // if
         } // for
-        ret->set_body( td->enumeration.body ); // Boolean; if it has body
+        ret->set_body( td->enumeration.body );
         return ret;
 } // buildEnum

src/Parser/parser.yy

@@ -2303 +2303 @@
         ;
 
-enum_type: // static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body, bool typed );                                                                                         // enum
+enum_type:
         ENUM attribute_list_opt '{' enumerator_list comma_opt '}'
                 { $$ = DeclarationNode::newEnum( nullptr, $4, true )->addQualifiers( $2 ); }
@@ -2318 +2318 @@
                         { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
 
-                        $$ = 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
+                        $$ = DeclarationNode::newEnum( nullptr, $7, true, $3 ) ->addQualifiers( $5 );
+                }
+        | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_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." ); }
@@ -2327 +2327 @@
           '{' enumerator_list comma_opt '}'
                 {
-                        $$ = DeclarationNode::newEnum( $6, $10, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 ) -> addEnumBase( $3 );
+                        $$ = DeclarationNode::newEnum( $6, $10, true, $3 ) -> addQualifiers( $5 ) -> addQualifiers( $7 );
                 }
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt typedef_name attribute_list_opt '{' enumerator_list comma_opt '}'
@@ -2333 +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 ) -> addQualifiers( $5 ) -> addQualifiers( $7 ) -> addEnumBase( $3 );
+                        $$ = DeclarationNode::newEnum( $6->name, $9, true, $3 ) -> addQualifiers( $5 ) -> addQualifiers( $7 );
                 }
         | enum_type_nobody