Changeset b0d9ff7 for src/Parser

Timestamp:

Sep 1, 2022, 1:27:52 PM (3 years ago)

Author:

JiadaL <j82liang@…>

Branches:

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

Children:

12df6fe

Parents:

def751f

Message:

Fix up the QualifiedNameExpr?. It should now work on both old AST and new AST. There are some known bugs to fix so make all-tests will fail.

Location:

src/Parser

Files:

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

src/Parser/DeclarationNode.cc ¶

@@ -253 +253 @@
 } // DeclarationNode::newAggregate
 
-DeclarationNode * DeclarationNode::newEnum( const string * name, DeclarationNode * constants, bool body, DeclarationNode * base) {
+DeclarationNode * DeclarationNode::newEnum( const string * name, DeclarationNode * constants, bool body, bool typed, 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;
+        newnode->type->enumeration.typed = typed;
         if ( base && base->type)  {
                 newnode->type->base = base->type;       
         } // if
 
-        // Check: if base has TypeData
         return newnode;
 } // DeclarationNode::newEnum
@@ -284 +284 @@
 
 DeclarationNode * DeclarationNode::newEnumValueGeneric( const string * name, InitializerNode * init ) {
-        if ( init ) { // list init {} or a singleInit
-                if ( init->get_expression() ) { // singleInit
+        if ( init ) {
+                if ( init->get_expression() ) {
                         return newEnumConstant( name, init->get_expression() );
-                } else { // TODO: listInit
+                } else {
                         DeclarationNode * newnode = newName( name );
                         newnode->initializer = init;
@@ -293 +293 @@
                 } // if
         } else {
-                return newName( name ); // Not explicitly inited enum value;
+                return newName( name );
         } // if
 } // DeclarationNode::newEnumValueGeneric

src/Parser/ExpressionNode.cc ¶

@@ -510 +510 @@
 
 QualifiedNameExpr * build_qualified_expr( const DeclarationNode * decl_node, const NameExpr * name ) {
-        Type * targetType = maybeMoveBuildType( decl_node );
-        return new QualifiedNameExpr( targetType, name->name );
-        return nullptr;
+        Declaration * newDecl = maybeBuild< Declaration >(decl_node);
+        if ( DeclarationWithType * newDeclWithType = dynamic_cast< DeclarationWithType * >( newDecl ) ) {
+                const Type * t = newDeclWithType->get_type();
+                if ( t ) {
+                        if ( const TypeInstType * typeInst = dynamic_cast<const TypeInstType *>( t ) ) {
+                                newDecl= new EnumDecl( typeInst->name );
+                        }
+                }
+        }
+        auto ret =  new QualifiedNameExpr( newDecl, name->name );
+        if ( auto e = dynamic_cast<EnumDecl*>(newDecl) ) {
+                auto enumInst = new EnumInstType( Type::Qualifiers(), e );
+                auto obj = new ObjectDecl( name->name, Type::StorageClasses(), LinkageSpec::Cforall, nullptr, enumInst, nullptr );
+                ret->set_var( obj );
+        }
+        return ret;
+}
+
+QualifiedNameExpr * build_qualified_expr( const EnumDecl * decl_node, const NameExpr * name ) {
+        EnumDecl * newDecl = const_cast< EnumDecl * >( decl_node );
+        return new QualifiedNameExpr( newDecl, name->name );
 }
 

src/Parser/ParseNode.h ¶

@@ -184 +184 @@
 NameExpr * build_varref( const std::string * name );
 QualifiedNameExpr * build_qualified_expr( const DeclarationNode * decl_node, const NameExpr * name );
+QualifiedNameExpr * build_qualified_expr( const EnumDecl * decl, const NameExpr * name );
 DimensionExpr * build_dimensionref( const std::string * name );
 
@@ -236 +237 @@
         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, DeclarationNode * base = nullptr );
+        static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body, bool typed, 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 ¶

@@ -548 +548 @@
                 return buildAggInst( td );
           case TypeData::EnumConstant:
-                // the name gets filled in later -- by SymTab::Validate
                 return new EnumInstType( buildQualifiers( td ), "" );
           case TypeData::SymbolicInst:
@@ -923 +922 @@
         assert( td->kind == TypeData::Enum );
         Type * baseType = td->base ? typebuild(td->base) : nullptr;
-        EnumDecl * ret = new EnumDecl( *td->enumeration.name, attributes, linkage, baseType );
+        EnumDecl * ret = new EnumDecl( *td->enumeration.name, attributes, td->enumeration.typed, linkage, baseType );
         buildList( td->enumeration.constants, ret->get_members() );
         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 ) {
-                if ( cur->has_enumeratorValue() ) {
+                if ( ret->isTyped && cur->has_enumeratorValue() ) {
+                        SemanticError( td->location, "Enumerator of enum(void) cannot have an explicit initializer value." );
+                } else if ( cur->has_enumeratorValue() ) {
                         ObjectDecl * member = dynamic_cast< ObjectDecl * >(* members);
                         member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ) ) );
                 } 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." );
+                                SemanticError( td->location, "Enumerators of an non-integer typed enum must be explicitly initialized." );
                         }
                 }

src/Parser/TypeData.h ¶

@@ -59 +59 @@
                 bool body;
                 bool anon;
+                bool typed;
         };
 

src/Parser/parser.yy ¶

@@ -614 +614 @@
                 { $$ = new ExpressionNode( new StmtExpr( dynamic_cast<CompoundStmt *>(maybeMoveBuild<Statement>($2) ) ) ); }
         | type_name '.' identifier                                                      // CFA, nested type
-                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
+                { $$ = new ExpressionNode( build_qualified_expr( $1, build_varref( $3 ) ) ); }
         | type_name '.' '[' field_name_list ']'                         // CFA, nested type / tuple field selector
                 { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
@@ -2387 +2387 @@
 enum_type:
         ENUM attribute_list_opt '{' enumerator_list comma_opt '}'
-                { $$ = DeclarationNode::newEnum( nullptr, $4, true )->addQualifiers( $2 ); }
+                { $$ = DeclarationNode::newEnum( nullptr, $4, true, false )->addQualifiers( $2 ); }
         | ENUM attribute_list_opt identifier
                 { typedefTable.makeTypedef( *$3 ); }
           '{' enumerator_list comma_opt '}'
-                { $$ = DeclarationNode::newEnum( $3, $6, true )->addQualifiers( $2 ); }
+                { $$ = DeclarationNode::newEnum( $3, $6, true, false )->addQualifiers( $2 ); }
         | ENUM attribute_list_opt typedef_name                          // unqualified type name
           '{' enumerator_list comma_opt '}'
-                { $$ = DeclarationNode::newEnum( $3->name, $5, true )->addQualifiers( $2 ); }
+                { $$ = DeclarationNode::newEnum( $3->name, $5, true, false )->addQualifiers( $2 ); }
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt '{' enumerator_list comma_opt '}'
                 {
@@ -2400 +2400 @@
                         { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
 
-                        $$ = DeclarationNode::newEnum( nullptr, $7, true, $3 )->addQualifiers( $5 );
+                        $$ = DeclarationNode::newEnum( nullptr, $7, true, true, $3 )->addQualifiers( $5 );
+                }
+        | ENUM '(' ')' attribute_list_opt '{' enumerator_list comma_opt '}'
+                {
+                        $$ = DeclarationNode::newEnum( nullptr, $6, true, true )->addQualifiers( $4 );
                 }
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt
@@ -2409 +2413 @@
           '{' enumerator_list comma_opt '}'
                 {
-                        $$ = DeclarationNode::newEnum( $6, $10, true, $3 )->addQualifiers( $5 )->addQualifiers( $7 );
-                }
+                        $$ = DeclarationNode::newEnum( $6, $10, true, true, $3 )->addQualifiers( $5 )->addQualifiers( $7 );
+                }
+        | ENUM '(' ')' attribute_list_opt identifier attribute_list_opt
+          '{' enumerator_list comma_opt '}'
+                {
+                        $$ = DeclarationNode::newEnum( $5, $8, true, true, nullptr )->addQualifiers( $4 )->addQualifiers( $6 );
+                }       
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt typedef_name 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." ); }
-                        typedefTable.makeTypedef( *$6->name );
-                        $$ = DeclarationNode::newEnum( $6->name, $9, true, $3 )->addQualifiers( $5 )->addQualifiers( $7 );
+                        $$ = DeclarationNode::newEnum( $6->name, $9, true, true, $3 )->addQualifiers( $5 )->addQualifiers( $7 );
+                }
+        | ENUM '(' ')' attribute_list_opt typedef_name attribute_list_opt '{' enumerator_list comma_opt '}'
+                {
+                        $$ = DeclarationNode::newEnum( $5->name, $8, true, true, nullptr )->addQualifiers( $4 )->addQualifiers( $6 );
                 }
         | enum_type_nobody
@@ -2422 +2433 @@
 enum_type_nobody:                                                                               // enum - {...}
         ENUM attribute_list_opt identifier
-                { 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 )->addQualifiers( $2 ); }
+                { typedefTable.makeTypedef( *$3 ); $$ = DeclarationNode::newEnum( $3, 0, false, false )->addQualifiers( $2 ); }
+        | ENUM attribute_list_opt type_name     
+                { typedefTable.makeTypedef( *$3->type->symbolic.name ); $$ = DeclarationNode::newEnum( $3->type->symbolic.name, 0, false, false )->addQualifiers( $2 ); }
         ;