Changeset 1e30df7 for src

Timestamp:

Oct 18, 2022, 5:48:13 PM (19 months ago)

Author:

JiadaL <j82liang@…>

Branches:

ADT, ast-experimental, master

Children:

5408b59

Parents:

a55472cc

Message:

Supports inline enums

Location:

src

Files:

• AST/Convert.cpp (modified) (1 diff)
• AST/Decl.hpp (modified) (1 diff)
• Parser/DeclarationNode.cc (modified) (1 diff)
• Parser/ParseNode.h (modified) (2 diffs)
• Parser/TypeData.cc (modified) (1 diff)
• Parser/parser.yy (modified) (1 diff)
• SynTree/Declaration.h (modified) (1 diff)
• Validate/LinkReferenceToTypes.cpp (modified) (1 diff)

src/AST/Convert.cpp

@@ -1615 +1615 @@
                         { old->get_funcSpec().val }
                 );
+                decl->enumInLine = old->enumInLine;
                 cache.emplace(old, decl);
                 assert(cache.find( old ) != cache.end());

src/AST/Decl.hpp

@@ -105 +105 @@
         ptr<Init> init;
         ptr<Expr> bitfieldWidth;
+        bool enumInLine = false; // A flag vairable to tell the compile:
+        // this is not a real object declaration. It is a place holder for 
+        // a set of enum value (ObjectDecl).
 
         ObjectDecl( const CodeLocation & loc, const std::string & name, const Type * type,

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/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

@@ -2601 +2601 @@
                 { $$ = 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/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/Validate/LinkReferenceToTypes.cpp

@@ -203 +203 @@
         }
 
+        // 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
+                                        );
+                                        buffer.push_back(t);
+                                }
+                        }
+                } else {
+                        buffer.push_back( *it );
+                }
+        }
+        mut->members = buffer;
+        decl = mut;
+
         ForwardEnumsType::iterator fwds = forwardEnums.find( decl->name );
         if ( fwds != forwardEnums.end() ) {