Changeset f135b50 for src/Parser

Timestamp:

Feb 28, 2022, 3:41:44 AM (2 years ago)

Author:

JiadaL <j82liang@…>

Branches:

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

Children:

786c438

Parents:

a8ef59e

Message:

The compiler is now trying to pass the value of enum const to code gen; but it won't work cause we must be able to evaluate the const_expr in compiler time. It is not currently passed as a Expression but won't be able to evaluate at compile time

Location:

src/Parser

Files:

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

src/Parser/DeclarationNode.cc

@@ -78 +78 @@
         delete variable.initializer;
 
-        delete type;
+//      delete type;
         delete bitfieldWidth;
 
@@ -253 +253 @@
 } // DeclarationNode::newAggregate
 
-DeclarationNode * DeclarationNode::newEnum( const string * name, DeclarationNode * constants, bool body, bool ) {
+DeclarationNode * DeclarationNode::newEnum( const string * name, DeclarationNode * constants, bool body, bool typed) {
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Enum );
@@ -272 +272 @@
 } // DeclarationNode::newName
 
-DeclarationNode * DeclarationNode::newEnumConstant( const string * name, ExpressionNode * constant ) {
+DeclarationNode * DeclarationNode::newEnumConstant( const string * name, ExpressionNode * constant ) { // Marker
         DeclarationNode * newnode = newName( name );
         newnode->enumeratorValue.reset( constant );
@@ -667 +667 @@
 }
 
+DeclarationNode * DeclarationNode::addEnumBase( DeclarationNode * o ) {
+        if ( o && o -> type)  {
+                type->base= o->type;
+        }
+        delete o;
+        return this;
+}
+
 DeclarationNode * DeclarationNode::addTypedef() {
         TypeData * newtype = new TypeData( TypeData::Symbolic );

src/Parser/ParseNode.h

@@ -265 +265 @@
         DeclarationNode * addType( DeclarationNode * );
         DeclarationNode * addTypedef();
+        DeclarationNode * addEnumBase( DeclarationNode * );
         DeclarationNode * addAssertions( DeclarationNode * );
         DeclarationNode * addName( std::string * );

src/Parser/StatementNode.cc

@@ -366 +366 @@
 } // maybe_build_compound
 
+// Question
 Statement * build_asm( bool voltile, Expression * instruction, ExpressionNode * output, ExpressionNode * input, ExpressionNode * clobber, LabelNode * gotolabels ) {
         list< Expression * > out, in;

src/Parser/TypeData.cc

@@ -918 +918 @@
 EnumDecl * buildEnum( const TypeData * td, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
         assert( td->kind == TypeData::Enum );
-        EnumDecl * ret = new EnumDecl( *td->enumeration.name, attributes, linkage );
-        buildList( td->enumeration.constants, ret->get_members() );
+        Type* baseType = td->base ? typebuild(td->base) : nullptr;
+        EnumDecl * ret = new EnumDecl( *td->enumeration.name, attributes, linkage, baseType );
+        buildList( td->enumeration.constants, ret->get_members() ); // enumConstant is both a node and a list
         list< Declaration * >::iterator members = ret->get_members().begin();
-        for ( const DeclarationNode * cur = td->enumeration. constants; cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) {
+        for ( const DeclarationNode * cur = td->enumeration.constants; cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) {
                 if ( cur->has_enumeratorValue() ) {
                         ObjectDecl * member = dynamic_cast< ObjectDecl * >(* members);
@@ -927 +928 @@
                 } // if
         } // for
-        ret->set_body( td->enumeration.body );
+        ret->set_body( td->enumeration.body ); // Boolean; if it has body
         return ret;
 } // buildEnum

src/Parser/TypeData.h

@@ -132 +132 @@
                                                  Initializer * init = nullptr, std::list< class Attribute * > attributes = std::list< class Attribute * >() );
 FunctionType * buildFunction( const TypeData * );
+Declaration * addEnumBase( Declaration *, const TypeData * );
 void buildKRFunction( const TypeData::Function_t & function );
 

src/Parser/parser.yy

@@ -2292 +2292 @@
                         { 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 );
+
+                        $$ = DeclarationNode::newEnum( nullptr, $7, true, true ) ->addQualifiers( $5 )  -> addEnumBase( $3 );
+                        // $$ = DeclarationNode::newEnum( nullptr, $7, true, true ) ->addQualifiers( $5 );
                 }
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt // Question: why attributes/qualifier after identifier
@@ -2301 +2303 @@
           '{' enumerator_list comma_opt '}'
                 {
-                        $$ = DeclarationNode::newEnum( $6, $10, true, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 );
+                        $$ = DeclarationNode::newEnum( $6, $10, true, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 ) -> addEnumBase( $3 );
+                        // $$ = DeclarationNode::newEnum( $6, $10, true, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 );
                 }
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt typedef_name attribute_list_opt '{' enumerator_list comma_opt '}'
@@ -2307 +2310 @@
                         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 );
+                        $$ = DeclarationNode::newEnum( $6->name, $9, true, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 ) -> addEnumBase( $3 );
+                        // $$ = DeclarationNode::newEnum( $6->name, $9, true, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 );
                 }
         | enum_type_nobody