Changeset ae267366 for src

Timestamp:

Feb 24, 2023, 3:31:50 PM (3 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, ast-experimental, master

Children:

2e77837

Parents:

f883ef1 (diff), f2a1cd2 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

fix merge conflict

Location:

src

Files:

• AST/Fwd.hpp (modified) (2 diffs)
• AST/Print.cpp (modified) (9 diffs)
• AST/Print.hpp (modified) (2 diffs)
• Parser/DeclarationNode.cc (modified) (8 diffs)
• Parser/ParseNode.h (modified) (3 diffs)
• Parser/TypeData.cc (modified) (2 diffs)
• Parser/TypeData.h (modified) (2 diffs)
• Parser/parser.yy (modified) (10 diffs)
• SynTree/Type.h (modified) (3 diffs)

src/AST/Fwd.hpp

@@ -15 +15 @@
 
 #pragma once
+
+template<typename> struct bitfield;
 
 #include "AST/Node.hpp"
@@ -147 +149 @@
 class TranslationGlobal;
 
+// For the following types, only use the using type.
+namespace CV {
+        struct qualifier_flags;
+        using Qualifiers = bitfield<qualifier_flags>;
 }
+namespace Function {
+        struct spec_flags;
+        using Specs = bitfield<spec_flags>;
+}
+namespace Storage {
+        struct class_flags;
+        using Classes = bitfield<class_flags>;
+}
+namespace Linkage {
+        struct spec_flags;
+        using Spec = bitfield<spec_flags>;
+}
+
+}

src/AST/Print.cpp

@@ -29 +29 @@
 namespace ast {
 
-template <typename C, typename... T>
-constexpr array<C,sizeof...(T)> make_array(T&&... values)
-{
-        return array<C,sizeof...(T)>{
-                std::forward<T>(values)...
-        };
+namespace {
+
+template<typename C, typename... T>
+constexpr array<C, sizeof...(T)> make_array( T&&... values ) {
+        return array<C, sizeof...(T)>{ std::forward<T>( values )... };
+}
+
+namespace Names {
+        static constexpr auto FuncSpecifiers = make_array<const char*>(
+                "inline", "_Noreturn", "fortran"
+        );
+
+        static constexpr auto StorageClasses = make_array<const char*>(
+                "extern", "static", "auto", "register", "__thread", "_Thread_local"
+        );
+
+        static constexpr auto Qualifiers = make_array<const char*>(
+                "const", "restrict", "volatile", "mutex", "_Atomic"
+        );
+}
+
+template<typename bits_t, size_t N>
+void print( ostream & os, const bits_t & bits,
+                const array<const char *, N> & names ) {
+        if ( !bits.any() ) return;
+        for ( size_t i = 0 ; i < N ; i += 1 ) {
+                if ( bits[i] ) {
+                        os << names[i] << ' ';
+                }
+        }
 }
 
@@ -80 +104 @@
         static const char* Names[];
 
-        struct Names {
-                static constexpr auto FuncSpecifiers = make_array<const char*>(
-                        "inline", "_Noreturn", "fortran"
-                );
-
-                static constexpr auto StorageClasses = make_array<const char*>(
-                        "extern", "static", "auto", "register", "__thread", "_Thread_local"
-                );
-
-                static constexpr auto Qualifiers = make_array<const char*>(
-                        "const", "restrict", "volatile", "mutex", "_Atomic"
-                );
-        };
-
-        template<typename storage_t, size_t N>
-        void print(const storage_t & storage, const array<const char *, N> & Names ) {
-                if ( storage.any() ) {
-                        for ( size_t i = 0; i < Names.size(); i += 1 ) {
-                                if ( storage[i] ) {
-                                        os << Names[i] << ' ';
-                                }
-                        }
-                }
-        }
-
-        void print( const ast::Function::Specs & specs ) {
-                print(specs, Names::FuncSpecifiers);
-        }
-
-        void print( const ast::Storage::Classes & storage ) {
-                print(storage, Names::StorageClasses);
-        }
-
-        void print( const ast::CV::Qualifiers & qualifiers ) {
-                print(qualifiers, Names::Qualifiers);
-        }
-
         void print( const std::vector<ast::Label> & labels ) {
                 if ( labels.empty() ) return;
@@ -230 +217 @@
                 }
 
-                print( node->storage );
+                ast::print( os, node->storage );
                 os << node->typeString();
 
@@ -272 +259 @@
 
         void preprint( const ast::Type * node ) {
-                print( node->qualifiers );
+                ast::print( os, node->qualifiers );
         }
 
@@ -278 +265 @@
                 print( node->forall );
                 print( node->assertions );
-                print( node->qualifiers );
+                ast::print( os, node->qualifiers );
         }
 
         void preprint( const ast::BaseInstType * node ) {
                 print( node->attributes );
-                print( node->qualifiers );
+                ast::print( os, node->qualifiers );
         }
 
@@ -294 +281 @@
                 }
 
-                print( node->storage );
+                ast::print( os, node->storage );
 
                 if ( node->type ) {
@@ -338 +325 @@
                 if ( ! short_mode ) printAll( node->attributes );
 
-                print( node->storage );
-                print( node->funcSpec );
-
-
+                ast::print( os, node->storage );
+                ast::print( os, node->funcSpec );
 
                 if ( node->type && node->isTypeFixed ) {
@@ -1627 +1612 @@
 };
 
+} // namespace
+
 void print( ostream & os, const ast::Node * node, Indenter indent ) {
         Printer printer { os, indent, false };
@@ -1637 +1624 @@
 }
 
-// Annoyingly these needed to be defined out of line to avoid undefined references.
-// The size here needs to be explicit but at least the compiler will produce an error
-// if the wrong size is specified
-constexpr array<const char*, 3> Printer::Names::FuncSpecifiers;
-constexpr array<const char*, 6> Printer::Names::StorageClasses;
-constexpr array<const char*, 5> Printer::Names::Qualifiers;
+void print( ostream & os, Function::Specs specs ) {
+        print( os, specs, Names::FuncSpecifiers );
 }
+
+void print( ostream & os, Storage::Classes storage ) {
+        print( os, storage, Names::StorageClasses );
+}
+
+void print( ostream & os, CV::Qualifiers qualifiers ) {
+        print( os, qualifiers, Names::Qualifiers );
+}
+
+} // namespace ast

src/AST/Print.hpp

@@ -16 +16 @@
 #pragma once
 
-#include <iostream>
-#include <utility>   // for forward
+#include <iosfwd>
 
-#include "AST/Node.hpp"
+#include "AST/Fwd.hpp"
 #include "Common/Indenter.h"
 
 namespace ast {
-
-class Decl;
 
 /// Print a node with the given indenter
@@ -44 +41 @@
 }
 
+/// Print each cv-qualifier used in the set, followed by a space.
+void print( std::ostream & os, CV::Qualifiers );
+/// Print each function specifier used in the set, followed by a space.
+void print( std::ostream & os, Function::Specs );
+/// Print each storage class used in the set, followed by a space.
+void print( std::ostream & os, Storage::Classes );
+
 }

src/Parser/DeclarationNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb 16 14:12:03 2023
-// Update Count     : 1388
+// Last Modified On : Fri Feb 24 11:10:03 2023
+// Update Count     : 1400
 //
 
@@ -61 +61 @@
         variable.initializer = nullptr;
 
-//      attr.name = nullptr;
-        attr.expr = nullptr;
-        attr.type = nullptr;
-
         assert.condition = nullptr;
         assert.message = nullptr;
@@ -70 +66 @@
 
 DeclarationNode::~DeclarationNode() {
-//      delete attr.name;
-        delete attr.expr;
-        delete attr.type;
-
 //      delete variable.name;
         delete variable.assertions;
@@ -115 +107 @@
         newnode->variable.initializer = maybeClone( variable.initializer );
 
-//      newnode->attr.name = attr.name ? new string( *attr.name ) : nullptr;
-        newnode->attr.expr = maybeClone( attr.expr );
-        newnode->attr.type = maybeClone( attr.type );
-
         newnode->assert.condition = maybeClone( assert.condition );
         newnode->assert.message = maybeClone( assert.message );
@@ -266 +254 @@
         newnode->type->enumeration.typed = typed;
         newnode->type->enumeration.hiding = hiding;
-        if ( base && base->type)  {
+        if ( base && base->type )  {
                 newnode->type->base = base->type;
         } // if
@@ -579 +567 @@
 
         checkQualifiers( type, q->type );
-        if ( (builtin == Zero || builtin == One) && q->type->qualifiers.val != 0 && error.length() == 0 ) {
+        if ( (builtin == Zero || builtin == One) && q->type->qualifiers.any() && error.length() == 0 ) {
                 SemanticWarning( yylloc, Warning::BadQualifiersZeroOne, Type::QualifiersNames[ilog2( q->type->qualifiers.val )], builtinTypeNames[builtin] );
         } // if
@@ -996 +984 @@
 
                         if ( DeclarationNode * extr = cur->extractAggregate() ) {
-                                // handle the case where a structure declaration is contained within an object or type declaration
+                                // Handle the case where a SUE declaration is contained within an object or type declaration.
+
+                                assert( cur->type );
+                                // Replace anonymous SUE name with typedef name to prevent anonymous naming problems across translation units.
+                                if ( cur->type->kind == TypeData::Symbolic && cur->type->symbolic.isTypedef ) {
+                                        assert( extr->type );
+                                        // Handle anonymous aggregates: typedef struct { int i; } foo
+                                        extr->type->qualifiers.reset();         // clear any CVs associated with the aggregate
+                                        if ( extr->type->kind == TypeData::Aggregate && extr->type->aggregate.anon ) {
+                                                delete extr->type->aggregate.name;
+                                                extr->type->aggregate.name = new string( "__anonymous_" + *cur->name );
+                                                extr->type->aggregate.anon = false;
+                                                assert( cur->type->base );
+                                                if ( cur->type->base ) {
+                                                        delete cur->type->base->aggInst.aggregate->aggregate.name;
+                                                        cur->type->base->aggInst.aggregate->aggregate.name = new string( "__anonymous_" + *cur->name );
+                                                        cur->type->base->aggInst.aggregate->aggregate.anon = false;
+                                                        cur->type->base->aggInst.aggregate->qualifiers.reset();
+                                                } // if
+                                        } // if
+                                        // Handle anonymous enumeration: typedef enum { A, B, C } foo
+                                        if ( extr->type->kind == TypeData::Enum && extr->type->enumeration.anon ) {
+                                                delete extr->type->enumeration.name;
+                                                extr->type->enumeration.name = new string( "__anonymous_" + *cur->name );
+                                                extr->type->enumeration.anon = false;
+                                                assert( cur->type->base );
+                                                if ( cur->type->base ) {
+                                                        delete cur->type->base->aggInst.aggregate->enumeration.name;
+                                                        cur->type->base->aggInst.aggregate->enumeration.name = new string( "__anonymous_" + *cur->name );
+                                                        cur->type->base->aggInst.aggregate->enumeration.anon = false;
+                                                } // if
+                                        } // if
+                                } // if
 
                                 Declaration * decl = extr->build();
@@ -1213 +1233 @@
         assert( type );
 
-        if ( attr.expr ) {
-                return new AttrType( buildQualifiers( type ), *name, attr.expr->build(), attributes );
-        } else if ( attr.type ) {
-                return new AttrType( buildQualifiers( type ), *name, attr.type->buildType(), attributes );
-        } // if
-
         switch ( type->kind ) {
           case TypeData::Enum:

src/Parser/ParseNode.h

@@ -10 +10 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Nov  2 21:27:07 2022
-// Update Count     : 939
+// Last Modified On : Sun Feb 19 09:02:37 2023
+// Update Count     : 940
 //
 
@@ -325 +325 @@
         Variable_t variable;
 
-        struct Attr_t {
-//              const std::string * name;
-                ExpressionNode * expr;
-                DeclarationNode * type;
-        };
-        Attr_t attr;
-
         struct StaticAssert_t {
                 ExpressionNode * condition;
@@ -343 +336 @@
 
         bool inLine = false;
-        bool enumInLine = false; 
+        bool enumInLine = false;
         Type::FuncSpecifiers funcSpecs;
         Type::StorageClasses storageClasses;

src/Parser/TypeData.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue May 10 22:36:52 2022
-// Update Count     : 677
+// Last Modified On : Sun Feb 19 11:00:46 2023
+// Update Count     : 679
 //
 
@@ -375 +375 @@
                 break;
           case Enum:
-                os << "enumeration ";
+                os << "enumeration " << *enumeration.name << endl;;
                 if ( enumeration.constants ) {
                         os << "with constants" << endl;

src/Parser/TypeData.h

@@ -10 +10 @@
 // Created On       : Sat May 16 15:18:36 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue May 10 22:18:49 2022
-// Update Count     : 203
+// Last Modified On : Fri Feb 24 14:25:02 2023
+// Update Count     : 205
 //
 
@@ -37 +37 @@
                 bool body;
                 bool anon;
-
                 bool tagged;
                 const std::string * parent = nullptr;
         };
 
-        struct AggInst_t {
+        struct AggInst_t {                                                                      // handles SUE
                 TypeData * aggregate = nullptr;
                 ExpressionNode * params = nullptr;

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb 14 21:11:39 2023
-// Update Count     : 5893
+// Last Modified On : Fri Feb 24 14:46:55 2023
+// Update Count     : 5983
 //
 
@@ -1941 +1941 @@
                         // if type_specifier is an anon aggregate => name 
                         typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname, "4" );
-                        $$ = $3->addType( $2 )->addTypedef();
+                        $$ = $3->addType( $2 )->addTypedef();           // watchout frees $2 and $3
                 }
         | typedef_declaration pop ',' push declarator
@@ -1983 +1983 @@
         | typedef_expression                                                            // deprecated GCC, naming expression type
         | sue_declaration_specifier
+                {
+                        assert( $1->type );
+                        if ( $1->type->qualifiers.any() ) {                     // CV qualifiers ?
+                                SemanticError( yylloc, "Useless type qualifier(s) in empty declaration." ); $$ = nullptr;
+                        }
+                        // enums are never empty declarations because there must have at least one enumeration.
+                        if ( $1->type->kind == TypeData::AggregateInst && $1->storageClasses.any() ) { // storage class ?
+                                SemanticError( yylloc, "Useless storage qualifier(s) in empty aggregate declaration." ); $$ = nullptr;
+                        }
+                }
         ;
 
@@ -2000 +2010 @@
         | sue_declaration_specifier invalid_types
                 {
-                        SemanticError( yylloc,
-                                                  ::toString( "Missing ';' after end of ",
-                                                                          $1->type->enumeration.name ? "enum" : AggregateDecl::aggrString( $1->type->aggregate.kind ),
-                                                                          " declaration" ) );
+                        SemanticError( yylloc, ::toString( "Missing ';' after end of ",
+                                $1->type->enumeration.name ? "enum" : AggregateDecl::aggrString( $1->type->aggregate.kind ),
+                                " declaration" ) );
                         $$ = nullptr;
                 }
@@ -2582 +2591 @@
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt '{' enumerator_list comma_opt '}'
                 {
-                        if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 )
+                        if ( $3->storageClasses.val != 0 || $3->type->qualifiers.any() )
                         { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
 
@@ -2593 +2602 @@
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt
                 {
-                        if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
+                        if ( $3->storageClasses.any() || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
                         typedefTable.makeTypedef( *$6 );
                 }
@@ -3052 +3061 @@
                 { $$ = DeclarationNode::newDirectiveStmt( new StatementNode( build_directive( $1 ) ) ); }
         | declaration
+                {
+                        // Variable declarations of anonymous types requires creating a unique type-name across multiple translation
+                        // unit, which is a dubious task, especially because C uses name rather than structural typing; hence it is
+                        // disallowed at the moment.
+                        if ( $1->linkage == LinkageSpec::Cforall && ! $1->storageClasses.is_static && $1->type && $1->type->kind == TypeData::AggregateInst ) {
+                                if ( $1->type->aggInst.aggregate->kind == TypeData::Enum && $1->type->aggInst.aggregate->enumeration.anon ) {
+                                        SemanticError( yylloc, "extern anonymous enumeration is currently unimplemented." ); $$ = nullptr;
+                                } else if ( $1->type->aggInst.aggregate->aggregate.anon ) { // handles struct or union
+                                        SemanticError( yylloc, "extern anonymous struct/union is currently unimplemented." ); $$ = nullptr;
+                                }
+                        }
+                }
         | IDENTIFIER IDENTIFIER
                 { IdentifierBeforeIdentifier( *$1.str, *$2.str, " declaration" ); $$ = nullptr; }
@@ -3097 +3118 @@
         | type_qualifier_list
                 {
-                        if ( $1->type->qualifiers.val ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
+                        if ( $1->type->qualifiers.any() ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
                         if ( $1->type->forall ) forall = true;          // remember generic type
                 }
@@ -3108 +3129 @@
         | declaration_qualifier_list
                 {
-                        if ( $1->type && $1->type->qualifiers.val ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
+                        if ( $1->type && $1->type->qualifiers.any() ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
                         if ( $1->type && $1->type->forall ) forall = true; // remember generic type
                 }
@@ -3119 +3140 @@
         | declaration_qualifier_list type_qualifier_list
                 {
-                        if ( ($1->type && $1->type->qualifiers.val) || ($2->type && $2->type->qualifiers.val) ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
+                        if ( ($1->type && $1->type->qualifiers.any()) || ($2->type && $2->type->qualifiers.any()) ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
                         if ( ($1->type && $1->type->forall) || ($2->type && $2->type->forall) ) forall = true; // remember generic type
                 }

src/SynTree/Type.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Feb 13 17:13:52 2023
-// Update Count     : 173
+// Last Modified On : Sun Feb 19 22:37:10 2023
+// Update Count     : 176
 //
 
@@ -125 +125 @@
                 bool operator!=( Qualifiers other ) const { return (val & Mask) != (other.val & Mask); }
                 bool operator<=( Qualifiers other ) const {
-                        return is_const    <= other.is_const        //Any non-const converts to const without cost
-                                        && is_volatile <= other.is_volatile     //Any non-volatile converts to volatile without cost
-                                        && is_mutex    >= other.is_mutex        //Any mutex converts to non-mutex without cost
-                                        && is_atomic   == other.is_atomic;      //No conversion from atomic to non atomic is free
+                        return is_const    <= other.is_const        // Any non-const converts to const without cost
+                                && is_volatile <= other.is_volatile             // Any non-volatile converts to volatile without cost
+                                && is_mutex    >= other.is_mutex                // Any mutex converts to non-mutex without cost
+                                && is_atomic   == other.is_atomic;              // No conversion from atomic to non atomic is free
                 }
                 bool operator<( Qualifiers other ) const { return *this != other && *this <= other; }
@@ -632 +632 @@
 class TypeofType : public Type {
   public:
-        Expression * expr;    ///< expression to take the type of
-        bool is_basetypeof;  ///< true iff is basetypeof type
+        Expression * expr;              ///< expression to take the type of
+        bool is_basetypeof;             ///< true iff is basetypeof type
 
         TypeofType( const Type::Qualifiers & tq, Expression * expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );