Changeset 85855b0 for src/AST

Timestamp:

Jun 10, 2024, 2:43:13 AM (19 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

42cdd07d

Parents:

d68de59

Message:

1. Implement enum cast; 2. Change valueE so that opague enum returns quasi_void; 3. change enum hiding interpretation and pass visiting scheme

Location:

src/AST

Files:

• Decl.cpp (modified) (1 diff)
• Decl.hpp (modified) (3 diffs)
• Expr.hpp (modified) (1 diff)
• Pass.impl.hpp (modified) (1 diff)
• SymbolTable.cpp (modified) (1 diff)
• SymbolTable.hpp (modified) (1 diff)
• Util.cpp (modified) (1 diff)

src/AST/Decl.cpp

@@ -170 +170 @@
 
 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 "";
+        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;
+}
 
 }

src/AST/Decl.hpp

@@ -75 +75 @@
         bool isDeleted = false;
         bool isTypeFixed = false;
+        bool isHidden = false;
 
         DeclWithType( const CodeLocation& loc, const std::string& name, Storage::Classes storage,
@@ -313 +314 @@
         ptr<Type> base;
         enum class EnumHiding { Visible, Hide } hide;
+        std::vector< ast::ptr<ast::EnumInstType>> inlinedDecl; // child enums
+
         EnumDecl( const CodeLocation& loc, const std::string& name, bool isTyped = false,
                 std::vector<ptr<Attribute>>&& attrs = {}, Linkage::Spec linkage = Linkage::Cforall,
@@ -328 +331 @@
 
         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;
 private:
         EnumDecl * clone() const override { return new EnumDecl{ *this }; }

src/AST/Expr.hpp

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

src/AST/Pass.impl.hpp

@@ -560 +560 @@
 
         if ( __visit_children() ) {
-                if ( node->hide == ast::EnumDecl::EnumHiding::Hide ) {
-                        guard_symtab guard { *this };
-                        maybe_accept( node, &EnumDecl::base );
-                        maybe_accept( node, &EnumDecl::params     );
-                        maybe_accept( node, &EnumDecl::members    );
-                        maybe_accept( node, &EnumDecl::attributes );
-                } else {
-                        maybe_accept( node, &EnumDecl::base );
-                        maybe_accept( node, &EnumDecl::params     );
-                        maybe_accept( node, &EnumDecl::members    );
-                        maybe_accept( node, &EnumDecl::attributes );
-                }
+                maybe_accept( node, &EnumDecl::base        );
+                maybe_accept( node, &EnumDecl::params      );
+                maybe_accept( node, &EnumDecl::members     );
+                maybe_accept( node, &EnumDecl::attributes  );
+                maybe_accept( node, &EnumDecl::inlinedDecl );
         }
 

src/AST/SymbolTable.cpp

@@ -159 +159 @@
 }
 
+std::vector<SymbolTable::IdData> SymbolTable::lookupIdIgnoreHidden( const std::string &id ) const {
+        std::vector<IdData> out;
+        std::vector<IdData> lookupResult = lookupId(id);
+        for ( auto candidate: lookupResult) {
+                if ( candidate.id ) {
+                        if (candidate.id->isHidden) continue;
+                }
+                out.push_back(candidate);
+        }
+        return out;
+}
+
 std::vector<SymbolTable::IdData> SymbolTable::specialLookupId( SymbolTable::SpecialFunctionKind kind, const std::string & otypeKey ) const {
         static Stats::Counters::CounterGroup * special_stats = Stats::Counters::build<Stats::Counters::CounterGroup>("Special Lookups");

src/AST/SymbolTable.hpp

@@ -121 +121 @@
         /// Gets all declarations with the given ID
         std::vector<IdData> lookupId( const std::string &id ) const;
+        /// Gets all declarations with the given ID, ignoring hidden members from enumeration
+        std::vector<IdData> lookupIdIgnoreHidden( const std::string &id ) const;
         /// Gets special functions associated with a type; if no key is given, returns everything
         std::vector<IdData> specialLookupId( SpecialFunctionKind kind, const std::string & otypeKey = "" ) const;

src/AST/Util.cpp

@@ -352 +352 @@
         void previsit( EnumDecl const * decl ) {
                 enumDecls.insert( decl );
-                if ( ast::EnumDecl::EnumHiding::Visible == decl->hide ) {
-                        for ( auto & member : decl->members ) {
-                                typedDecls.insert( member.strict_as<ast::DeclWithType>() );
-                        }
+                for ( auto & member : decl->members ) {
+                        typedDecls.insert( member.strict_as<ast::DeclWithType>() );
                 }
                 beginScope();