Changeset d191e24 for src

Timestamp:

Oct 19, 2022, 5:29:12 PM (3 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, ast-experimental, master

Children:

bc899d6

Parents:

82ff4ed1 (diff), 058ece2 (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/Convert.cpp (modified) (5 diffs)
• AST/Decl.hpp (modified) (2 diffs)
• AST/Expr.hpp (modified) (1 diff)
• AST/Pass.impl.hpp (modified) (1 diff)
• CodeGen/CodeGenerator.cc (modified) (1 diff)
• CodeGen/CodeGenerator.h (modified) (1 diff)
• Common/PassVisitor.impl.h (modified) (3 diffs)
• Parser/DeclarationNode.cc (modified) (1 diff)
• Parser/ExpressionNode.cc (modified) (1 diff)
• Parser/ParseNode.h (modified) (2 diffs)
• Parser/TypeData.cc (modified) (1 diff)
• Parser/parser.yy (modified) (1 diff)
• ResolvExpr/CandidateFinder.cpp (modified) (1 diff)
• SymTab/Mangler.cc (modified) (4 diffs)
• SymTab/Validate.cc (modified) (1 diff)
• SymTab/ValidateType.cc (modified) (1 diff)
• SynTree/AddressExpr.cc (modified) (1 diff)
• SynTree/Declaration.h (modified) (1 diff)
• SynTree/Expression.h (modified) (1 diff)
• Validate/FixQualifiedTypes.cpp (modified) (1 diff)
• Validate/LinkReferenceToTypes.cpp (modified) (3 diffs)

src/AST/Convert.cpp

@@ -310 +310 @@
                         node->name,
                         get<Attribute>().acceptL( node->attributes ),
-                        false, // Temporary
+                        node->isTyped,
                         LinkageSpec::Spec( node->linkage.val ),
                         get<Type>().accept1(node->base)
                 );
-                return aggregatePostamble( decl, node ); // Node info, including members, processed in aggregatePostamble
+                return aggregatePostamble( decl, node );
         }
 
@@ -737 +737 @@
                                 node->name
                 );
-                temp->var = get<DeclarationWithType>().accept1(node->var);
                 auto expr = visitBaseExpr( node,
                         temp
@@ -1615 +1614 @@
                         { old->get_funcSpec().val }
                 );
+                decl->enumInLine = old->enumInLine;
                 cache.emplace(old, decl);
                 assert(cache.find( old ) != cache.end());
@@ -2281 +2281 @@
         }
 
-        /// xxx - type_decl should be DeclWithType in the final design
-        /// type_decl is set to EnumDecl as a temporary fix
         virtual void visit( const QualifiedNameExpr * old ) override final {
                 this->node = visitBaseExpr( old,
@@ -2288 +2286 @@
                                 old->location,
                                 GET_ACCEPT_1(type_decl, Decl),
-                                GET_ACCEPT_1(var, DeclWithType),
                                 old->name
                         )

src/AST/Decl.hpp

@@ -105 +105 @@
         ptr<Init> init;
         ptr<Expr> bitfieldWidth;
+        bool enumInLine = false; // enum inline is not a real object declaration. 
+        // It is a place holder for a set of enum value (ObjectDecl)
+        bool importValue = false; // if the value copied from somewhere else
 
         ObjectDecl( const CodeLocation & loc, const std::string & name, const Type * type,
@@ -312 +315 @@
 class EnumDecl final : public AggregateDecl {
 public:
-        bool isTyped;
-        ptr<Type> base;
+        bool isTyped; // isTyped indicated if the enum has a declaration like:
+        // enum (type_optional) Name {...} 
+        ptr<Type> base; // if isTyped == true && base.get() == nullptr, it is a "void" type enum
 
         EnumDecl( const CodeLocation& loc, const std::string& name, bool isTyped = false, 

src/AST/Expr.hpp

@@ -257 +257 @@
 public:
         ptr<Decl> type_decl;
-        ptr<DeclWithType> var;
         std::string name;
 
-        QualifiedNameExpr( const CodeLocation & loc, const Decl * d, const DeclWithType * r, const std::string & n ) 
-        : Expr( loc ), type_decl( d ), var(r), name( n ) {}
+        QualifiedNameExpr( const CodeLocation & loc, const Decl * d, const std::string & n ) 
+        : Expr( loc ), type_decl( d ), name( n ) {}
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }

src/AST/Pass.impl.hpp

@@ -1205 +1205 @@
         if ( __visit_children() ) {
                 guard_symtab guard { *this };
-                maybe_accept( node, &QualifiedNameExpr::var );
                 maybe_accept( node, &QualifiedNameExpr::type_decl );
         }

src/CodeGen/CodeGenerator.cc

@@ -912 +912 @@
                 }
                 output << ")";
-        }
-
-        // QualifiedNameExpr should not reach to CodeGen.
-        // FixQualifiedName Convert QualifiedNameExpr to VariableExpr
-        void CodeGenerator::postvisit( QualifiedNameExpr * expr ) {
-                output << "/* label */" << mangleName(expr->var);
         }
 

src/CodeGen/CodeGenerator.h

@@ -103 +103 @@
                 void postvisit( DefaultArgExpr * );
                 void postvisit( GenericExpr * );
-                void postvisit( QualifiedNameExpr *);
 
                 //*** Statements

src/Common/PassVisitor.impl.h

@@ -1934 +1934 @@
         indexerScopedAccept( node->result, *this );
         maybeAccept_impl( node->type_decl, *this );
-        maybeAccept_impl( node->var, *this );
 
         VISIT_END( node );
@@ -1945 +1944 @@
         indexerScopedAccept( node->result, *this );
         maybeAccept_impl( node->type_decl, *this );
-        maybeAccept_impl( node->var, *this );
 
         VISIT_END( node );
@@ -1957 +1955 @@
     indexerScopedMutate( node->result, *this );
         maybeMutate_impl( node->type_decl, *this );
-        maybeAccept_impl( node->var, *this );
 
         MUTATE_END( Expression, node );

src/Parser/DeclarationNode.cc

@@ -297 +297 @@
         } // if
 } // DeclarationNode::newEnumValueGeneric
+
+DeclarationNode * DeclarationNode::newEnumInLine( const string name ) {
+        DeclarationNode * newnode = newName( new std::string(name) );
+        newnode->enumInLine = true;
+        return newnode;
+}
 
 DeclarationNode * DeclarationNode::newFromTypedef( const string * name ) {

src/Parser/ExpressionNode.cc

@@ -523 +523 @@
                 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;

src/Parser/ParseNode.h

@@ -240 +240 @@
         static DeclarationNode * newEnumConstant( const std::string * name, ExpressionNode * constant );
         static DeclarationNode * newEnumValueGeneric( const std::string * name, InitializerNode * init );
+        static DeclarationNode * newEnumInLine( const std::string name );
         static DeclarationNode * newName( const std::string * );
         static DeclarationNode * newFromTypeGen( const std::string *, ExpressionNode * params );
@@ -339 +340 @@
 
         bool inLine = false;
+        bool enumInLine = false; 
         Type::FuncSpecifiers funcSpecs;
         Type::StorageClasses storageClasses;

src/Parser/TypeData.cc

@@ -924 +924 @@
         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->enumInLine ) {
+                        // Tell the compiler this is a inline value placeholder
+                        ObjectDecl * member = dynamic_cast< ObjectDecl* >(* members);
+                        member->enumInLine = true;
+                }
                 if ( ret->isTyped && !ret->base && cur->has_enumeratorValue() ) {
                         SemanticError( td->location, "Enumerator of enum(void) cannot have an explicit initializer value." );

src/Parser/parser.yy

@@ -2605 +2605 @@
                 { $$ = DeclarationNode::newEnumValueGeneric( $1, $2 ); }
         | INLINE type_name
-                { $$ = DeclarationNode::newEnumValueGeneric( new string("inline"), nullptr ); }
+                { $$ = DeclarationNode::newEnumInLine( *$2->type->symbolic.name ); }
         | enumerator_list ',' identifier_or_type_name enumerator_value_opt
                 { $$ = $1->appendList( DeclarationNode::newEnumValueGeneric( $3, $4 ) ); }

src/ResolvExpr/CandidateFinder.cpp

@@ -862 +862 @@
                                 }
                         }
-                }
-
-                void postvisit( const ast::QualifiedNameExpr * qualifiedNameExpr ) {
-                        auto mangleName = Mangle::mangle(qualifiedNameExpr->var);
-                        addCandidate( qualifiedNameExpr, tenv );
                 }
 

src/SymTab/Mangler.cc

@@ -65 +65 @@
                                 void postvisit( const QualifiedType * qualType );
 
-                                void postvisit( const QualifiedNameExpr * qualNameExpr );
-
                                 std::string get_mangleName() { return mangleName; }
                           private:
@@ -307 +305 @@
                                         mangleName += Encoding::qualifiedTypeEnd;
                                 }
-                        }
-
-                        void Mangler_old::postvisit( const QualifiedNameExpr * qual ) {
-                                maybeAccept( qual->var, *visitor );
                         }
 
@@ -423 +417 @@
                         void postvisit( const ast::OneType * oneType );
                         void postvisit( const ast::QualifiedType * qualType );
-                        void postvisit( const ast::QualifiedNameExpr * qualNameExpr );
 
                         std::string get_mangleName() { return mangleName; }
@@ -652 +645 @@
                                 mangleName += Encoding::qualifiedTypeEnd;
                         }
-                }
-                void Mangler_new::postvisit( const ast::QualifiedNameExpr * qual ) {
-                        maybeAccept( qual->var.get(), *visitor );
                 }
 

src/SymTab/Validate.cc

@@ -858 +858 @@
                         declsToAddBefore.push_back( new UnionDecl( aggDecl->name, noAttributes, tyDecl->linkage ) );
                 } else if ( EnumInstType * enumInst = dynamic_cast< EnumInstType * >( designatorType ) ) {
-                        // declsToAddBefore.push_back( new EnumDecl( enumDecl->name, noAttributes, tyDecl->linkage, enumDecl->baseEnum->base ) );
                         if ( enumInst->baseEnum ) {
                                 const EnumDecl * enumDecl = enumInst->baseEnum;

src/SymTab/ValidateType.cc

@@ -81 +81 @@
         void previsit( QualifiedType * qualType );
         void postvisit( QualifiedType * qualType );
-
         void postvisit( QualifiedNameExpr * qualExpr );
-
+        
         void postvisit( EnumDecl * enumDecl );
         void postvisit( StructDecl * structDecl );

src/SynTree/AddressExpr.cc

@@ -50 +50 @@
                                 set_result( addrType( refType->base ) );
                         } else {
+                                if(!arg->result->location.isSet()) arg->result->location = arg->location;
                                 SemanticError( arg->result, "Attempt to take address of non-lvalue expression: " );
                         } // if

src/SynTree/Declaration.h

@@ -121 +121 @@
         Initializer * init;
         Expression * bitfieldWidth;
+        bool enumInLine = false;
 
         ObjectDecl( const std::string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage, Expression * bitfieldWidth, Type * type, Initializer * init,

src/SynTree/Expression.h

@@ -168 +168 @@
         Declaration * type_decl;
         std::string name;
-        DeclarationWithType * var;
 
         QualifiedNameExpr( Declaration * decl, std::string name): Expression(), type_decl(decl), name(name) {}
-        QualifiedNameExpr( const QualifiedNameExpr & other): Expression(other), type_decl(other.type_decl), name(other.name), var(other.var) {}
-        DeclarationWithType * get_var() const { return var; }
-        void set_var( DeclarationWithType * newValue ) { var = newValue; }
+        QualifiedNameExpr( const QualifiedNameExpr & other): Expression(other), type_decl(other.type_decl), name(other.name) {}
 
         virtual ~QualifiedNameExpr() {
-                delete var;
                 delete type_decl;
         }

src/Validate/FixQualifiedTypes.cpp

@@ -102 +102 @@
                         }
 
-
-                auto var = new ast::ObjectDecl( t->var->location, t->name,
-                         new ast::EnumInstType(enumDecl, ast::CV::Const), nullptr, {}, ast::Linkage::Cforall );
-                        var->scopeLevel = 1; // 1 for now; should copy the scopeLevel of the enumValue
+                auto var = new ast::ObjectDecl( t->location, t->name,
+                        new ast::EnumInstType(enumDecl, ast::CV::Const), nullptr, {}, ast::Linkage::Cforall );
                         var->mangleName = Mangle::mangle( var );
                         return new ast::VariableExpr( t->location, var );
-                // return ret;
         }
 

src/Validate/LinkReferenceToTypes.cpp

@@ -44 +44 @@
         void postvisit( ast::UnionDecl const * decl );
         ast::TraitDecl const * postvisit( ast::TraitDecl const * decl );
-        ast::QualifiedNameExpr const * previsit( ast::QualifiedNameExpr const * decl);
 
 private:
@@ -203 +202 @@
         }
 
+        // The following section 
+        auto mut = ast::mutate( decl );
+        std::vector<ast::ptr<ast::Decl>> buffer;
+        for ( auto it = decl->members.begin(); it != decl->members.end(); ++it) {
+                auto member = (*it).as<ast::ObjectDecl>();
+                if ( member->enumInLine ) {
+                        auto targetEnum = symtab.lookupEnum( member->name );
+                        if ( targetEnum ) {                     
+                                for ( auto singleMamber : targetEnum->members ) {
+                                        auto tm = singleMamber.as<ast::ObjectDecl>();
+                                        auto t = new ast::ObjectDecl(
+                                                member->location, // use the "inline" location
+                                                tm->name,
+                                                new ast::EnumInstType( decl, ast::CV::Const ),
+                                                // Construct a new EnumInstType as the type
+                                                tm->init,
+                                                tm->storage,
+                                                tm->linkage,
+                                                tm->bitfieldWidth,
+                                                {}, // enum member doesn't have attribute
+                                                tm->funcSpec
+                                        );
+                                        t->importValue = true;
+                                        buffer.push_back(t);
+                                }
+                        }
+                } else {
+                        auto search_it = std::find_if( buffer.begin(), buffer.end(), [member](ast::ptr<ast::Decl> cur) {
+                                auto curAsObjDecl = cur.as<ast::ObjectDecl>();
+                                return (curAsObjDecl->importValue) && (curAsObjDecl->name == member->name);
+                        });
+                        if ( search_it != buffer.end() ) {
+                                buffer.erase( search_it ); // Found an import enum value that has the same name
+                                // override the imported value
+                        }
+                        buffer.push_back( *it );
+                }
+        }
+        mut->members = buffer;
+        decl = mut;
+
         ForwardEnumsType::iterator fwds = forwardEnums.find( decl->name );
         if ( fwds != forwardEnums.end() ) {
@@ -284 +324 @@
 }
 
-ast::QualifiedNameExpr const * LinkTypesCore::previsit( ast::QualifiedNameExpr const * decl ) {
-        // Try to lookup type
-        if ( auto objDecl = decl->type_decl.as<ast::ObjectDecl>() ) {
-                if ( auto inst = objDecl->type.as<ast::TypeInstType>()) {
-                        if ( auto enumDecl = symtab.lookupEnum ( inst->name ) ) {
-                                auto mut = ast::mutate( decl );
-                                mut->type_decl = enumDecl;
-                                auto enumInst = new ast::EnumInstType( enumDecl );
-                                enumInst->name = decl->name;
-                                // Adding result; addCandidate() use result
-                                mut->result = enumInst;
-                                decl = mut;
-                        }
-                }
-        } else if ( auto enumDecl = decl->type_decl.as<ast::EnumDecl>() ) {
-                auto mut = ast::mutate( decl );
-                auto enumInst = new ast::EnumInstType( enumDecl );
-                enumInst->name = decl->name;
-                // Adding result; addCandidate() use result
-                mut->result = enumInst;
-                decl = mut;
-        }
-        // ast::EnumDecl const * decl = symtab.lookupEnum( type->name );
-        // // It's not a semantic error if the enum is not found, just an implicit forward declaration.
-        // if ( decl ) {
-        //      // Just linking in the node.
-        //      auto mut = ast::mutate( type );
-        //      mut->base = const_cast<ast::EnumDecl *>( decl );
-        //      type = mut;
-        // }
-        return decl;
-}
-
 } // namespace