Changeset 92355883 for src

Timestamp:

Aug 31, 2023, 5:51:00 PM (16 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

2a301ff

Parents:

c84dd61

Message:

Array can use enum instance with explicit initializer as designator. More general case will be covered in later commit

Location:

src

Files:

• Parser/parser.yy (modified) (1 diff)
• ResolvExpr/CurrentObject.cc (modified) (2 diffs)
• ResolvExpr/ResolveTypeof.cc (modified) (9 diffs)
• ResolvExpr/ResolveTypeof.h (modified) (1 diff)
• ResolvExpr/Resolver.cc (modified) (1 diff)

src/Parser/parser.yy

@@ -2696 +2696 @@
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt
                 {
-                        if ( $3->storageClasses.any() || $3->type->qualifiers.val != 0 ) {
+                        if ( $3 && ($3->storageClasses.any() || $3->type->qualifiers.val != 0 )) {
                                 SemanticError( yylloc, "syntax error, storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." );
                         }

src/ResolvExpr/CurrentObject.cc

@@ -1045 +1045 @@
                         PRINT( std::cerr << "____untyped: " << expr << std::endl; )
                         auto dit = desigAlts.begin();
-                        if ( auto nexpr = dynamic_cast< const NameExpr * >( expr ) ) {
-                                for ( const Type * t : curTypes ) {
-                                        assert( dit != desigAlts.end() );
-
-                                        DesignatorChain & d = *dit;
+
+                        for ( const Type * t : curTypes ) {
+                                assert( dit != desigAlts.end() );
+                                DesignatorChain & d = *dit;
+                                if ( auto nexpr = dynamic_cast< const NameExpr *>( expr ) ) {
                                         PRINT( std::cerr << "____actual: " << t << std::endl; )
                                         if ( auto refType = dynamic_cast< const BaseInstType * >( t ) ) {
@@ -1062 +1062 @@
                                                         }
                                                 }
+                                        } else if ( auto at = dynamic_cast< const ArrayType * >( t ) ) {
+                                                auto nexpr = dynamic_cast< const NameExpr *>( expr );
+                                                auto res = eval( nexpr ); 
+                                                for ( const Decl * mem : refType->lookup( nexpr->name ) ) {
+                                                        if ( auto field = dynamic_cast< const ObjectDecl * >( mem ) ) {
+                                                                DesignatorChain d2 = d;
+                                                                d2.emplace_back( new VariableExpr{ expr->location, field } );
+                                                                newDesigAlts.emplace_back( std::move( d2 ) );
+                                                                // newTypes.emplace_back( field->type );
+                                                                newTypes.emplace_back( at->base );
+                                                        }
+                                                }
+
+                                                // d.emplace_back( expr );
+                                                // newDesigAlts.emplace_back( d );
+                                                // newTypes.emplace_back( at->base );
                                         }
 
                                         ++dit;
-                                }
-                        } else {
-                                for ( const Type * t : curTypes ) {
-                                        assert( dit != desigAlts.end() );
-
-                                        DesignatorChain & d = *dit;
+                                } else {
                                         if ( auto at = dynamic_cast< const ArrayType * >( t ) ) {
                                                 PRINT( std::cerr << "____alt: " << at->get_base() << std::endl; )

src/ResolvExpr/ResolveTypeof.cc

@@ -15 +15 @@
 
 #include "ResolveTypeof.h"
-#include "RenameVars.h"
-
-#include <cassert>               // for assert
+
+#include <cassert>  // for assert
 
 #include "AST/CVQualifiers.hpp"
@@ -25 +24 @@
 #include "AST/Type.hpp"
 #include "AST/TypeEnvironment.hpp"
-#include "Common/PassVisitor.h"  // for PassVisitor
-#include "Common/utility.h"      // for copy
-#include "Resolver.h"            // for resolveInVoidContext
+#include "Common/PassVisitor.h"   // for PassVisitor
+#include "Common/utility.h"       // for copy
+#include "InitTweak/InitTweak.h"  // for isConstExpr
+#include "RenameVars.h"
+#include "Resolver.h"  // for resolveInVoidContext
+#include "SymTab/Mangler.h"
 #include "SynTree/Expression.h"  // for Expression
 #include "SynTree/Mutator.h"     // for Mutator
 #include "SynTree/Type.h"        // for TypeofType, Type
-#include "SymTab/Mangler.h"
-#include "InitTweak/InitTweak.h" // for isConstExpr
 
 namespace SymTab {
@@ -39 +39 @@
 
 namespace ResolvExpr {
-        namespace {
+namespace {
 #if 0
                 void
@@ -52 +52 @@
         }
 
-        class ResolveTypeof_old : public WithShortCircuiting {
-          public:
+class ResolveTypeof_old : public WithShortCircuiting {
+   public:
                 ResolveTypeof_old( const SymTab::Indexer &indexer ) : indexer( indexer ) {}
                 void premutate( TypeofType *typeofType );
                 Type * postmutate( TypeofType *typeofType );
 
-          private:
-                const SymTab::Indexer &indexer;
-        };
+   private:
+    const SymTab::Indexer &indexer;
+};
 
         Type * resolveTypeof( Type *type, const SymTab::Indexer &indexer ) {
@@ -71 +71 @@
         }
 
-        Type * ResolveTypeof_old::postmutate( TypeofType *typeofType ) {
+    Type * ResolveTypeof_old::postmutate( TypeofType *typeofType ) {
 #if 0
                 std::cerr << "resolving typeof: ";
@@ -77 +77 @@
                 std::cerr << std::endl;
 #endif
-                // pass on null expression
+    // pass on null expression
                 if ( ! typeofType->expr ) return typeofType;
 
-                bool isBasetypeof = typeofType->is_basetypeof;
-                auto oldQuals = typeofType->get_qualifiers().val;
-
-                Type* newType;
+    bool isBasetypeof = typeofType->is_basetypeof;
+    auto oldQuals = typeofType->get_qualifiers().val;
+
+    Type* newType;
                 if ( TypeExpr* tyExpr = dynamic_cast<TypeExpr*>(typeofType->expr) ) {
-                        // typeof wrapping type
-                        newType = tyExpr->type;
-                        tyExpr->type = nullptr;
-                        delete tyExpr;
-                } else {
-                        // typeof wrapping expression
+        // typeof wrapping type
+        newType = tyExpr->type;
+        tyExpr->type = nullptr;
+        delete tyExpr;
+    } else {
+        // typeof wrapping expression
                         Expression * newExpr = resolveInVoidContext( typeofType->expr, indexer );
                         assert( newExpr->result && ! newExpr->result->isVoid() );
-                        newType = newExpr->result;
-                        newExpr->result = nullptr;
-                        delete typeofType;
-                        delete newExpr;
-                }
-
-                // clear qualifiers for base, combine with typeoftype quals in any case
-                if ( isBasetypeof ) {
+        newType = newExpr->result;
+        newExpr->result = nullptr;
+        delete typeofType;
+        delete newExpr;
+    }
+
+    // clear qualifiers for base, combine with typeoftype quals in any case
+    if ( isBasetypeof ) {
                         // replace basetypeof(<enum>) by int
                         if ( dynamic_cast<EnumInstType*>(newType) ) {
@@ -112 +112 @@
                                 = ( newType->get_qualifiers().val & ~Type::Qualifiers::Mask ) | oldQuals;
                 } else {
-                        newType->get_qualifiers().val |= oldQuals;
-                }
-
-                return newType;
-        }
+        newType->get_qualifiers().val |= oldQuals;
+    }
+
+    return newType;
+}
 
 namespace {
-        struct ResolveTypeof_new : public ast::WithShortCircuiting {
-                const ResolveContext & context;
+struct ResolveTypeof_new : public ast::WithShortCircuiting {
+    const ResolveContext & context;
 
                 ResolveTypeof_new( const ResolveContext & context ) :
@@ -127 +127 @@
                 void previsit( const ast::TypeofType * ) { visit_children = false; }
 
-                const ast::Type * postvisit( const ast::TypeofType * typeofType ) {
-                        // pass on null expression
-                        if ( ! typeofType->expr ) return typeofType;
-
-                        ast::ptr< ast::Type > newType;
-                        if ( auto tyExpr = typeofType->expr.as< ast::TypeExpr >() ) {
-                                // typeof wrapping type
-                                newType = tyExpr->type;
-                        } else {
-                                // typeof wrapping expression
-                                ast::TypeEnvironment dummy;
-                                ast::ptr< ast::Expr > newExpr =
-                                        resolveInVoidContext( typeofType->expr, context, dummy );
-                                assert( newExpr->result && ! newExpr->result->isVoid() );
-                                newType = newExpr->result;
-                        }
-
-                        // clear qualifiers for base, combine with typeoftype quals regardless
-                        if ( typeofType->kind == ast::TypeofType::Basetypeof ) {
-                                // replace basetypeof(<enum>) by int
+        const ast::Type * postvisit( const ast::TypeofType * typeofType ) {
+        // pass on null expression
+            if ( ! typeofType->expr ) return typeofType;
+
+            ast::ptr< ast::Type > newType;
+            if ( auto tyExpr = typeofType->expr.as< ast::TypeExpr >() ) {
+            // typeof wrapping type
+            newType = tyExpr->type;
+        } else {
+            // typeof wrapping expression
+            ast::TypeEnvironment dummy;
+            ast::ptr< ast::Expr > newExpr =
+                resolveInVoidContext( typeofType->expr, context, dummy );
+            assert( newExpr->result && ! newExpr->result->isVoid() );
+            newType = newExpr->result;
+        }
+
+        // clear qualifiers for base, combine with typeoftype quals regardless
+        if ( typeofType->kind == ast::TypeofType::Basetypeof ) {
+            // replace basetypeof(<enum>) by int
                                 if ( newType.as< ast::EnumInstType >() ) {
                                         newType = new ast::BasicType{
                                                 ast::BasicType::SignedInt, newType->qualifiers, copy(newType->attributes) };
-                                }
+            }
                                 reset_qualifiers(
                                         newType,
                                         ( newType->qualifiers & ~ast::CV::EquivQualifiers ) | typeofType->qualifiers );
-                        } else {
+        } else {
                                 add_qualifiers( newType, typeofType->qualifiers );
-                        }
-
-                        return newType.release();
-                }
-        };
+        }
+
+        return newType.release();
+    }
+};
 } // anonymous namespace
 
@@ -195 +195 @@
 
 const ast::ObjectDecl * fixObjectType( const ast::ObjectDecl * decl , const ResolveContext & context ) {
-        if (decl->isTypeFixed) {
-                return decl;
-        }
-
-        auto mutDecl = mutate(decl);
-        {
-                auto resolvedType = resolveTypeof(decl->type, context);
-                resolvedType = fixArrayType(resolvedType, context);
-                mutDecl->type = resolvedType;
-        }
-
-        // Do not mangle unnamed variables.
-        if (!mutDecl->name.empty()) {
-                mutDecl->mangleName = Mangle::mangle(mutDecl);
-        }
-
-        mutDecl->type = renameTyVars(mutDecl->type, RenameMode::GEN_EXPR_ID);
-        mutDecl->isTypeFixed = true;
-        return mutDecl;
-}
-
-} // namespace ResolvExpr
+    if (decl->isTypeFixed) {
+        return decl;
+    }
+
+    auto mutDecl = mutate(decl);
+    fixObjectInit(decl, context);
+    {
+        auto resolvedType = resolveTypeof(decl->type, context);
+        resolvedType = fixArrayType(resolvedType, context);
+        mutDecl->type = resolvedType;
+    }
+
+    // Do not mangle unnamed variables.
+    if (!mutDecl->name.empty()) {
+        mutDecl->mangleName = Mangle::mangle(mutDecl);
+    }
+
+    mutDecl->type = renameTyVars(mutDecl->type, RenameMode::GEN_EXPR_ID);
+    mutDecl->isTypeFixed = true;
+    return mutDecl;
+}
+
+const ast::ObjectDecl *fixObjectInit(const ast::ObjectDecl *decl,
+                                     const ResolveContext &context) {
+    if (decl->isTypeFixed) {
+        return decl;
+    }
+
+    auto mutDecl = mutate(decl);
+
+    if ( auto mutListInit = mutDecl->init.as<ast::ListInit>() ) {
+        // std::list<ast::Designation *> newDesignations;        
+
+        for ( size_t k = 0; k < mutListInit->designations.size(); k++ ) {
+            const ast::Designation *des = mutListInit->designations[k].get();
+            // Desination here
+            ast::Designation * newDesination = new ast::Designation(des->location);
+
+            if (des->designators.size() == 0) continue;
+
+            // The designator I want to replace
+            const ast::Expr * designator = des->designators.at(0);
+
+            if ( const ast::NameExpr * designatorName = dynamic_cast<const ast::NameExpr *>(designator) ) {
+                auto candidates = context.symtab.lookupId(designatorName->name);
+                // Does not work for the overloading case currently
+                // assert( candidates.size() == 1 );
+                if ( candidates.size() != 1 ) return mutDecl;
+                auto candidate = candidates.at(0);
+                if ( const ast::EnumInstType * enumInst = dynamic_cast<const ast::EnumInstType *>(candidate.id->get_type()) ) {
+                    // determine that is an enumInst, swap it with its const value
+                    assert( candidates.size() == 1 );
+                    const ast::EnumDecl * baseEnum = enumInst->base;
+                    // Need to iterate over all enum value to find the initializer to swap
+                    for ( size_t m = 0; m < baseEnum->members.size(); ++m ) {
+                        if ( baseEnum->members.at(m)->name == designatorName->name ) {
+                            const ast::ObjectDecl * mem = baseEnum->members.at(m).as<const ast::ObjectDecl>();
+                            assert(mem);
+                            if ( mem->init ) {
+                                const ast::SingleInit * memInit = mem->init.as<const ast::SingleInit>();
+                                ast::Expr * initValue = shallowCopy( memInit->value.get() );
+                                newDesination->designators.push_back( initValue );
+                            } else {
+                                SemanticError(des->location, "TODO: Enum Array Designation with no explicit value is not implemented");
+                            }
+                        }
+                    }
+                    if ( newDesination->designators.size() == 0 ) {
+                        SemanticError(des->location, "Resolution Error: Resolving array designation as Enum Instance value, but cannot find a desgination value");
+                    }
+                } else {
+                    newDesination->designators.push_back( des->designators.at(0) );
+                }
+            } else {
+                newDesination->designators.push_back( des->designators.at(0) );
+            }
+            mutListInit = ast::mutate_field_index(mutListInit, &ast::ListInit::designations, k, newDesination);
+        }
+    }
+    return mutDecl;
+}
+
+}  // namespace ResolvExpr
 
 // Local Variables: //

src/ResolvExpr/ResolveTypeof.h

@@ -31 +31 @@
         const ast::Type * resolveTypeof( const ast::Type *, const ResolveContext & );
         const ast::ObjectDecl * fixObjectType( const ast::ObjectDecl * decl , const ResolveContext & );
+        const ast::ObjectDecl * fixObjectInit( const ast::ObjectDecl * decl , const ResolveContext &);
 } // namespace ResolvExpr
 

src/ResolvExpr/Resolver.cc

@@ -1507 +1507 @@
                                 if ( InitTweak::tryConstruct( mutDecl ) && ( managedTypes.isManaged( mutDecl ) || ((! isInFunction() || mutDecl->storage.is_static ) && ! InitTweak::isConstExpr( mutDecl->init ) ) ) ) {
                                         // constructed objects cannot be designated
-                                        if ( InitTweak::isDesignated( mutDecl->init ) ) SemanticError( mutDecl, "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n" );
+                                        // if ( InitTweak::isDesignated( mutDecl->init ) ) SemanticError( mutDecl, "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n" );
+                                        if ( InitTweak::isDesignated( mutDecl->init ) ) {
+                                                SemanticError( mutDecl, "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n" );
+                                        }
                                         // constructed objects should not have initializers nested too deeply
                                         if ( ! InitTweak::checkInitDepth( mutDecl ) ) SemanticError( mutDecl, "Managed object's initializer is too deep " );