Changeset 06d75931 for src

Timestamp:

Oct 26, 2024, 8:17:20 AM (8 weeks ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

14c31eb

Parents:

3a08cb1 (diff), d031f7f (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src

Files:

• AST/Decl.cpp (modified) (1 diff)
• AST/Decl.hpp (modified) (2 diffs)
• ResolvExpr/CandidateFinder.cpp (modified) (2 diffs)
• ResolvExpr/CommonType.cpp (modified) (2 diffs)
• ResolvExpr/CurrentObject.cpp (modified) (6 diffs)
• Validate/ImplementEnumFunc.cpp (modified) (5 diffs)

src/AST/Decl.cpp

@@ -169 +169 @@
 }
 
-const std::string EnumDecl::getUnmangeldArrayName( const ast::EnumAttribute attr ) const {
-        switch( attr ) {
-                case ast::EnumAttribute::Value: return "values_" + name ;
-                case ast::EnumAttribute::Label: return "labels_" + name;
-                default: /* Posn does not generate array */ 
-                        return "";
-        }
-}
-
-unsigned EnumDecl::calChildOffset(const std::string & target) const{
-        unsigned offset = 0;
-        for (auto childEnum: inlinedDecl) {
-                auto childDecl = childEnum->base;
-                if (childDecl->name == target) {
-                        return offset;
-                }
-                offset += childDecl->members.size();
-        }
-    std::cerr << "Cannot find the target enum" << std::endl;
-        return 0;
-}
-
-unsigned EnumDecl::calChildOffset(const ast::EnumInstType * target) const{
-        return calChildOffset(target->base->name);
-}
-
-bool EnumDecl::isSubTypeOf(const ast::EnumDecl * other) const {
-        if (name == other->name) return true;
-        for (auto inlined: other->inlinedDecl) {
-                if (isSubTypeOf(inlined->base)) return true;
-        }
-        return false;
-}
-
 bool EnumDecl::isTyped() const { return base; }
 

src/AST/Decl.hpp

@@ -302 +302 @@
 };
 
+/// Enumeration attribute kind.
 enum class EnumAttribute{ Value, Posn, Label };
+
 /// enum declaration `enum Foo { ... };`
 class EnumDecl final : public AggregateDecl {
@@ -328 +330 @@
         const char * typeString() const override { return aggrString( Enum ); }
 
-        const std::string getUnmangeldArrayName( const EnumAttribute attr ) const;
-
-        unsigned calChildOffset(const std::string & childEnum) const;
-        unsigned calChildOffset(const ast::EnumInstType * childEnum) const;
-
-        bool isSubTypeOf(const ast::EnumDecl *) const;
         bool isTyped() const;
         bool isOpaque() const;

src/ResolvExpr/CandidateFinder.cpp

@@ -2136 +2136 @@
 }
 
+/// If the target enum is a child, get the offset from the base to the target.
+static unsigned findChildOffset(
+                const ast::EnumDecl * decl, const ast::EnumDecl * target ) {
+        unsigned offset = 0;
+        for ( auto inlined : decl->inlinedDecl ) {
+                auto childDecl = inlined->base;
+                if ( childDecl == target ) {
+                        return offset;
+                }
+                offset += childDecl->members.size();
+        }
+        SemanticError( decl, "Cannot find the target enum." );
+}
+
 const ast::Expr * CandidateFinder::makeEnumOffsetCast( const ast::EnumInstType * src, 
         const ast::EnumInstType * dst, const ast::Expr * expr, Cost minCost ) {
@@ -2147 +2161 @@
                 ast::CastExpr * castToDst;
                 if (c<minCost) {
-                        unsigned offset = dstDecl->calChildOffset(dstChild.get());
+                        unsigned offset = findChildOffset( dstDecl, dstChild.get()->base );
                         if (offset > 0) {
                                 auto untyped = ast::UntypedExpr::createCall(
-                                        expr->location, 
-                                        "?+?", 
+                                        expr->location,
+                                        "?+?",
                                         { new ast::CastExpr( expr->location,
                                                 expr,

src/ResolvExpr/CommonType.cpp

@@ -636 +636 @@
         void postvisit( const ast::UnionInstType * ) {}
 
+        /// Is the target enum a child of the base enum?
+        static bool isChildEnum(
+                        const ast::EnumDecl * decl, const ast::EnumDecl * target ) {
+                if ( decl == target ) return true;
+                for ( auto inlined : decl->inlinedDecl ) {
+                        if ( isChildEnum( inlined->base, target ) ) return true;
+                }
+                return false;
+        }
+
         void postvisit( const ast::EnumInstType * param ) {
                 auto argAsEnumInst = dynamic_cast<const ast::EnumInstType *>(type2);
@@ -641 +651 @@
                         const ast::EnumDecl* paramDecl = param->base;
                         const ast::EnumDecl* argDecl = argAsEnumInst->base;
-                        if (argDecl->isSubTypeOf(paramDecl)) result = param;
+                        if ( isChildEnum( paramDecl, argDecl ) ) {
+                                result = param;
+                        }
                 } else if ( param->base && !param->base->isCfa ) {
                         auto basicType = new ast::BasicType( ast::BasicKind::UnsignedInt );

src/ResolvExpr/CurrentObject.cpp

@@ -60 +60 @@
         /// Retrieve the list of possible (Type,Designation) pairs for the
         /// current position in the current object.
-        virtual std::deque< InitAlternative > operator* () const = 0;
+        virtual std::deque< InitAlternative > getOptions() const = 0;
 
         /// True if the iterator is not currently at the end.
@@ -77 +77 @@
         virtual const Type * getNext() = 0;
 
-        /// Helper for operator*; aggregates must add designator to each init
-        /// alternative, but adding designators in operator* creates duplicates.
+        /// Helper for getOptions; aggregates must add designator to each init
+        /// alternative, but adding designators in getOptions creates duplicates.
         virtual std::deque< InitAlternative > first() const = 0;
 };
@@ -103 +103 @@
         }
 
-        std::deque< InitAlternative > operator* () const override { return first(); }
+        std::deque< InitAlternative > getOptions() const override { return first(); }
 
         operator bool() const override { return type; }
@@ -169 +169 @@
         }
 
-        std::deque< InitAlternative > operator* () const override { return first(); }
+        std::deque< InitAlternative > getOptions() const override { return first(); }
 
         operator bool() const override { return index < size; }
@@ -297 +297 @@
         }
 
-        std::deque< InitAlternative > operator* () const final {
+        std::deque< InitAlternative > getOptions() const final {
                 if ( memberIter && *memberIter ) {
                         std::deque< InitAlternative > ret = memberIter->first();
@@ -594 +594 @@
         PRINT( std::cerr << "____getting current options" << std::endl; )
         assertf( ! objStack.empty(), "objstack empty in getOptions" );
-        return **objStack.back();
+        return objStack.back()->getOptions();
 }
 

src/Validate/ImplementEnumFunc.cpp

@@ -78 +78 @@
         std::vector<ast::ptr<ast::Init>> genValueInit() const;
         ast::ObjectDecl* genAttrArrayProto(
-                const ast::EnumAttribute attr, const CodeLocation& location,
-                std::vector<ast::ptr<ast::Init>>& inits) const;
+                const CodeLocation& location, const std::string& prefix,
+                const ast::Type * type, std::vector<ast::ptr<ast::Init>>& inits ) const;
 };
 
@@ -351 +351 @@
 
 ast::ObjectDecl* EnumAttrFuncGenerator::genAttrArrayProto(
-        const ast::EnumAttribute attr, const CodeLocation& location,
-        std::vector<ast::ptr<ast::Init>>& inits) const {
+                const CodeLocation& location, const std::string& prefix,
+                const ast::Type * type, std::vector<ast::ptr<ast::Init>>& inits ) const {
         ast::ArrayType* arrT = new ast::ArrayType(
-                attr == ast::EnumAttribute::Value
-                        ? decl->base
-                        : new ast::PointerType(
-                                new ast::BasicType(ast::BasicKind::Char, ast::CV::Const)),
+                type,
                 ast::ConstantExpr::from_int(decl->location, decl->members.size()),
                 ast::LengthFlag::FixedLen, ast::DimensionFlag::DynamicDim);
@@ -363 +360 @@
         ast::ObjectDecl* objDecl =
                 new ast::ObjectDecl(
-                        decl->location, decl->getUnmangeldArrayName( attr ),
+                        decl->location, prefix + decl->name,
                         arrT, new ast::ListInit( location, std::move( inits ) ),
                         ast::Storage::Static, ast::Linkage::AutoGen );
@@ -417 +414 @@
 void EnumAttrFuncGenerator::genTypedEnumFunction(const ast::EnumAttribute attr) {
         if (attr == ast::EnumAttribute::Value) {
-                if (decl->isTyped()) {
-                        // TypedEnum's backing arrays
-                        std::vector<ast::ptr<ast::Init>> inits = genValueInit();
-                        ast::ObjectDecl* arrayProto =
-                                genAttrArrayProto(attr, getLocation(), inits);
-                        forwards.push_back(arrayProto);
-
-                        ast::FunctionDecl* funcProto = genValueProto();
-                        produceForwardDecl(funcProto);
-                        genValueOrLabelBody(funcProto, arrayProto);
-                        produceDecl(funcProto);
-                }  
-                // else {
-                //      ast::FunctionDecl* funcProto = genQuasiValueProto();
-                //      produceForwardDecl(funcProto);
-                //      // genQuasiValueBody(funcProto);
-                //      produceDecl(funcProto);
-                // }
+                if ( !decl->isTyped() ) return;
+                std::vector<ast::ptr<ast::Init>> inits = genValueInit();
+                ast::ObjectDecl* arrayProto =
+                        genAttrArrayProto( getLocation(), "values_", decl->base, inits );
+                forwards.push_back(arrayProto);
+
+                ast::FunctionDecl* funcProto = genValueProto();
+                produceForwardDecl(funcProto);
+                genValueOrLabelBody(funcProto, arrayProto);
+                produceDecl(funcProto);
         } else if (attr == ast::EnumAttribute::Label) {
                 std::vector<ast::ptr<ast::Init>> inits = genLabelInit();
+                const ast::Type * type = new ast::PointerType(
+                        new ast::BasicType( ast::BasicKind::Char, ast::CV::Const ) );
                 ast::ObjectDecl* arrayProto =
-                        genAttrArrayProto(attr, getLocation(), inits);
+                        genAttrArrayProto( getLocation(), "labels_", type, inits );
                 forwards.push_back(arrayProto);
                 ast::FunctionDecl* funcProto = genLabelProto();
@@ -445 +436 @@
                 produceDecl(funcProto);
         } else {
+                assert( attr == ast::EnumAttribute::Posn );
                 ast::FunctionDecl* funcProto = genPosnProto();
                 produceForwardDecl(funcProto);