Changeset 3e54399

Timestamp:

Mar 10, 2022, 2:03:43 AM (3 years ago)

Author:

JiadaL <j82liang@…>

Branches:

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

Children:

f238fcc2

Parents:

786c438

Message:

The compiler now will add a cast to base type for the usage of type enum; but it will fail because of violating some restrictions for the auto-gen functions. Need to investiage more

Location:

src

Files:

• AST/Convert.cpp (modified) (2 diffs)
• AST/Decl.cpp (modified) (1 diff)
• AST/Decl.hpp (modified) (1 diff)
• CodeGen/CodeGenerator.cc (modified) (2 diffs)
• SymTab/Validate.cc (modified) (1 diff)
• SynTree/Declaration.h (modified) (1 diff)

src/AST/Convert.cpp

@@ -305 +305 @@
         }
 
-        const ast::Decl * visit( const ast::EnumDecl * node ) override final { // Marker: what is this for? 
-        // Called in ConverterNewToOld
+        const ast::Decl * visit( const ast::EnumDecl * node ) override final {
                 if ( inCache( node ) ) return nullptr;
                 auto decl = new EnumDecl(
                         node->name,
                         get<Attribute>().acceptL( node->attributes ),
-                        LinkageSpec::Spec( node->linkage.val )
+                        LinkageSpec::Spec( node->linkage.val ),
+                        get<Type>().accept1(node->base)
                 );
                 return aggregatePostamble( decl, node ); // Node info, including members, processed in aggregatePostamble
@@ -2768 +2768 @@
         }
 
-        virtual void visit( const EnumInstType * old ) override final {
-                ast::EnumInstType * ty;
+        virtual void visit( const EnumInstType * old ) override final { // Here is visiting the EnumInst Decl not the usage.
+                ast::EnumInstType * ty; 
                 if ( old->baseEnum ) {
                         ty = new ast::EnumInstType{

src/AST/Decl.cpp

@@ -137 +137 @@
                         
                 // Handle typed enum by casting the value in (C++) compiler
-                if ( base ) { // A typed enum
-                        if ( const BasicType * bt = dynamic_cast<const BasicType *>(base) ) {
-                                switch( bt->kind ) {
-                                        case BasicType::Kind::Bool:     value = (bool) it->second; break;
-                                        case BasicType::Kind::Char: value = (char) it->second; break;
-                                        case BasicType::Kind::SignedChar: value = (signed char) it->second; break;
-                                        case BasicType::Kind::UnsignedChar: value = (unsigned char) it->second; break;
-                                        case BasicType::Kind::ShortSignedInt: value = (short signed int) it->second; break;
-                                        case BasicType::Kind::SignedInt: value = (signed int) it->second; break;
-                                        case BasicType::Kind::UnsignedInt: value = (unsigned int) it->second; break;
-                                        case BasicType::Kind::LongSignedInt: value = (long signed int) it->second; break;
-                                        case BasicType::Kind::LongUnsignedInt: value = (long unsigned int) it->second; break;
-                                        case BasicType::Kind::LongLongSignedInt: value = (long long signed int) it->second; break;
-                                        case BasicType::Kind::LongLongUnsignedInt: value = (long long unsigned int) it->second; break; 
-                                        // TODO: value should be able to handle long long unsigned int
+                // if ( base ) { // A typed enum
+                //      if ( const BasicType * bt = dynamic_cast<const BasicType *>(base) ) {
+                //              switch( bt->kind ) {
+                //                      case BasicType::Kind::Bool:     value = (bool) it->second; break;
+                //                      case BasicType::Kind::Char: value = (char) it->second; break;
+                //                      case BasicType::Kind::SignedChar: value = (signed char) it->second; break;
+                //                      case BasicType::Kind::UnsignedChar: value = (unsigned char) it->second; break;
+                //                      case BasicType::Kind::ShortSignedInt: value = (short signed int) it->second; break;
+                //                      case BasicType::Kind::SignedInt: value = (signed int) it->second; break;
+                //                      case BasicType::Kind::UnsignedInt: value = (unsigned int) it->second; break;
+                //                      case BasicType::Kind::LongSignedInt: value = (long signed int) it->second; break;
+                //                      case BasicType::Kind::LongUnsignedInt: value = (long unsigned int) it->second; break;
+                //                      case BasicType::Kind::LongLongSignedInt: value = (long long signed int) it->second; break;
+                //                      case BasicType::Kind::LongLongUnsignedInt: value = (long long unsigned int) it->second; break; 
+                //                      // TODO: value should be able to handle long long unsigned int
 
-                                        default:
-                                        value = it->second;
-                                }
-                        }
-                } else {
+                //                      default:
+                //                      value = it->second;
+                //              }
+                //      }
+                // } else {
                         value = it->second;
-                }
+                //}
 
                 return true;

src/AST/Decl.hpp

@@ -302 +302 @@
 class EnumDecl final : public AggregateDecl {
 public:
-        Type * base;
+        ptr<Type> base;
 
         EnumDecl( const CodeLocation& loc, const std::string& name,

src/CodeGen/CodeGenerator.cc

@@ -348 +348 @@
                                 des->accept( *visitor );
                         } else {
-                                // otherwise, it has to be a ConstantExpr or CastExpr, initializing array eleemnt
+                                // otherwise, it has to be a ConstantExpr or CastExpr, initializing array element
                                 output << "[";
                                 des->accept( *visitor );
@@ -662 +662 @@
                         output << opInfo->symbol;
                 } else {
+                        if (dynamic_cast<EnumInstType *>(variableExpr->get_var()->get_type()) 
+                        && dynamic_cast<EnumInstType *>(variableExpr->get_var()->get_type())->baseEnum->base) {
+                                output << '(' <<genType(dynamic_cast<EnumInstType *>(variableExpr->get_var()->get_type())->baseEnum->base, "", options) << ')';
+                        }
                         output << mangleName( variableExpr->get_var() );
                 } // if

src/SymTab/Validate.cc

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

src/SynTree/Declaration.h

@@ -339 +339 @@
           LinkageSpec::Spec linkage = LinkageSpec::Cforall,
           Type * baseType = nullptr ) : Parent( name, attributes, linkage ) , base( baseType ){}
-        EnumDecl( const EnumDecl & other ) : Parent( other ) {}
+        EnumDecl( const EnumDecl & other ) : Parent( other ), base( other.base ) {}
 
         bool valueOf( Declaration * enumerator, long long int & value );