Changeset 154672d for src

Timestamp:

Sep 7, 2023, 10:05:33 AM (2 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

0f8b1a7

Parents:

79b05224 (diff), 416b443 (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:

• ControlStruct/MultiLevelExit.cpp (modified) (6 diffs)
• ResolvExpr/ResolveTypeof.cc (modified) (4 diffs)
• ResolvExpr/Resolver.cc (modified) (2 diffs)

src/ControlStruct/MultiLevelExit.cpp

@@ -10 +10 @@
 // Created On       : Mon Nov  1 13:48:00 2021
 // Last Modified By : Andrew Beach
-// Last Modified On : Mon Mar 28  9:42:00 2022
-// Update Count     : 34
+// Last Modified On : Wed Sep  6 12:00:00 2023
+// Update Count     : 35
 //
 
@@ -18 +18 @@
 #include "AST/Pass.hpp"
 #include "AST/Stmt.hpp"
-#include "Common/CodeLocationTools.hpp"
 #include "LabelGeneratorNew.hpp"
 
@@ -26 +25 @@
 
 namespace ControlStruct {
+
+namespace {
+
 class Entry {
   public:
@@ -35 +37 @@
                 bool used = false;
                 Target( const Label & label ) : label( label ) {}
-                Target() : label( CodeLocation() ) {}
+                Target() : label( CodeLocation(), "" ) {}
         };
         Target firstTarget;
@@ -524 +526 @@
         // if continue is used insert a continue label into the back of the body of the loop
         if ( entry.isContUsed() ) {
-                CompoundStmt * new_body = new CompoundStmt( body->location );
-                // {}
-                new_body->kids.push_back( body );
                 // {
                 //  body
+                //  ContinueLabel: ;
                 // }
-                new_body->kids.push_back(
-                        labelledNullStmt( body->location, entry.useContExit() ) );
-                // {
-                //  body
-                //  ContinueLabel: {}
-                // }
-                return new_body;
+                return new CompoundStmt( body->location, {
+                        body,
+                        labelledNullStmt( body->location, entry.useContExit() ),
+                } );
         }
 
@@ -620 +617 @@
 }
 
+} // namespace
+
 const CompoundStmt * multiLevelExitUpdate(
-        const CompoundStmt * stmt,
-        const LabelToStmt & labelTable ) {
+                const CompoundStmt * stmt, const LabelToStmt & labelTable ) {
         // Must start in the body, so FunctionDecls can be a stopping point.
         Pass<MultiLevelExitCore> visitor( labelTable );
-        const CompoundStmt * ret = stmt->accept( visitor );
-        // There are some unset code locations slipping in, possibly by Labels.
-        const Node * node = localFillCodeLocations( ret->location, ret );
-        return strict_dynamic_cast<const CompoundStmt *>( node );
-}
+        return stmt->accept( visitor );
+}
+
 } // namespace ControlStruct
 

src/ResolvExpr/ResolveTypeof.cc

@@ -237 +237 @@
             // The designator I want to replace
             const ast::Expr * designator = des->designators.at(0);
-
+            // Stupid flag variable for development, to be removed
+            bool mutated = false;
             if ( const ast::NameExpr * designatorName = dynamic_cast<const ast::NameExpr *>(designator) ) {
                 auto candidates = context.symtab.lookupId(designatorName->name);
@@ -244 +245 @@
                 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()) ) {
+                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 );
@@ -250 +251 @@
                     // Need to iterate over all enum value to find the initializer to swap
                     for ( size_t m = 0; m < baseEnum->members.size(); ++m ) {
+                        const ast::ObjectDecl * mem = baseEnum->members.at(m).as<const ast::ObjectDecl>();
                         if ( baseEnum->members.at(m)->name == designatorName->name ) {
-                            const ast::ObjectDecl * mem = baseEnum->members.at(m).as<const ast::ObjectDecl>();
                             assert(mem);
-                            const ast::ConstantExpr * enumAsInit = ast::ConstantExpr::from_int(newDesination->location, m);
-                            newDesination->designators.push_back( enumAsInit );
+                            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 );
+                                mutated = true;
+                            }
+                            break;
                         }
-                    }
-                    if ( newDesination->designators.size() == 0 ) {
-                        SemanticError(des->location, "Resolution Error: Resolving array designation as Enum Instance value, but cannot find a desgination value");
                     }
                 } else {
@@ -266 +269 @@
                 newDesination->designators.push_back( des->designators.at(0) );
             }
-            mutListInit = ast::mutate_field_index(mutListInit, &ast::ListInit::designations, k, newDesination);
+            if ( mutated ) {
+                mutListInit = ast::mutate_field_index(mutListInit, &ast::ListInit::designations, k, newDesination);
+            }
         }
     }

src/ResolvExpr/Resolver.cc

@@ -988 +988 @@
                         }
                 };
+
+                struct ResolveDesignators_new final : public ast::WithShortCircuiting {
+                        ResolveContext& context;
+                        bool result = false;
+
+                        ResolveDesignators_new( ResolveContext& _context ): context{_context} {};
+
+                        void previsit( const ast::Node * ) {
+                                // short circuit if we already know there are designations
+                                if ( result ) visit_children = false;
+                        }
+
+                        void previsit( const ast::Designation * des ) {
+                                if ( result ) visit_children = false;
+                                else if ( ! des->designators.empty() ) {
+                                        if ( (des->designators.size() == 1) ) {
+                                                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);
+                                                        for ( auto candidate : candidates ) {
+                                                                if ( dynamic_cast<const ast::EnumInstType *>(candidate.id->get_type()) ) {
+                                                                        result = true;
+                                                                        break;
+                                                                }
+                                                        }
+                                                } 
+                                        } 
+                                        visit_children = false;
+                                }
+                        }
+                };
         } // anonymous namespace
         /// Check if this expression is or includes a deleted expression
@@ -1507 +1538 @@
                                 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" );
+                                                ast::Pass<ResolveDesignators_new> res( context );
+                                                maybe_accept( mutDecl->init.get(), res );
+                                                if ( !res.core.result ) {
+                                                        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