Changeset 4559b34

Timestamp:

Apr 3, 2022, 8:49:42 PM (3 years ago)

Author:

JiadaL <j82liang@…>

Branches:

ADT, ast-experimental, enum, master, pthread-emulation, qualifiedEnum

Children:

92538ab

Parents:

3eb1653

Message:

Update the String Enum implementation. The declaration now can handles creating the enum decl. But the compilation fails when trying to create reference to the Enum. Need a way to resolve InstTypes?

Location:

src

Files:

• AST/Convert.cpp (modified) (2 diffs)
• AST/Decl.hpp (modified) (1 diff)
• AST/Print.cpp (modified) (1 diff)
• Common/PassVisitor.impl.h (modified) (1 diff)
• ResolvExpr/Resolver.cc (modified) (1 diff)
• SymTab/Validate.cc (modified) (1 diff)
• SynTree/AggregateDecl.cc (modified) (2 diffs)
• SynTree/Declaration.h (modified) (2 diffs)

src/AST/Convert.cpp

@@ -1468 +1468 @@
                 return strict_dynamic_cast< ast::Decl * >( node );
         }
-
+        
         ConverterOldToNew() = default;
         ConverterOldToNew(const ConverterOldToNew &) = delete;
@@ -2771 +2771 @@
                 ast::EnumInstType * ty; 
                 if ( old->baseEnum ) {
-                        ty = new ast::EnumInstType{
+                        ty = new ast::EnumInstType{ // Probably here: missing the specification of the base
                                 GET_ACCEPT_1( baseEnum, EnumDecl ),
                                 cv( old ),

src/AST/Decl.hpp

@@ -317 +317 @@
         const char * typeString() const override { return aggrString( Enum ); }
 
+        bool isTyped() {return base && base.get();}
+
 private:
         EnumDecl * clone() const override { return new EnumDecl{ *this }; }

src/AST/Print.cpp

@@ -210 +210 @@
                 }
 
+                auto ptrToEnum = dynamic_cast<const ast::EnumDecl *>(node);
+                if ( ! short_mode && ptrToEnum && ptrToEnum->base ) {
+                        os << endl << indent << ".. with (enum) base" << endl;
+                        ++indent;
+                        ptrToEnum->base->accept( *this );
+                        --indent;  
+                }
+
                 os << endl;
         }

src/Common/PassVisitor.impl.h

@@ -754 +754 @@
 
         // unlike structs, traits, and unions, enums inject their members into the global scope
-        if ( node->base ) maybeAccept_impl( node->base, *this ); // Need this? Maybe not?
+        // if ( node->base ) maybeAccept_impl( node->base, *this ); // Need this? Maybe not?
         maybeAccept_impl( node->parameters, *this );
         maybeAccept_impl( node->members   , *this );

src/ResolvExpr/Resolver.cc

@@ -1470 +1470 @@
                         // enumerator initializers should not use the enum type to initialize, since the
                         // enum type is still incomplete at this point. Use `int` instead.
-                        objectDecl = fixObjectType(objectDecl, symtab);
-                        currentObject = ast::CurrentObject{
-                                objectDecl->location, new ast::BasicType{ ast::BasicType::SignedInt } };
+
+                        if (dynamic_cast< const ast::EnumInstType * >( objectDecl->get_type() )->base->base) { // const ast::PointerType &
+                                const ast::Type * enumBase =  (dynamic_cast< const ast::EnumInstType * >( objectDecl->get_type() )->base->base.get());
+                                const ast::PointerType * enumBaseAsPtr = dynamic_cast<const ast::PointerType *>(enumBase);
+
+                                if ( enumBaseAsPtr ) {
+                                        const ast::Type * pointerBase = enumBaseAsPtr->base.get();
+                                        if ( dynamic_cast<const ast::BasicType *>(pointerBase) ) {
+                                                objectDecl = fixObjectType(objectDecl, symtab);
+                                                if (dynamic_cast<const ast::BasicType *>(pointerBase)->kind == ast::BasicType::Char)
+                                                currentObject = ast::CurrentObject{
+                                                        objectDecl->location,  new ast::PointerType{ 
+                                                                new ast::BasicType{ ast::BasicType::Char }
+                                                        } };
+                                        } else {
+                                                objectDecl = fixObjectType(objectDecl, symtab);
+                                                currentObject = ast::CurrentObject{objectDecl->location, new ast::BasicType{ ast::BasicType::SignedInt } };
+                                        }
+                                }
+                        } else {
+                                objectDecl = fixObjectType(objectDecl, symtab);
+                                currentObject = ast::CurrentObject{
+                                        objectDecl->location, new ast::BasicType{ ast::BasicType::SignedInt } };
+                        }
+
                 }
                 else {

src/SymTab/Validate.cc

@@ -939 +939 @@
                                         // need to resolve enumerator initializers early so that other passes that determine if an expression is constexpr have the appropriate information.
                                         SingleInit * init = strict_dynamic_cast<SingleInit *>( field->init );
-                                        ResolvExpr::findSingleExpression( init->value, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), indexer );
+                                        if ( !enumDecl->base || dynamic_cast<BasicType *>(enumDecl->base))
+                                                ResolvExpr::findSingleExpression( init->value, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), indexer );
+                                        else {
+                                                if (dynamic_cast<PointerType *>(enumDecl->base)) {
+                                                        auto typePtr = dynamic_cast<PointerType *>(enumDecl->base);
+                                                        ResolvExpr::findSingleExpression( init->value,
+                                                         new PointerType( Type::Qualifiers(), typePtr->base ), indexer );
+                                                } else {
+                                                        ResolvExpr::findSingleExpression( init->value, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), indexer );
+                                                }
+                                        }
+                                        
                                 }
                         }
+
                 } // if
         }

src/SynTree/AggregateDecl.cc

@@ -59 +59 @@
         } // if
         os << " with body " << has_body();
-
         if ( ! parameters.empty() ) {
                 os << endl << indent << "... with parameters" << endl;
@@ -106 +105 @@
 const char * EnumDecl::typeString() const { return aggrString( Enum ); }
 
+void EnumDecl::print( std::ostream & os, Indenter indent ) const {
+        AggregateDecl::print(os, indent);
+        os << " with base? " << (base? "True" : "False") << std::endl;
+        if ( base ) {
+                os << "Base Type of Enum:" << std::endl;
+                base->print(os, indent);
+        }
+        os <<  std::endl << "End of EnumDecl::print" << std::endl;
+}
+
 const char * TraitDecl::typeString() const { return aggrString( Trait ); }
 

src/SynTree/Declaration.h

@@ -290 +290 @@
         AggregateDecl * set_body( bool body ) { AggregateDecl::body = body; return this; }
 
-        virtual void print( std::ostream & os, Indenter indent = {} ) const override final;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
         virtual void printShort( std::ostream & os, Indenter indent = {} ) const override;
   protected:
@@ -352 +352 @@
         Type * base;
         std::unordered_map< std::string, long long int > enumValues;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override final;
   private:
         // std::unordered_map< std::string, long long int > enumValues;