Changeset f238fcc2 for src

Timestamp:

Mar 21, 2022, 3:17:37 PM (2 years ago)

Author:

JiadaL <j82liang@…>

Branches:

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

Children:

4390fb6

Parents:

3e54399

Message:

Enable numeric type for typed enum

Location:

src

Files:

• AST/Convert.cpp (modified) (4 diffs)
• CodeGen/GenType.cc (modified) (1 diff)
• Parser/TypeData.cc (modified) (2 diffs)
• ResolvExpr/ConversionCost.cc (modified) (2 diffs)
• SynTree/BasicType.cc (modified) (1 diff)
• SynTree/Type.h (modified) (1 diff)

src/AST/Convert.cpp

@@ -1496 +1496 @@
                 getAccept1< ast::type, decltype( old->child ) >( old->child )
 
-#       define GET_ACCEPT_E(child, type) \
-                getAccept1< ast::type, decltype( old->base ) >( old->base )
 
         template<typename NewT, typename OldC>
@@ -1513 +1511 @@
 #       define GET_ACCEPT_V(child, type) \
                 getAcceptV< ast::type, decltype( old->child ) >( old->child )
+
+#       define GET_ACCEPT_E(child, type) \
+                getAccept1< ast::type, decltype( old->base ) >( old->base )
 
         template<typename NewT, typename OldC>
@@ -1714 +1715 @@
         }
 
-        // Marker
         // Convert SynTree::EnumDecl to AST::EnumDecl
         virtual void visit( const EnumDecl * old ) override final {
@@ -1723 +1723 @@
                         GET_ACCEPT_V(attributes, Attribute),
                         { old->linkage.val },
-                        old->base? GET_ACCEPT_E(base, Type) : nullptr,
+                        GET_ACCEPT_1(base, Type),
                         old->enumValues
                 );

src/CodeGen/GenType.cc

@@ -253 +253 @@
 
         void GenType::postvisit( EnumInstType * enumInst ) {
-                typeString = enumInst->name + " " + typeString;
-                if ( options.genC ) typeString = "enum " + typeString;
+                if ( enumInst->baseEnum->base 
+                && dynamic_cast<BasicType *>(enumInst->baseEnum->base)
+                && dynamic_cast<BasicType *>(enumInst->baseEnum->base)->kind != BasicType::Kind::SignedInt) {
+                        typeString = genType(enumInst->baseEnum->base, "", options) + typeString;
+                } else {
+                        typeString = enumInst->name + " " + typeString;
+                        if ( options.genC ) {
+                                typeString = "enum " + typeString;
+                        } 
+                } 
                 handleQualifiers( enumInst );
         }

src/Parser/TypeData.cc

@@ -918 +918 @@
 EnumDecl * buildEnum( const TypeData * td, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
         assert( td->kind == TypeData::Enum );
-        Type* baseType = td->base ? typebuild(td->base) : nullptr;
+        Type * baseType = td->base ? typebuild(td->base) : nullptr;
         EnumDecl * ret = new EnumDecl( *td->enumeration.name, attributes, linkage, baseType );
-        buildList( td->enumeration.constants, ret->get_members() ); // enumConstant is both a node and a list
+        buildList( td->enumeration.constants, ret->get_members() );
         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 ) {
@@ -926 +926 @@
                         ObjectDecl * member = dynamic_cast< ObjectDecl * >(* members);
                         member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ) ) );
+                } else {
+                        if ( baseType && (!dynamic_cast<BasicType *>(baseType) || !dynamic_cast<BasicType *>(baseType)->isWholeNumber())) {
+                                SemanticError( td->location, "A non whole number enum value decl must be explicitly initialized." );
+                        }
                 } // if
         } // for

src/ResolvExpr/ConversionCost.cc

@@ -333 +333 @@
                 } else if ( dynamic_cast< const EnumInstType * >( dest ) ) {
                         // xxx - not positive this is correct, but appears to allow casting int => enum
-                        cost = Cost::unsafe;
+                        // TODO
+                        EnumDecl * decl = dynamic_cast< const EnumInstType * >( dest )->baseEnum;
+                        if ( decl->base ) {
+                                cost = Cost::infinity;
+                        } else {
+                                cost = Cost::unsafe;
+                        } // if
                 } // if
                 // no cases for zero_t/one_t because it should not be possible to convert int, etc. to zero_t/one_t.
@@ -610 +616 @@
         } else if ( dynamic_cast< const ast::EnumInstType * >( dst ) ) {
                 // xxx - not positive this is correct, but appears to allow casting int => enum
-                cost = Cost::unsafe;
+                const ast::EnumDecl * decl = (dynamic_cast< const ast::EnumInstType * >( dst ))->base.get();
+                if ( decl->base ) {
+                        cost = Cost::infinity;
+                } else {
+                        cost = Cost::unsafe;
+                } // if
         }
 }

src/SynTree/BasicType.cc

@@ -29 +29 @@
 }
 
+bool BasicType::isWholeNumber() const {
+        return kind == Bool || 
+                kind ==Char ||
+                kind == SignedChar ||
+                kind == UnsignedChar ||
+                kind == ShortSignedInt ||
+                kind == ShortUnsignedInt ||
+                kind == SignedInt ||
+                kind == UnsignedInt ||
+                kind == LongSignedInt ||
+                kind == LongUnsignedInt ||
+                kind == LongLongSignedInt ||
+                kind ==LongLongUnsignedInt ||
+                kind == SignedInt128 ||
+                kind == UnsignedInt128;
+}
+
 bool BasicType::isInteger() const {
         return kind <= UnsignedInt128;

src/SynTree/Type.h

@@ -268 +268 @@
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
-
+        bool isWholeNumber() const;
         bool isInteger() const;
 };