Changeset 5407cdc for src

Timestamp:

Apr 28, 2021, 4:56:50 PM (4 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

8d66610

Parents:

feacef9 (diff), b7fd2db6 (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:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src

Files:

• AST/Convert.cpp (modified) (3 diffs)
• AST/Decl.hpp (modified) (2 diffs)
• AST/Expr.cpp (modified) (1 diff)
• AST/Expr.hpp (modified) (1 diff)
• AST/Fwd.hpp (modified) (2 diffs)
• AST/Node.cpp (modified) (2 diffs)
• AST/Pass.hpp (modified) (1 diff)
• AST/Pass.impl.hpp (modified) (1 diff)
• AST/Print.cpp (modified) (1 diff)
• AST/Type.cpp (modified) (3 diffs)
• AST/Visitor.hpp (modified) (2 diffs)
• CodeGen/CodeGenerator.cc (modified) (2 diffs)
• CodeGen/CodeGenerator.h (modified) (2 diffs)
• Common/CodeLocationTools.cpp (modified) (2 diffs)
• Common/PassVisitor.h (modified) (2 diffs)
• Common/PassVisitor.impl.h (modified) (1 diff)
• Concurrency/Keywords.cc (modified) (10 diffs)
• Parser/DeclarationNode.cc (modified) (10 diffs)
• Parser/ParseNode.h (modified) (3 diffs)
• Parser/TypeData.h (modified) (3 diffs)
• Parser/TypedefTable.cc (modified) (2 diffs)
• Parser/lex.ll (modified) (6 diffs)
• Parser/parser.yy (modified) (53 diffs)
• ResolvExpr/CurrentObject.cc (modified) (1 diff)
• SynTree/Constant.cc (modified) (1 diff)
• SynTree/Constant.h (modified) (1 diff)
• SynTree/Declaration.cc (modified) (2 diffs)
• SynTree/Declaration.h (modified) (2 diffs)
• SynTree/Mutator.h (modified) (2 diffs)
• SynTree/SynTree.h (modified) (2 diffs)
• SynTree/Visitor.h (modified) (2 diffs)
• Virtual/ExpandCasts.cc (modified) (7 diffs)
• Virtual/Tables.cc (modified) (8 diffs)
• Virtual/Tables.h (modified) (3 diffs)
• main.cc (modified) (12 diffs)

src/AST/Convert.cpp

@@ -9 +9 @@
 // Author           : Thierry Delisle
 // Created On       : Thu May 09 15::37::05 2019
-// Last Modified By : Andrew Beach
-// Last Modified On : Thr Nov 12 10:07:00 2020
-// Update Count     : 34
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Mar 12 18:43:51 2021
+// Update Count     : 36
 //
 
@@ -327 +327 @@
         const ast::AsmDecl * visit( const ast::AsmDecl * node ) override final {
                 auto decl = new AsmDecl( get<AsmStmt>().accept1( node->stmt ) );
+                declPostamble( decl, node );
+                return nullptr;
+        }
+
+        const ast::DirectiveDecl * visit( const ast::DirectiveDecl * node ) override final {
+                auto decl = new DirectiveDecl( get<DirectiveStmt>().accept1( node->stmt ) );
                 declPostamble( decl, node );
                 return nullptr;
@@ -1769 +1775 @@
         }
 
+        virtual void visit( const DirectiveDecl * old ) override final {
+                auto decl = new ast::DirectiveDecl{
+                        old->location,
+                        GET_ACCEPT_1(stmt, DirectiveStmt)
+                };
+                decl->extension  = old->extension;
+                decl->uniqueId   = old->uniqueId;
+                decl->storage    = { old->storageClasses.val };
+
+                this->node = decl;
+        }
+
         virtual void visit( const StaticAssertDecl * old ) override final {
                 auto decl = new ast::StaticAssertDecl{

src/AST/Decl.hpp

@@ -10 +10 @@
 // Created On       : Thu May 9 10:00:00 2019
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jan 11 20:48:38 2021
-// Update Count     : 30
+// Last Modified On : Fri Mar 12 18:25:05 2021
+// Update Count     : 32
 //
 
@@ -365 +365 @@
 };
 
+/// C-preprocessor directive `#...`
+class DirectiveDecl : public Decl {
+public:
+        ptr<DirectiveStmt> stmt;
+
+        DirectiveDecl( const CodeLocation & loc, DirectiveStmt * stmt )
+        : Decl( loc, "", {}, {} ), stmt(stmt) {}
+
+        const DirectiveDecl * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        DirectiveDecl * clone() const override { return new DirectiveDecl( *this ); }
+        MUTATE_FRIEND
+};
+
 class StaticAssertDecl : public Decl {
 public:

src/AST/Expr.cpp

@@ -260 +260 @@
 }
 
+ConstantExpr * ConstantExpr::from_string( const CodeLocation & loc, const std::string & str ) {
+        const Type * charType = new BasicType( BasicType::Char );
+        // Adjust the length of the string for the terminator.
+        const Expr * strSize = from_ulong( loc, str.size() + 1 );
+        const Type * strType = new ArrayType( charType, strSize, FixedLen, StaticDim );
+        const std::string strValue = "\"" + str + "\"";
+        return new ConstantExpr( loc, strType, strValue, std::nullopt );
+}
+
 ConstantExpr * ConstantExpr::null( const CodeLocation & loc, const Type * ptrType ) {
         return new ConstantExpr{

src/AST/Expr.hpp

@@ -438 +438 @@
         long long int intValue() const;
 
-        /// generates a boolean constant of the given bool
+        /// Generates a boolean constant of the given bool.
         static ConstantExpr * from_bool( const CodeLocation & loc, bool b );
-        /// generates an integer constant of the given int
+        /// Generates an integer constant of the given int.
         static ConstantExpr * from_int( const CodeLocation & loc, int i );
-        /// generates an integer constant of the given unsigned long int
+        /// Generates an integer constant of the given unsigned long int.
         static ConstantExpr * from_ulong( const CodeLocation & loc, unsigned long i );
-        /// generates a null pointer value for the given type. void * if omitted.
+        /// Generates a string constant from the given string (char type, unquoted string).
+        static ConstantExpr * from_string( const CodeLocation & loc, const std::string & string );
+        /// Generates a null pointer value for the given type. void * if omitted.
         static ConstantExpr * null( const CodeLocation & loc, const Type * ptrType = nullptr );
 

src/AST/Fwd.hpp

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Wed May  8 16:05:00 2019
-// Last Modified By : Andrew Beach
-// Last Modified On : Thr Jul 23 14:15:00 2020
-// Update Count     : 2
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Mar 12 18:37:39 2021
+// Update Count     : 4
 //
 
@@ -35 +35 @@
 class TypedefDecl;
 class AsmDecl;
+class DirectiveDecl;
 class StaticAssertDecl;
 

src/AST/Node.cpp

@@ -9 +9 @@
 // Author           : Thierry Delisle
 // Created On       : Thu May 16 14:16:00 2019
-// Last Modified By : Andrew Beach
-// Last Modified On : Fri Jun  5 10:21:00 2020
-// Update Count     : 1
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Mar 12 18:25:06 2021
+// Update Count     : 2
 //
 
@@ -130 +130 @@
 template class ast::ptr_base< ast::AsmDecl, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::AsmDecl, ast::Node::ref_type::strong >;
+template class ast::ptr_base< ast::DirectiveDecl, ast::Node::ref_type::weak >;
+template class ast::ptr_base< ast::DirectiveDecl, ast::Node::ref_type::strong >;
 template class ast::ptr_base< ast::StaticAssertDecl, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::StaticAssertDecl, ast::Node::ref_type::strong >;

src/AST/Pass.hpp

@@ -139 +139 @@
         const ast::Decl *             visit( const ast::TypedefDecl          * ) override final;
         const ast::AsmDecl *          visit( const ast::AsmDecl              * ) override final;
+        const ast::DirectiveDecl *    visit( const ast::DirectiveDecl        * ) override final;
         const ast::StaticAssertDecl * visit( const ast::StaticAssertDecl     * ) override final;
         const ast::CompoundStmt *     visit( const ast::CompoundStmt         * ) override final;

src/AST/Pass.impl.hpp

@@ -646 +646 @@
 
 //--------------------------------------------------------------------------
+// DirectiveDecl
+template< typename core_t >
+const ast::DirectiveDecl * ast::Pass< core_t >::visit( const ast::DirectiveDecl * node ) {
+        VISIT_START( node );
+
+        VISIT(
+                maybe_accept( node, &DirectiveDecl::stmt );
+        )
+
+        VISIT_END( DirectiveDecl, node );
+}
+
+//--------------------------------------------------------------------------
 // StaticAssertDecl
 template< typename core_t >

src/AST/Print.cpp

@@ -387 +387 @@
 
         virtual const ast::AsmDecl * visit( const ast::AsmDecl * node ) override final {
+                safe_print( node->stmt );
+                return node;
+        }
+
+        virtual const ast::DirectiveDecl * visit( const ast::DirectiveDecl * node ) override final {
                 safe_print( node->stmt );
                 return node;

src/AST/Type.cpp

@@ -105 +105 @@
 }
 
+// --- BaseInstType
+
 std::vector<readonly<Decl>> BaseInstType::lookup( const std::string& name ) const {
         assertf( aggr(), "Must have aggregate to perform lookup" );
@@ -119 +121 @@
 template<typename decl_t>
 SueInstType<decl_t>::SueInstType(
-        const decl_t * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
-: BaseInstType( b->name, q, move(as) ), base( b ) {}
+        const base_type * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
+: BaseInstType( b->name, q, std::move(as) ), base( b ) {}
 
 template<typename decl_t>
@@ -142 +144 @@
         const TraitDecl * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
 : BaseInstType( b->name, q, move(as) ), base( b ) {}
+
+// --- TypeInstType
 
 void TypeInstType::set_base( const TypeDecl * b ) {

src/AST/Visitor.hpp

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Thr May 9 15:28:00 2019
-// Last Modified By : Andrew Beach
-// Last Modified On : Thr May 9 15:33:00 2019
-// Update Count     : 0
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Mar 12 18:25:07 2021
+// Update Count     : 1
 //
 
@@ -31 +31 @@
     virtual const ast::Decl *             visit( const ast::TypedefDecl          * ) = 0;
     virtual const ast::AsmDecl *          visit( const ast::AsmDecl              * ) = 0;
+    virtual const ast::DirectiveDecl *    visit( const ast::DirectiveDecl        * ) = 0;
     virtual const ast::StaticAssertDecl * visit( const ast::StaticAssertDecl     * ) = 0;
     virtual const ast::CompoundStmt *     visit( const ast::CompoundStmt         * ) = 0;

src/CodeGen/CodeGenerator.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Feb 16 08:32:48 2020
-// Update Count     : 532
+// Last Modified On : Fri Mar 12 19:00:42 2021
+// Update Count     : 536
 //
 #include "CodeGenerator.h"
@@ -935 +935 @@
                 if ( asmStmt->get_instruction() ) asmStmt->get_instruction()->accept( *visitor );
                 output << " )";
+        }
+
+        void CodeGenerator::postvisit( DirectiveDecl * directiveDecl ) {
+                output << endl << directiveDecl->get_stmt()->directive; // endl prevents spaces before directive
         }
 

src/CodeGen/CodeGenerator.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Feb 16 03:58:31 2020
-// Update Count     : 62
+// Last Modified On : Fri Mar 12 18:35:38 2021
+// Update Count     : 63
 //
 
@@ -105 +105 @@
                 void postvisit( DirectiveStmt * );
                 void postvisit( AsmDecl * );                                    // special: statement in declaration context
+                void postvisit( DirectiveDecl * );                              // special: statement in declaration context
                 void postvisit( IfStmt * );
                 void postvisit( SwitchStmt * );

src/Common/CodeLocationTools.cpp

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Fri Dec  4 15:42:00 2020
-// Last Modified By : Andrew Beach
-// Last Modified On : Wed Dec  9  9:42:00 2020
-// Update Count     : 1
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Mar 12 18:35:37 2021
+// Update Count     : 2
 //
 
@@ -102 +102 @@
     macro(TypedefDecl, Decl) \
     macro(AsmDecl, AsmDecl) \
+    macro(DirectiveDecl, DirectiveDecl) \
     macro(StaticAssertDecl, StaticAssertDecl) \
     macro(CompoundStmt, CompoundStmt) \

src/Common/PassVisitor.h

@@ -77 +77 @@
         virtual void visit( AsmDecl * asmDecl ) override final;
         virtual void visit( const AsmDecl * asmDecl ) override final;
+        virtual void visit( DirectiveDecl * directiveDecl ) override final;
+        virtual void visit( const DirectiveDecl * directiveDecl ) override final;
         virtual void visit( StaticAssertDecl * assertDecl ) override final;
         virtual void visit( const StaticAssertDecl * assertDecl ) override final;
@@ -261 +263 @@
         virtual Declaration * mutate( TypedefDecl * typeDecl ) override final;
         virtual AsmDecl * mutate( AsmDecl * asmDecl ) override final;
+        virtual DirectiveDecl * mutate( DirectiveDecl * directiveDecl ) override final;
         virtual StaticAssertDecl * mutate( StaticAssertDecl * assertDecl ) override final;
 

src/Common/PassVisitor.impl.h

@@ -973 +973 @@
 
 //--------------------------------------------------------------------------
+// DirectiveDecl
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( DirectiveDecl * node ) {
+        VISIT_START( node );
+
+        maybeAccept_impl( node->stmt, *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( const DirectiveDecl * node ) {
+        VISIT_START( node );
+
+        maybeAccept_impl( node->stmt, *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+DirectiveDecl * PassVisitor< pass_type >::mutate( DirectiveDecl * node ) {
+        MUTATE_START( node );
+
+        maybeMutate_impl( node->stmt, *this );
+
+        MUTATE_END( DirectiveDecl, node );
+}
+
+//--------------------------------------------------------------------------
 // StaticAssertDecl
 template< typename pass_type >

src/Concurrency/Keywords.cc

@@ -42 +42 @@
 
 namespace Concurrency {
+        inline static std::string getTypeIdName( std::string const & exception_name ) {
+                return exception_name.empty() ? std::string() : Virtual::typeIdType( exception_name );
+        }
         inline static std::string getVTableName( std::string const & exception_name ) {
-                return exception_name.empty() ? std::string() : Virtual::vtableTypeName(exception_name);
+                return exception_name.empty() ? std::string() : Virtual::vtableTypeName( exception_name );
         }
 
@@ -75 +78 @@
                   type_name( type_name ), field_name( field_name ), getter_name( getter_name ),
                   context_error( context_error ), exception_name( exception_name ),
+                  typeid_name( getTypeIdName( exception_name ) ),
                   vtable_name( getVTableName( exception_name ) ),
                   needs_main( needs_main ), cast_target( cast_target ) {}
@@ -84 +88 @@
 
                 void handle( StructDecl * );
+                void addTypeId( StructDecl * );
                 void addVtableForward( StructDecl * );
                 FunctionDecl * forwardDeclare( StructDecl * );
@@ -99 +104 @@
                 const std::string context_error;
                 const std::string exception_name;
+                const std::string typeid_name;
                 const std::string vtable_name;
                 bool needs_main;
@@ -106 +112 @@
                 FunctionDecl * dtor_decl = nullptr;
                 StructDecl * except_decl = nullptr;
+                StructDecl * typeid_decl = nullptr;
                 StructDecl * vtable_decl = nullptr;
         };
@@ -393 +400 @@
                         except_decl = decl;
                 }
+                else if ( !typeid_decl && typeid_name == decl->name && decl->body ) {
+                        typeid_decl = decl;
+                }
                 else if ( !vtable_decl && vtable_name == decl->name && decl->body ) {
                         vtable_decl = decl;
@@ -404 +414 @@
                 if ( type_decl && isDestructorFor( decl, type_decl ) )
                         dtor_decl = decl;
-                else if ( vtable_name.empty() )
-                        ;
-                else if( !decl->has_body() )
+                else if ( vtable_name.empty() || !decl->has_body() )
                         ;
                 else if ( auto param = isMainFor( decl, cast_target ) ) {
@@ -418 +426 @@
                         std::list< Expression * > poly_args = { new TypeExpr( struct_type->clone() ) };
                         ObjectDecl * vtable_object = Virtual::makeVtableInstance(
+                                "_default_vtable_object_declaration",
                                 vtable_decl->makeInst( poly_args ), struct_type, nullptr );
                         declsToAddAfter.push_back( vtable_object );
+                        declsToAddAfter.push_back(
+                                new ObjectDecl(
+                                        Virtual::concurrentDefaultVTableName(),
+                                        Type::Const,
+                                        LinkageSpec::Cforall,
+                                        /* bitfieldWidth */ nullptr,
+                                        new ReferenceType( Type::Const, vtable_object->type->clone() ),
+                                        new SingleInit( new VariableExpr( vtable_object ) )
+                                )
+                        );
                         declsToAddAfter.push_back( Virtual::makeGetExceptionFunction(
                                 vtable_object, except_decl->makeInst( std::move( poly_args ) )
@@ -448 +467 @@
                 if( !dtor_decl ) SemanticError( decl, context_error );
 
-                addVtableForward( decl );
+                if ( !exception_name.empty() ) {
+                        if( !typeid_decl ) SemanticError( decl, context_error );
+                        if( !vtable_decl ) SemanticError( decl, context_error );
+
+                        addTypeId( decl );
+                        addVtableForward( decl );
+                }
                 FunctionDecl * func = forwardDeclare( decl );
                 ObjectDecl * field = addField( decl );
@@ -454 +479 @@
         }
 
+        void ConcurrentSueKeyword::addTypeId( StructDecl * decl ) {
+                assert( typeid_decl );
+                StructInstType typeid_type( Type::Const, typeid_decl );
+                typeid_type.parameters.push_back( new TypeExpr(
+                        new StructInstType( noQualifiers, decl )
+                        ) );
+                declsToAddBefore.push_back( Virtual::makeTypeIdInstance( &typeid_type ) );
+        }
+
         void ConcurrentSueKeyword::addVtableForward( StructDecl * decl ) {
-                if ( vtable_decl ) {
-                        std::list< Expression * > poly_args = {
-                                new TypeExpr( new StructInstType( noQualifiers, decl ) ),
-                        };
-                        declsToAddBefore.push_back( Virtual::makeGetExceptionForward(
-                                vtable_decl->makeInst( poly_args ),
-                                except_decl->makeInst( poly_args )
-                        ) );
-                        declsToAddBefore.push_back( Virtual::makeVtableForward(
-                                vtable_decl->makeInst( move( poly_args ) ) ) );
-                // Its only an error if we want a vtable and don't have one.
-                } else if ( ! vtable_name.empty() ) {
-                        SemanticError( decl, context_error );
-                }
+                assert( vtable_decl );
+                std::list< Expression * > poly_args = {
+                        new TypeExpr( new StructInstType( noQualifiers, decl ) ),
+                };
+                declsToAddBefore.push_back( Virtual::makeGetExceptionForward(
+                        vtable_decl->makeInst( poly_args ),
+                        except_decl->makeInst( poly_args )
+                ) );
+                ObjectDecl * vtable_object = Virtual::makeVtableForward(
+                        "_default_vtable_object_declaration",
+                        vtable_decl->makeInst( move( poly_args ) ) );
+                declsToAddBefore.push_back( vtable_object );
+                declsToAddBefore.push_back(
+                        new ObjectDecl(
+                                Virtual::concurrentDefaultVTableName(),
+                                Type::Const,
+                                LinkageSpec::Cforall,
+                                /* bitfieldWidth */ nullptr,
+                                new ReferenceType( Type::Const, vtable_object->type->clone() ),
+                                /* init */ nullptr
+                        )
+                );
         }
 

src/Parser/DeclarationNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jan 11 20:58:07 2021
-// Update Count     : 1137
+// Last Modified On : Tue Mar 23 08:44:08 2021
+// Update Count     : 1149
 //
 
@@ -167 +167 @@
 }
 
-DeclarationNode * DeclarationNode::newFunction( const string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body ) {
-        DeclarationNode * newnode = new DeclarationNode;
-        newnode->name = name;
-        newnode->type = new TypeData( TypeData::Function );
-        newnode->type->function.params = param;
-        newnode->type->function.body = body;
-
-        if ( ret ) {
-                newnode->type->base = ret->type;
-                ret->type = nullptr;
-                delete ret;
-        } // if
-
-        return newnode;
-} // DeclarationNode::newFunction
-
-
 DeclarationNode * DeclarationNode::newStorageClass( Type::StorageClasses sc ) {
         DeclarationNode * newnode = new DeclarationNode;
@@ -237 +220 @@
         return newnode;
 } // DeclarationNode::newForall
-
-DeclarationNode * DeclarationNode::newFromTypedef( const string * name ) {
-        DeclarationNode * newnode = new DeclarationNode;
-        newnode->type = new TypeData( TypeData::SymbolicInst );
-        newnode->type->symbolic.name = name;
-        newnode->type->symbolic.isTypedef = true;
-        newnode->type->symbolic.params = nullptr;
-        return newnode;
-} // DeclarationNode::newFromTypedef
 
 DeclarationNode * DeclarationNode::newFromGlobalScope() {
@@ -289 +263 @@
 } // DeclarationNode::newEnum
 
+DeclarationNode * DeclarationNode::newName( const string * name ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        assert( ! newnode->name );
+        newnode->name = name;
+        return newnode;
+} // DeclarationNode::newName
+
 DeclarationNode * DeclarationNode::newEnumConstant( const string * name, ExpressionNode * constant ) {
-        DeclarationNode * newnode = new DeclarationNode;
-        newnode->name = name;
+        DeclarationNode * newnode = newName( name );
         newnode->enumeratorValue.reset( constant );
         return newnode;
 } // DeclarationNode::newEnumConstant
 
-DeclarationNode * DeclarationNode::newName( const string * name ) {
-        DeclarationNode * newnode = new DeclarationNode;
-        newnode->name = name;
-        return newnode;
-} // DeclarationNode::newName
+DeclarationNode * DeclarationNode::newFromTypedef( const string * name ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->type = new TypeData( TypeData::SymbolicInst );
+        newnode->type->symbolic.name = name;
+        newnode->type->symbolic.isTypedef = true;
+        newnode->type->symbolic.params = nullptr;
+        return newnode;
+} // DeclarationNode::newFromTypedef
 
 DeclarationNode * DeclarationNode::newFromTypeGen( const string * name, ExpressionNode * params ) {
@@ -312 +295 @@
 
 DeclarationNode * DeclarationNode::newTypeParam( TypeDecl::Kind tc, const string * name ) {
-        DeclarationNode * newnode = new DeclarationNode;
+        DeclarationNode * newnode = newName( name );
         newnode->type = nullptr;
-        assert( ! newnode->name );
-//      newnode->variable.name = name;
-        newnode->name = name;
         newnode->variable.tyClass = tc;
         newnode->variable.assertions = nullptr;
@@ -343 +323 @@
 
 DeclarationNode * DeclarationNode::newTypeDecl( const string * name, DeclarationNode * typeParams ) {
-        DeclarationNode * newnode = new DeclarationNode;
-        newnode->name = name;
+        DeclarationNode * newnode = newName( name );
         newnode->type = new TypeData( TypeData::Symbolic );
         newnode->type->symbolic.isTypedef = false;
@@ -417 +396 @@
 } // DeclarationNode::newBuiltinType
 
+DeclarationNode * DeclarationNode::newFunction( const string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body ) {
+        DeclarationNode * newnode = newName( name );
+        newnode->type = new TypeData( TypeData::Function );
+        newnode->type->function.params = param;
+        newnode->type->function.body = body;
+
+        if ( ret ) {
+                newnode->type->base = ret->type;
+                ret->type = nullptr;
+                delete ret;
+        } // if
+
+        return newnode;
+} // DeclarationNode::newFunction
+
 DeclarationNode * DeclarationNode::newAttribute( const string * name, ExpressionNode * expr ) {
         DeclarationNode * newnode = new DeclarationNode;
@@ -424 +418 @@
         newnode->attributes.push_back( new Attribute( *name, exprs ) );
         delete name;
+        return newnode;
+}
+
+DeclarationNode * DeclarationNode::newDirectiveStmt( StatementNode * stmt ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->directiveStmt = stmt;
         return newnode;
 }
@@ -879 +879 @@
 }
 
-DeclarationNode * DeclarationNode::cloneType( string * newName ) {
-        DeclarationNode * newnode = new DeclarationNode;
+DeclarationNode * DeclarationNode::cloneType( string * name ) {
+        DeclarationNode * newnode = newName( name );
         newnode->type = maybeClone( type );
         newnode->copySpecifiers( this );
-        assert( newName );
-        newnode->name = newName;
         return newnode;
 }
@@ -1072 +1070 @@
                 return new AsmDecl( strict_dynamic_cast<AsmStmt *>( asmStmt->build() ) );
         } // if
+        if ( directiveStmt ) {
+                return new DirectiveDecl( strict_dynamic_cast<DirectiveStmt *>( directiveStmt->build() ) );
+        } // if
 
         if ( variable.tyClass != TypeDecl::NUMBER_OF_KINDS ) {

src/Parser/ParseNode.h

@@ -10 +10 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Jan  3 18:23:01 2021
-// Update Count     : 896
+// Last Modified On : Fri Mar 12 15:19:04 2021
+// Update Count     : 897
 //
 
@@ -249 +249 @@
         static DeclarationNode * newTypeof( ExpressionNode * expr, bool basetypeof = false );
         static DeclarationNode * newAttribute( const std::string *, ExpressionNode * expr = nullptr ); // gcc attributes
+        static DeclarationNode * newDirectiveStmt( StatementNode * stmt ); // gcc external directive statement
         static DeclarationNode * newAsmStmt( StatementNode * stmt ); // gcc external asm statement
         static DeclarationNode * newStaticAssert( ExpressionNode * condition, Expression * message );
@@ -345 +346 @@
         std::string error;
         StatementNode * asmStmt = nullptr;
+        StatementNode * directiveStmt = nullptr;
 
         static UniqueName anonymous;

src/Parser/TypeData.h

@@ -7 +7 @@
 // TypeData.h --
 //
-// Author           : Rodolfo G. Esteves
+// Author           : Peter A. Buhr
 // Created On       : Sat May 16 15:18:36 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Dec 13 23:42:35 2019
-// Update Count     : 199
+// Last Modified On : Sat Mar 27 09:05:35 2021
+// Update Count     : 200
 //
 
 #pragma once
 
-#include <iosfwd>                // for ostream
-#include <list>                  // for list
-#include <string>                // for string
+#include <iosfwd>                                                                               // for ostream
+#include <list>                                                                                 // for list
+#include <string>                                                                               // for string
 
-#include "ParseNode.h"           // for DeclarationNode, DeclarationNode::Ag...
-#include "SynTree/LinkageSpec.h" // for Spec
-#include "SynTree/Type.h"        // for Type, ReferenceToType (ptr only)
-#include "SynTree/SynTree.h"     // for Visitor Nodes
+#include "ParseNode.h"                                                                  // for DeclarationNode, DeclarationNode::Ag...
+#include "SynTree/LinkageSpec.h"                                                // for Spec
+#include "SynTree/Type.h"                                                               // for Type, ReferenceToType (ptr only)
+#include "SynTree/SynTree.h"                                                    // for Visitor Nodes
 
 struct TypeData {
@@ -33 +33 @@
                 const std::string * name = nullptr;
                 DeclarationNode * params = nullptr;
-                ExpressionNode * actuals = nullptr;                                             // holds actual parameters later applied to AggInst
+                ExpressionNode * actuals = nullptr;                             // holds actual parameters later applied to AggInst
                 DeclarationNode * fields = nullptr;
                 bool body;
@@ -62 +62 @@
 
         struct Function_t {
-                mutable DeclarationNode * params = nullptr;                             // mutables modified in buildKRFunction
-                mutable DeclarationNode * idList = nullptr;                             // old-style
+                mutable DeclarationNode * params = nullptr;             // mutables modified in buildKRFunction
+                mutable DeclarationNode * idList = nullptr;             // old-style
                 mutable DeclarationNode * oldDeclList = nullptr;
                 StatementNode * body = nullptr;
-                ExpressionNode * withExprs = nullptr;                                           // expressions from function's with_clause
+                ExpressionNode * withExprs = nullptr;                   // expressions from function's with_clause
         };
 

src/Parser/TypedefTable.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 15:20:13 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Feb 15 08:06:36 2020
-// Update Count     : 259
+// Last Modified On : Mon Mar 15 20:56:47 2021
+// Update Count     : 260
 //
 
@@ -89 +89 @@
         debugPrint( cerr << "Adding enclosing at " << locn << " " << identifier << " as " << kindName( kind ) << " scope " << scope << " level " << level << " note " << kindTable.getNote( kindTable.currentScope() - 1 ).level << endl );
         auto ret = kindTable.insertAt( scope, identifier, kind );
-        if ( ! ret.second ) ret.first->second = kind;   // exists => update
+        if ( ! ret.second ) ret.first->second = kind;           // exists => update
 } // TypedefTable::addToEnclosingScope
 

src/Parser/lex.ll

@@ -10 +10 @@
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
- * Last Modified On : Tue Oct  6 18:15:41 2020
- * Update Count     : 743
+ * Last Modified On : Thu Apr  1 13:22:31 2021
+ * Update Count     : 754
  */
 
@@ -221 +221 @@
 break                   { KEYWORD_RETURN(BREAK); }
 case                    { KEYWORD_RETURN(CASE); }
-catch                   { KEYWORD_RETURN(CATCH); }                              // CFA
-catchResume             { KEYWORD_RETURN(CATCHRESUME); }                // CFA
+catch                   { QKEYWORD_RETURN(CATCH); }                             // CFA
+catchResume             { QKEYWORD_RETURN(CATCHRESUME); }               // CFA
 char                    { KEYWORD_RETURN(CHAR); }
 choose                  { KEYWORD_RETURN(CHOOSE); }                             // CFA
@@ -247 +247 @@
 fallthrough             { KEYWORD_RETURN(FALLTHROUGH); }                // CFA
 fallthru                { KEYWORD_RETURN(FALLTHRU); }                   // CFA
-finally                 { KEYWORD_RETURN(FINALLY); }                    // CFA
+finally                 { QKEYWORD_RETURN(FINALLY); }                   // CFA
+fixup                   { QKEYWORD_RETURN(FIXUP); }                             // CFA
 float                   { KEYWORD_RETURN(FLOAT); }
 __float80               { KEYWORD_RETURN(uuFLOAT80); }                  // GCC
@@ -287 +288 @@
 or                              { QKEYWORD_RETURN(WOR); }                               // CFA
 otype                   { KEYWORD_RETURN(OTYPE); }                              // CFA
+recover                 { QKEYWORD_RETURN(RECOVER); }                   // CFA
 register                { KEYWORD_RETURN(REGISTER); }
+report                  { KEYWORD_RETURN(THROWRESUME); }                // CFA
 restrict                { KEYWORD_RETURN(RESTRICT); }                   // C99
 __restrict              { KEYWORD_RETURN(RESTRICT); }                   // GCC
@@ -315 +318 @@
 __typeof                { KEYWORD_RETURN(TYPEOF); }                             // GCC
 __typeof__              { KEYWORD_RETURN(TYPEOF); }                             // GCC
+typeid                  { KEYWORD_RETURN(TYPEID); }                             // GCC
 union                   { KEYWORD_RETURN(UNION); }
 __uint128_t             { KEYWORD_RETURN(UINT128); }                    // GCC
@@ -324 +328 @@
 __volatile              { KEYWORD_RETURN(VOLATILE); }                   // GCC
 __volatile__    { KEYWORD_RETURN(VOLATILE); }                   // GCC
-waitfor                 { KEYWORD_RETURN(WAITFOR); }
-when                    { KEYWORD_RETURN(WHEN); }
+vtable                  { KEYWORD_RETURN(VTABLE); }                             // CFA
+waitfor                 { KEYWORD_RETURN(WAITFOR); }                    // CFA
+when                    { KEYWORD_RETURN(WHEN); }                               // CFA
 while                   { KEYWORD_RETURN(WHILE); }
 with                    { KEYWORD_RETURN(WITH); }                               // CFA

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb  3 18:30:12 2021
-// Update Count     : 4700
+// Last Modified On : Mon Apr 26 18:41:54 2021
+// Update Count     : 4990
 //
 
@@ -32 +32 @@
 //
 // 1. designation with and without '=' (use ':' instead)
-// 2. attributes not allowed in parenthesis of declarator
+
 //
 // All of the syntactic extensions for GCC C are marked with the comment "GCC". The second extensions are for Cforall
@@ -211 +211 @@
 } // forCtrl
 
-bool forall = false, yyy = false;                                               // aggregate have one or more forall qualifiers ?
+bool forall = false;                                                                    // aggregate have one or more forall qualifiers ?
 
 // https://www.gnu.org/software/bison/manual/bison.html#Location-Type
@@ -264 +264 @@
 %token RESTRICT                                                                                 // C99
 %token ATOMIC                                                                                   // C11
-%token FORALL MUTEX VIRTUAL COERCE                                              // CFA
+%token FORALL MUTEX VIRTUAL VTABLE COERCE                               // CFA
 %token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED
 %token BOOL COMPLEX IMAGINARY                                                   // C99
@@ -270 +270 @@
 %token uFLOAT16 uFLOAT32 uFLOAT32X uFLOAT64 uFLOAT64X uFLOAT128 // GCC
 %token ZERO_T ONE_T                                                                             // CFA
-%token VALIST                                                                                   // GCC
-%token AUTO_TYPE                                                                                // GCC
-%token TYPEOF BASETYPEOF LABEL                                                  // GCC
+%token SIZEOF TYPEOF VALIST AUTO_TYPE                                   // GCC
+%token OFFSETOF BASETYPEOF TYPEID                                               // CFA
 %token ENUM STRUCT UNION
 %token EXCEPTION                                                                                // CFA
 %token GENERATOR COROUTINE MONITOR THREAD                               // CFA
 %token OTYPE FTYPE DTYPE TTYPE TRAIT                                    // CFA
-%token SIZEOF OFFSETOF
 // %token RESUME                                                                                        // CFA
+%token LABEL                                                                                    // GCC
 %token SUSPEND                                                                                  // CFA
 %token ATTRIBUTE EXTENSION                                                              // GCC
 %token IF ELSE SWITCH CASE DEFAULT DO WHILE FOR BREAK CONTINUE GOTO RETURN
-%token CHOOSE DISABLE ENABLE FALLTHRU FALLTHROUGH TRY CATCH CATCHRESUME FINALLY THROW THROWRESUME AT WITH WHEN WAITFOR // CFA
+%token CHOOSE FALLTHRU FALLTHROUGH WITH WHEN WAITFOR    // CFA
+%token DISABLE ENABLE TRY THROW THROWRESUME AT                  // CFA
 %token ASM                                                                                              // C99, extension ISO/IEC 9899:1999 Section J.5.10(1)
 %token ALIGNAS ALIGNOF GENERIC STATICASSERT                             // C11
 
 // names and constants: lexer differentiates between identifier and typedef names
-%token<tok> IDENTIFIER                  QUOTED_IDENTIFIER               TYPEDEFname                             TYPEGENname
-%token<tok> TIMEOUT                             WOR
-%token<tok> INTEGERconstant             CHARACTERconstant               STRINGliteral
+%token<tok> IDENTIFIER          QUOTED_IDENTIFIER       TYPEDEFname             TYPEGENname
+%token<tok> TIMEOUT                     WOR                                     CATCH                   RECOVER                 CATCHRESUME             FIXUP           FINALLY         // CFA
+%token<tok> INTEGERconstant     CHARACTERconstant       STRINGliteral
 %token<tok> DIRECTIVE
 // Floating point constant is broken into three kinds of tokens because of the ambiguity with tuple indexing and
@@ -321 +321 @@
 %type<en> constant
 %type<en> tuple                                                 tuple_expression_list
-%type<op> ptrref_operator                               unary_operator                          assignment_operator
+%type<op> ptrref_operator                               unary_operator                          assignment_operator                     simple_assignment_operator      compound_assignment_operator
 %type<en> primary_expression                    postfix_expression                      unary_expression
 %type<en> cast_expression_list                  cast_expression                         exponential_expression          multiplicative_expression       additive_expression
@@ -373 +373 @@
 
 %type<decl> basic_declaration_specifier basic_type_name basic_type_specifier direct_type indirect_type
+%type<decl> vtable vtable_opt default_opt
 
 %type<decl> trait_declaration trait_declaration_list trait_declaring_list trait_specifier
@@ -428 +429 @@
 
 %type<decl> type_declaration_specifier type_type_specifier type_name typegen_name
-%type<decl> typedef typedef_declaration typedef_expression
+%type<decl> typedef_name typedef_declaration typedef_expression
 
 %type<decl> variable_type_redeclarator type_ptr type_array type_function
@@ -440 +441 @@
 
 %type<decl> type_qualifier type_qualifier_name forall type_qualifier_list_opt type_qualifier_list
-%type<decl> type_specifier type_specifier_nobody enum_specifier_nobody
+%type<decl> type_specifier type_specifier_nobody
 
 %type<decl> variable_declarator variable_ptr variable_array variable_function
 %type<decl> variable_abstract_declarator variable_abstract_ptr variable_abstract_array variable_abstract_function
 
-%type<decl> attribute_list_opt attribute_list attribute_opt attribute attribute_name_list attribute_name
+%type<decl> attribute_list_opt attribute_list attribute attribute_name_list attribute_name
 
 // initializers
@@ -462 +463 @@
 // Order of these lines matters (low-to-high precedence). THEN is left associative over WOR/TIMEOUT/ELSE, WOR is left
 // associative over TIMEOUT/ELSE, and TIMEOUT is left associative over ELSE.
-%precedence THEN        // rule precedence for IF/WAITFOR statement
-%precedence WOR         // token precedence for start of WOR in WAITFOR statement
-%precedence TIMEOUT     // token precedence for start of TIMEOUT in WAITFOR statement
-%precedence ELSE        // token precedence for start of else clause in IF/WAITFOR statement
+%precedence THEN                // rule precedence for IF/WAITFOR statement
+%precedence WOR                 // token precedence for start of WOR in WAITFOR statement
+%precedence TIMEOUT             // token precedence for start of TIMEOUT in WAITFOR statement
+%precedence CATCH               // token precedence for start of TIMEOUT in WAITFOR statement
+%precedence RECOVER             // token precedence for start of TIMEOUT in WAITFOR statement
+%precedence CATCHRESUME // token precedence for start of TIMEOUT in WAITFOR statement
+%precedence FIXUP               // token precedence for start of TIMEOUT in WAITFOR statement
+%precedence FINALLY             // token precedence for start of TIMEOUT in WAITFOR statement
+%precedence ELSE                // token precedence for start of else clause in IF/WAITFOR statement
+
 
 // Handle shift/reduce conflict for generic type by shifting the '(' token. For example, this string is ambiguous:
@@ -544 +551 @@
         TIMEOUT
         | WOR
+        | CATCH
+        | RECOVER
+        | CATCHRESUME
+        | FIXUP
+        | FINALLY
         ;
 
@@ -774 +786 @@
         | OFFSETOF '(' type_no_function ',' identifier ')'
                 { $$ = new ExpressionNode( build_offsetOf( $3, build_varref( $5 ) ) ); }
+        | TYPEID '(' type_no_function ')'
+                {
+                        SemanticError( yylloc, "typeid name is currently unimplemented." ); $$ = nullptr;
+                        // $$ = new ExpressionNode( build_offsetOf( $3, build_varref( $5 ) ) );
+                }
         ;
 
@@ -795 +812 @@
                 { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
         | '(' aggregate_control '&' ')' cast_expression         // CFA
+                { $$ = new ExpressionNode( build_keyword_cast( $2, $5 ) ); }
+        | '(' aggregate_control '*' ')' cast_expression         // CFA
                 { $$ = new ExpressionNode( build_keyword_cast( $2, $5 ) ); }
         | '(' VIRTUAL ')' cast_expression                                       // CFA
@@ -939 +958 @@
 
 assignment_operator:
+        simple_assignment_operator
+        | compound_assignment_operator
+        ;
+
+simple_assignment_operator:
         '='                                                                                     { $$ = OperKinds::Assign; }
-        | ATassign                                                                      { $$ = OperKinds::AtAssn; }
-        | EXPassign                                                                     { $$ = OperKinds::ExpAssn; }
+        | ATassign                                                                      { $$ = OperKinds::AtAssn; } // CFA
+        ;
+
+compound_assignment_operator:
+        EXPassign                                                                       { $$ = OperKinds::ExpAssn; }
         | MULTassign                                                            { $$ = OperKinds::MulAssn; }
         | DIVassign                                                                     { $$ = OperKinds::DivAssn; }
@@ -1019 +1046 @@
                 { $$ = new StatementNode( build_compound( (StatementNode *)0 ) ); }
         | '{' push
-          local_label_declaration_opt                                           // GCC, local labels
+          local_label_declaration_opt                                           // GCC, local labels appear at start of block
           statement_decl_list                                                           // C99, intermix declarations and statements
           pop '}'
@@ -1217 +1244 @@
         | comma_expression ';' comma_expression inclexcl comma_expression '~' comma_expression // CFA
                 { $$ = forCtrl( $3, $1, $3->clone(), $4, $5, $7 ); }
+
+        | comma_expression ';' TYPEDEFname                                      // CFA, array type
+                {
+                        SemanticError( yylloc, "Array interator is currently unimplemented." ); $$ = nullptr;
+                        $$ = forCtrl( new ExpressionNode( build_varref( $3 ) ), $1, nullptr, OperKinds::Range, nullptr, nullptr );
+                }
 
                 // There is a S/R conflicit if ~ and -~ are factored out.
@@ -1366 +1399 @@
 
 exception_statement:
-        TRY compound_statement handler_clause
+        TRY compound_statement handler_clause                                   %prec THEN
                 { $$ = new StatementNode( build_try( $2, $3, 0 ) ); }
         | TRY compound_statement finally_clause
@@ -1389 +1422 @@
 handler_key:
         CATCH                                                                           { $$ = CatchStmt::Terminate; }
+        | RECOVER                                                                       { $$ = CatchStmt::Terminate; }
         | CATCHRESUME                                                           { $$ = CatchStmt::Resume; }
+        | FIXUP                                                                         { $$ = CatchStmt::Resume; }
         ;
 
@@ -1741 +1776 @@
         ;
 
-enum_specifier_nobody:                                                                  // type specifier - {...}
-                // Preclude SUE declarations in restricted scopes (see type_specifier_nobody)
-        basic_type_specifier
-        | sue_type_specifier_nobody
-        ;
-
 type_qualifier_list_opt:                                                                // GCC, used in asm_statement
         // empty
@@ -1766 +1795 @@
 type_qualifier:
         type_qualifier_name
-        | attribute
+        | attribute                                                                                     // trick handles most atrribute locations
         ;
 
@@ -1874 +1903 @@
         | AUTO_TYPE
                 { $$ = DeclarationNode::newBuiltinType( DeclarationNode::AutoType ); }
+        | vtable
+        ;
+
+vtable_opt:
+        // empty
+                { $$ = nullptr; }
+        | vtable;
+        ;
+
+vtable:
+        VTABLE '(' type_list ')' default_opt
+                { SemanticError( yylloc, "vtable is currently unimplemented." ); $$ = nullptr; }
+        ;
+
+default_opt:
+        // empty
+                { $$ = nullptr; }
+        | DEFAULT
+                { SemanticError( yylloc, "vtable default is currently unimplemented." ); $$ = nullptr; }
         ;
 
@@ -2025 +2073 @@
           '{' field_declaration_list_opt '}' type_parameters_opt
                 { $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 ); }
-        | aggregate_key attribute_list_opt type_name
-                {
-                        // for type_name can be a qualified type name S.T, in which case only the last name in the chain needs a typedef (other names in the chain should already have one)
-                        typedefTable.makeTypedef( *$3->type->leafName(), forall || typedefTable.getEnclForall() ? TYPEGENname : TYPEDEFname ); // create typedef
+        | aggregate_key attribute_list_opt TYPEDEFname          // unqualified type name
+                {
+                        typedefTable.makeTypedef( *$3, forall || typedefTable.getEnclForall() ? TYPEGENname : TYPEDEFname ); // create typedef
                         forall = false;                                                         // reset
                 }
           '{' field_declaration_list_opt '}' type_parameters_opt
-                { $$ = DeclarationNode::newAggregate( $1, $3->type->symbolic.name, $8, $6, true )->addQualifiers( $2 ); }
+                {
+                        DeclarationNode::newFromTypedef( $3 );
+                        $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 );
+                }
+        | aggregate_key attribute_list_opt TYPEGENname          // unqualified type name
+                {
+                        typedefTable.makeTypedef( *$3, forall || typedefTable.getEnclForall() ? TYPEGENname : TYPEDEFname ); // create typedef
+                        forall = false;                                                         // reset
+                }
+          '{' field_declaration_list_opt '}' type_parameters_opt
+                {
+                        DeclarationNode::newFromTypeGen( $3, nullptr );
+                        $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 );
+                }
         | aggregate_type_nobody
         ;
@@ -2069 +2129 @@
 
 aggregate_data:
-        STRUCT
-                { yyy = true; $$ = AggregateDecl::Struct; }
+        STRUCT vtable_opt
+                { $$ = AggregateDecl::Struct; }
         | UNION
-                { yyy = true; $$ = AggregateDecl::Union; }
+                { $$ = AggregateDecl::Union; }
         | EXCEPTION                                                                                     // CFA
-                // { yyy = true; $$ = AggregateDecl::Exception; }
-                { SemanticError( yylloc, "exception aggregate is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
+                { $$ = AggregateDecl::Exception; }
+          //            { SemanticError( yylloc, "exception aggregate is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
         ;
 
 aggregate_control:                                                                              // CFA
         MONITOR
-                { yyy = true; $$ = AggregateDecl::Monitor; }
+                { $$ = AggregateDecl::Monitor; }
         | MUTEX STRUCT
-                { yyy = true; $$ = AggregateDecl::Monitor; }
+                { $$ = AggregateDecl::Monitor; }
         | GENERATOR
-                { yyy = true; $$ = AggregateDecl::Generator; }
+                { $$ = AggregateDecl::Generator; }
         | MUTEX GENERATOR
                 { SemanticError( yylloc, "monitor generator is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
         | COROUTINE
-                { yyy = true; $$ = AggregateDecl::Coroutine; }
+                { $$ = AggregateDecl::Coroutine; }
         | MUTEX COROUTINE
                 { SemanticError( yylloc, "monitor coroutine is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
         | THREAD
-                { yyy = true; $$ = AggregateDecl::Thread; }
+                { $$ = AggregateDecl::Thread; }
         | MUTEX THREAD
                 { SemanticError( yylloc, "monitor thread is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
@@ -2188 +2248 @@
         ;
 
-// Cannot use attribute_list_opt because of ambiguity with enum_specifier_nobody, which already parses attribute.
-// Hence, only a single attribute is allowed after the "ENUM".
 enum_type:                                                                                              // enum
-        ENUM attribute_opt '{' enumerator_list comma_opt '}'
+        ENUM attribute_list_opt '{' enumerator_list comma_opt '}'
                 { $$ = DeclarationNode::newEnum( nullptr, $4, true )->addQualifiers( $2 ); }
-        | ENUM attribute_opt identifier
+        | ENUM attribute_list_opt identifier
                 { typedefTable.makeTypedef( *$3 ); }
           '{' enumerator_list comma_opt '}'
                 { $$ = DeclarationNode::newEnum( $3, $6, true )->addQualifiers( $2 ); }
-        | ENUM attribute_opt typedef                                            // enum cannot be generic
+        | ENUM attribute_list_opt typedef_name                          // unqualified type name
           '{' enumerator_list comma_opt '}'
                 { $$ = DeclarationNode::newEnum( $3->name, $5, true )->addQualifiers( $2 ); }
-        | ENUM enum_specifier_nobody '{' enumerator_list comma_opt '}'
-                // { $$ = DeclarationNode::newEnum( nullptr, $4, true ); }
-                { SemanticError( yylloc, "Typed enumeration is currently unimplemented." ); $$ = nullptr; }
-        | ENUM enum_specifier_nobody declarator '{' enumerator_list comma_opt '}'
-                // {
-                //      typedefTable.makeTypedef( *$3->name );
-                //      $$ = DeclarationNode::newEnum( nullptr, $5, true );
-                // }
-                { SemanticError( yylloc, "Typed enumeration is currently unimplemented." ); $$ = nullptr; }
+        | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt '{' enumerator_list comma_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." ); }
+                        SemanticError( yylloc, "Typed enumeration is currently unimplemented." ); $$ = nullptr;
+                }
+        | 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." ); }
+                        typedefTable.makeTypedef( *$6 );
+                }
+          '{' enumerator_list comma_opt '}'
+                {
+                        SemanticError( yylloc, "Typed enumeration is currently unimplemented." ); $$ = nullptr;
+                }
+        | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt typedef_name attribute_list_opt '{' enumerator_list comma_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." ); }
+                        typedefTable.makeTypedef( *$6->name );
+                        SemanticError( yylloc, "Typed enumeration is currently unimplemented." ); $$ = nullptr;
+                }
         | enum_type_nobody
         ;
 
 enum_type_nobody:                                                                               // enum - {...}
-        ENUM attribute_opt identifier
-                {
-                        typedefTable.makeTypedef( *$3 );
-                        $$ = DeclarationNode::newEnum( $3, 0, false )->addQualifiers( $2 );
-                }
-        | ENUM attribute_opt type_name                                          // enum cannot be generic
-                {
-                        typedefTable.makeTypedef( *$3->type->symbolic.name );
-                        $$ = DeclarationNode::newEnum( $3->type->symbolic.name, 0, false )->addQualifiers( $2 );
-                }
+        ENUM attribute_list_opt identifier
+                { typedefTable.makeTypedef( *$3 ); $$ = DeclarationNode::newEnum( $3, 0, false )->addQualifiers( $2 ); }
+        | ENUM attribute_list_opt type_name                                     // qualified type name
+                { typedefTable.makeTypedef( *$3->type->symbolic.name ); $$ = DeclarationNode::newEnum( $3->type->symbolic.name, 0, false )->addQualifiers( $2 ); }
         ;
 
@@ -2228 +2291 @@
         identifier_or_type_name enumerator_value_opt
                 { $$ = DeclarationNode::newEnumConstant( $1, $2 ); }
+        | INLINE type_name
+                { $$ = DeclarationNode::newEnumConstant( new string("inline"), nullptr ); }
         | enumerator_list ',' identifier_or_type_name enumerator_value_opt
                 { $$ = $1->appendList( DeclarationNode::newEnumConstant( $3, $4 ) ); }
+        | enumerator_list ',' INLINE type_name enumerator_value_opt
+                { $$ = $1->appendList( DeclarationNode::newEnumConstant( new string("inline"), nullptr ) ); }
         ;
 
@@ -2237 +2304 @@
         // | '=' constant_expression
         //      { $$ = $2; }
-        | '=' initializer
+        | simple_assignment_operator initializer
                 { $$ = $2->get_expression(); }                                  // FIX ME: enum only deals with constant_expression
         ;
@@ -2365 +2432 @@
         // empty
                 { $$ = nullptr; }
-        | '=' initializer
-                { $$ = $2; }
-        | '=' VOID
-                { $$ = new InitializerNode( true ); }
-        | ATassign initializer
-                { $$ = $2->set_maybeConstructed( false ); }
+        | simple_assignment_operator initializer        { $$ = $1 == OperKinds::Assign ? $2 : $2->set_maybeConstructed( false ); }
+        | '=' VOID                                                                      { $$ = new InitializerNode( true ); }
         ;
 
@@ -2626 +2689 @@
 
 external_definition:
-        declaration
+        DIRECTIVE
+                { $$ = DeclarationNode::newDirectiveStmt( new StatementNode( build_directive( $1 ) ) ); }
+        | declaration
         | external_function_definition
         | EXTENSION external_definition                                         // GCC, multiple __extension__ allowed, meaning unknown
@@ -2634 +2699 @@
                 }
         | ASM '(' string_literal ')' ';'                                        // GCC, global assembler statement
-                {
-                        $$ = DeclarationNode::newAsmStmt( new StatementNode( build_asm( false, $3, 0 ) ) );
-                }
+                { $$ = DeclarationNode::newAsmStmt( new StatementNode( build_asm( false, $3, 0 ) ) ); }
         | EXTERN STRINGliteral                                                          // C++-style linkage specifier
                 {
@@ -2782 +2845 @@
         ;
 
-attribute_opt:
-        // empty
-                { $$ = nullptr; }
-        | attribute
-        ;
-
 attribute:                                                                                              // GCC
         ATTRIBUTE '(' '(' attribute_name_list ')' ')'
@@ -2849 +2906 @@
 // declaring an array of functions versus a pointer to an array of functions.
 
+paren_identifier:
+        identifier
+                { $$ = DeclarationNode::newName( $1 ); }
+        | '(' paren_identifier ')'                                                      // redundant parenthesis
+                { $$ = $2; }
+        ;
+
 variable_declarator:
         paren_identifier attribute_list_opt
@@ -2859 +2923 @@
         ;
 
-paren_identifier:
-        identifier
-                { $$ = DeclarationNode::newName( $1 ); }
-        | '(' paren_identifier ')'                                                      // redundant parenthesis
-                { $$ = $2; }
-        ;
-
 variable_ptr:
         ptrref_operator variable_declarator
@@ -2871 +2928 @@
         | ptrref_operator type_qualifier_list variable_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
-        | '(' variable_ptr ')' attribute_list_opt
-                { $$ = $2->addQualifiers( $4 ); }                               // redundant parenthesis
+        | '(' variable_ptr ')' attribute_list_opt                       // redundant parenthesis
+                { $$ = $2->addQualifiers( $4 ); }
+        | '(' attribute_list variable_ptr ')' attribute_list_opt // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 )->addQualifiers( $5 ); }
         ;
 
@@ -2880 +2939 @@
         | '(' variable_ptr ')' array_dimension
                 { $$ = $2->addArray( $4 ); }
-        | '(' variable_array ')' multi_array_dimension          // redundant parenthesis
+        | '(' attribute_list variable_ptr ')' array_dimension
+                { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
+        | '(' variable_array ')' multi_array_dimension          // redundant parenthesis
                 { $$ = $2->addArray( $4 ); }
+        | '(' attribute_list variable_array ')' multi_array_dimension // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
         | '(' variable_array ')'                                                        // redundant parenthesis
                 { $$ = $2; }
+        | '(' attribute_list variable_array ')'                         // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 ); }
         ;
 
@@ -2889 +2954 @@
         '(' variable_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
                 { $$ = $2->addParamList( $6 ); }
+        | '(' attribute_list variable_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+                { $$ = $3->addQualifiers( $2 )->addParamList( $7 ); }
         | '(' variable_function ')'                                                     // redundant parenthesis
                 { $$ = $2; }
+        | '(' attribute_list variable_function ')'                      // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 ); }
         ;
 
@@ -2910 +2979 @@
         | '(' function_ptr ')' '(' push parameter_type_list_opt pop ')'
                 { $$ = $2->addParamList( $6 ); }
+        | '(' attribute_list function_ptr ')' '(' push parameter_type_list_opt pop ')'
+                { $$ = $3->addQualifiers( $2 )->addParamList( $7 ); }
         | '(' function_no_ptr ')'                                                       // redundant parenthesis
                 { $$ = $2; }
+        | '(' attribute_list function_no_ptr ')'                        // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 ); }
         ;
 
@@ -2919 +2992 @@
         | ptrref_operator type_qualifier_list function_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
-        | '(' function_ptr ')'
-                { $$ = $2; }
+        | '(' function_ptr ')' attribute_list_opt
+                { $$ = $2->addQualifiers( $4 ); }
+        | '(' attribute_list function_ptr ')' attribute_list_opt
+                { $$ = $3->addQualifiers( $2 )->addQualifiers( $5 ); }
         ;
 
@@ -2926 +3001 @@
         '(' function_ptr ')' array_dimension
                 { $$ = $2->addArray( $4 ); }
+        | '(' attribute_list function_ptr ')' array_dimension
+                { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
         | '(' function_array ')' multi_array_dimension          // redundant parenthesis
                 { $$ = $2->addArray( $4 ); }
+        | '(' attribute_list function_array ')' multi_array_dimension // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
         | '(' function_array ')'                                                        // redundant parenthesis
                 { $$ = $2; }
+        | '(' attribute_list function_array ')'                         // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 ); }
         ;
 
@@ -2950 +3031 @@
         | '(' KR_function_ptr ')' '(' push parameter_type_list_opt pop ')'
                 { $$ = $2->addParamList( $6 ); }
+        | '(' attribute_list KR_function_ptr ')' '(' push parameter_type_list_opt pop ')'
+                { $$ = $3->addQualifiers( $2 )->addParamList( $7 ); }
         | '(' KR_function_no_ptr ')'                                            // redundant parenthesis
                 { $$ = $2; }
+        | '(' attribute_list KR_function_no_ptr ')'                     // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 ); }
         ;
 
@@ -2961 +3046 @@
         | '(' KR_function_ptr ')'
                 { $$ = $2; }
+        | '(' attribute_list KR_function_ptr ')'
+                { $$ = $3->addQualifiers( $2 ); }
         ;
 
@@ -2966 +3053 @@
         '(' KR_function_ptr ')' array_dimension
                 { $$ = $2->addArray( $4 ); }
+        | '(' attribute_list KR_function_ptr ')' array_dimension
+                { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
         | '(' KR_function_array ')' multi_array_dimension       // redundant parenthesis
                 { $$ = $2->addArray( $4 ); }
+        | '(' attribute_list KR_function_array ')' multi_array_dimension // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
         | '(' KR_function_array ')'                                                     // redundant parenthesis
                 { $$ = $2; }
+        | '(' attribute_list KR_function_array ')'                      // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 ); }
         ;
 
@@ -2981 +3074 @@
 // The pattern precludes declaring an array of functions versus a pointer to an array of functions, and returning arrays
 // and functions versus pointers to arrays and functions.
+
+paren_type:
+        typedef_name
+                {
+                        // hide type name in enclosing scope by variable name
+                        typedefTable.addToEnclosingScope( *$1->name, IDENTIFIER, "ID" );
+                }
+        | '(' paren_type ')'
+                { $$ = $2; }
+        ;
 
 variable_type_redeclarator:
@@ -2992 +3095 @@
         ;
 
-paren_type:
-        typedef
-                // hide type name in enclosing scope by variable name
-                {
-                        // if ( ! typedefTable.existsCurr( *$1->name ) ) {
-                                typedefTable.addToEnclosingScope( *$1->name, IDENTIFIER, "ID" );
-                        // } else {
-                        //      SemanticError( yylloc, string("'") + *$1->name + "' redeclared as different kind of symbol." ); $$ = nullptr;
-                        // } // if
-                }
-        | '(' paren_type ')'
-                { $$ = $2; }
-        ;
-
 type_ptr:
         ptrref_operator variable_type_redeclarator
@@ -3011 +3100 @@
         | ptrref_operator type_qualifier_list variable_type_redeclarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
-        | '(' type_ptr ')' attribute_list_opt
-                { $$ = $2->addQualifiers( $4 ); }                               // redundant parenthesis
+        | '(' type_ptr ')' attribute_list_opt                           // redundant parenthesis
+                { $$ = $2->addQualifiers( $4 ); }
+        | '(' attribute_list type_ptr ')' attribute_list_opt // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 )->addQualifiers( $5 ); }
         ;
 
@@ -3020 +3111 @@
         | '(' type_ptr ')' array_dimension
                 { $$ = $2->addArray( $4 ); }
+        | '(' attribute_list type_ptr ')' array_dimension
+                { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
         | '(' type_array ')' multi_array_dimension                      // redundant parenthesis
                 { $$ = $2->addArray( $4 ); }
+        | '(' attribute_list type_array ')' multi_array_dimension // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
         | '(' type_array ')'                                                            // redundant parenthesis
                 { $$ = $2; }
+        | '(' attribute_list type_array ')'                                     // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 ); }
         ;
 
@@ -3031 +3128 @@
         | '(' type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
                 { $$ = $2->addParamList( $6 ); }
+        | '(' attribute_list type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+                { $$ = $3->addQualifiers( $2 )->addParamList( $7 ); }
         | '(' type_function ')'                                                         // redundant parenthesis
                 { $$ = $2; }
+        | '(' attribute_list type_function ')'                          // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 ); }
         ;
 
@@ -3057 +3158 @@
         | ptrref_operator type_qualifier_list identifier_parameter_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
-        | '(' identifier_parameter_ptr ')' attribute_list_opt
+        | '(' identifier_parameter_ptr ')' attribute_list_opt // redundant parenthesis
                 { $$ = $2->addQualifiers( $4 ); }
         ;
@@ -3091 +3192 @@
 
 type_parameter_redeclarator:
-        typedef attribute_list_opt
+        typedef_name attribute_list_opt
                 { $$ = $1->addQualifiers( $2 ); }
-        | '&' MUTEX typedef attribute_list_opt
+        | '&' MUTEX typedef_name attribute_list_opt
                 { $$ = $3->addPointer( DeclarationNode::newPointer( DeclarationNode::newTypeQualifier( Type::Mutex ), OperKinds::AddressOf ) )->addQualifiers( $4 ); }
         | type_parameter_ptr
@@ -3102 +3203 @@
         ;
 
-typedef:
+typedef_name:
         TYPEDEFname
                 { $$ = DeclarationNode::newName( $1 ); }
@@ -3114 +3215 @@
         | ptrref_operator type_qualifier_list type_parameter_redeclarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
-        | '(' type_parameter_ptr ')' attribute_list_opt
+        | '(' type_parameter_ptr ')' attribute_list_opt         // redundant parenthesis
                 { $$ = $2->addQualifiers( $4 ); }
         ;
 
 type_parameter_array:
-        typedef array_parameter_dimension
+        typedef_name array_parameter_dimension
                 { $$ = $1->addArray( $2 ); }
         | '(' type_parameter_ptr ')' array_parameter_dimension
@@ -3126 +3227 @@
 
 type_parameter_function:
-        typedef '(' push parameter_type_list_opt pop ')'        // empty parameter list OBSOLESCENT (see 3)
+        typedef_name '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
                 { $$ = $1->addParamList( $4 ); }
         | '(' type_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
@@ -3255 +3356 @@
         | ptrref_operator type_qualifier_list abstract_parameter_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
-        | '(' abstract_parameter_ptr ')' attribute_list_opt
+        | '(' abstract_parameter_ptr ')' attribute_list_opt     // redundant parenthesis
                 { $$ = $2->addQualifiers( $4 ); }
         ;
@@ -3334 +3435 @@
         | ptrref_operator type_qualifier_list variable_abstract_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
-        | '(' variable_abstract_ptr ')' attribute_list_opt
+        | '(' variable_abstract_ptr ')' attribute_list_opt      // redundant parenthesis
                 { $$ = $2->addQualifiers( $4 ); }
         ;

src/ResolvExpr/CurrentObject.cc

@@ -925 +925 @@
                 if ( auto aggr = dynamic_cast< const BaseInstType * >( type ) ) {
                         if ( auto sit = dynamic_cast< const StructInstType * >( aggr ) ) {
+                                assert( sit->base );
                                 return new StructIterator{ loc, sit };
                         } else if ( auto uit = dynamic_cast< const UnionInstType * >( aggr ) ) {
+                                assert( uit->base );
                                 return new UnionIterator{ loc, uit };
                         } else {

src/SynTree/Constant.cc

@@ -42 +42 @@
 }
 
+Constant Constant::from_string( const std::string & str ) {
+        Type * charType = new BasicType( noQualifiers, BasicType::Char );
+        // Adjust the length of the string for the terminator.
+        Expression * strSize = new ConstantExpr( Constant::from_ulong( str.size() + 1 ) );
+        Type * strType = new ArrayType( noQualifiers, charType, strSize, false, false );
+        const std::string strValue = "\"" + str + "\"";
+        return Constant( strType, strValue, std::nullopt );
+}
+
 Constant Constant::null( Type * ptrtype ) {
         if ( nullptr == ptrtype ) {

src/SynTree/Constant.h

@@ -47 +47 @@
         /// generates an integer constant of the given unsigned long int
         static Constant from_ulong( unsigned long i );
+        /// generates a string constant from the given string (char type, unquoted string)
+        static Constant from_string( const std::string & string );
 
         /// generates a null pointer value for the given type. void * if omitted.

src/SynTree/Declaration.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Dec 11 16:39:56 2019
-// Update Count     : 36
+// Last Modified On : Fri Mar 12 18:35:39 2021
+// Update Count     : 37
 //
 
@@ -66 +66 @@
 
 
+DirectiveDecl::DirectiveDecl( DirectiveStmt *stmt ) : Declaration( "", Type::StorageClasses(), LinkageSpec::C ), stmt( stmt ) {
+}
+
+DirectiveDecl::DirectiveDecl( const DirectiveDecl &other ) : Declaration( other ), stmt( maybeClone( other.stmt ) ) {
+}
+
+DirectiveDecl::~DirectiveDecl() {
+        delete stmt;
+}
+
+void DirectiveDecl::print( std::ostream &os, Indenter indent ) const {
+        stmt->print( os, indent );
+}
+
+void DirectiveDecl::printShort( std::ostream &os, Indenter indent ) const {
+        stmt->print( os, indent );
+}
+
+
 StaticAssertDecl::StaticAssertDecl( Expression * condition, ConstantExpr * message ) : Declaration( "", Type::StorageClasses(), LinkageSpec::C ), condition( condition ), message( message )  {
 }

src/SynTree/Declaration.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jan 11 20:48:39 2021
-// Update Count     : 158
+// Last Modified On : Fri Mar 12 18:35:36 2021
+// Update Count     : 159
 //
 
@@ -400 +400 @@
 };
 
+class DirectiveDecl : public Declaration {
+  public:
+        DirectiveStmt * stmt;
+
+        DirectiveDecl( DirectiveStmt * stmt );
+        DirectiveDecl( const DirectiveDecl & other );
+        virtual ~DirectiveDecl();
+
+        DirectiveStmt * get_stmt() { return stmt; }
+        void set_stmt( DirectiveStmt * newValue ) { stmt = newValue; }
+
+        virtual DirectiveDecl * clone() const override { return new DirectiveDecl( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual DirectiveDecl * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+        virtual void printShort( std::ostream & os, Indenter indent = {} ) const override;
+};
+
 class StaticAssertDecl : public Declaration {
 public:

src/SynTree/Mutator.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jul 25 22:37:46 2019
-// Update Count     : 17
+// Last Modified On : Fri Mar 12 18:35:36 2021
+// Update Count     : 18
 //
 #pragma once
@@ -34 +34 @@
         virtual Declaration * mutate( TypedefDecl * typeDecl ) = 0;
         virtual AsmDecl * mutate( AsmDecl * asmDecl ) = 0;
+        virtual DirectiveDecl * mutate( DirectiveDecl * directiveDecl ) = 0;
         virtual StaticAssertDecl * mutate( StaticAssertDecl * assertDecl ) = 0;
 

src/SynTree/SynTree.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jul 25 22:37:45 2019
-// Update Count     : 12
+// Last Modified On : Fri Mar 12 18:56:44 2021
+// Update Count     : 13
 //
 
@@ -36 +36 @@
 class TypedefDecl;
 class AsmDecl;
+class DirectiveDecl;
 class StaticAssertDecl;
 

src/SynTree/Visitor.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jul 25 22:21:49 2019
-// Update Count     : 14
+// Last Modified On : Fri Mar 12 18:35:35 2021
+// Update Count     : 15
 //
 
@@ -45 +45 @@
         virtual void visit( AsmDecl * node ) { visit( const_cast<const AsmDecl *>(node) ); }
         virtual void visit( const AsmDecl * asmDecl ) = 0;
+        virtual void visit( DirectiveDecl * node ) { visit( const_cast<const DirectiveDecl *>(node) ); }
+        virtual void visit( const DirectiveDecl * directiveDecl ) = 0;
         virtual void visit( StaticAssertDecl * node ) { visit( const_cast<const StaticAssertDecl *>(node) ); }
         virtual void visit( const StaticAssertDecl * assertDecl ) = 0;

src/Virtual/ExpandCasts.cc

@@ -32 +32 @@
 namespace Virtual {
 
+static bool is_prefix( const std::string & prefix, const std::string& entire ) {
+        size_t const p_size = prefix.size();
+        return (p_size < entire.size() && prefix == entire.substr(0, p_size));
+}
+
+static bool is_type_id_object( const ObjectDecl * objectDecl ) {
+        const std::string & objectName = objectDecl->name;
+        return is_prefix( "__cfatid_", objectName );
+}
+
         // Indented until the new ast code gets added.
 
@@ -66 +76 @@
         };
 
-        /* Currently virtual depends on the rather brittle name matching between
-         * a (strict/explicate) virtual type, its vtable type and the vtable
-         * instance.
-         * A stronger implementation, would probably keep track of those triads
-         * and use that information to create better error messages.
-         */
-
-        namespace {
-
-        std::string get_vtable_name( std::string const & name ) {
-                return name + "_vtable";
-        }
-
-        std::string get_vtable_inst_name( std::string const & name ) {
-                return std::string("_") + get_vtable_name( name ) + "_instance";
-        }
-
-        std::string get_vtable_name_root( std::string const & name ) {
-                return name.substr(0, name.size() - 7 );
-        }
-
-        std::string get_vtable_inst_name_root( std::string const & name ) {
-                return get_vtable_name_root( name.substr(1, name.size() - 10 ) );
-        }
-
-        bool is_vtable_inst_name( std::string const & name ) {
-                return 17 < name.size() &&
-                        name == get_vtable_inst_name( get_vtable_inst_name_root( name ) );
-        }
-
-        } // namespace
-
         class VirtualCastCore {
-                Type * pointer_to_pvt(int level_of_indirection) {
+                CastExpr * cast_to_type_id( Expression * expr, int level_of_indirection ) {
                         Type * type = new StructInstType(
                                 Type::Qualifiers( Type::Const ), pvt_decl );
@@ -105 +83 @@
                                 type = new PointerType( noQualifiers, type );
                         }
-                        return type;
+                        return new CastExpr( expr, type );
                 }
 
@@ -141 +119 @@
 
         void VirtualCastCore::premutate( ObjectDecl * objectDecl ) {
-                if ( is_vtable_inst_name( objectDecl->get_name() ) ) {
-                        if ( ObjectDecl * existing = indexer.insert( objectDecl ) ) {
-                                std::string msg = "Repeated instance of virtual table, original found at: ";
-                                msg += existing->location.filename;
-                                msg += ":" + toString( existing->location.first_line );
-                                SemanticError( objectDecl->location, msg );
-                        }
+                if ( is_type_id_object( objectDecl ) ) {
+                        // Multiple definitions should be fine because of linkonce.
+                        indexer.insert( objectDecl );
                 }
         }
@@ -170 +144 @@
         }
 
-        /// Get the virtual table type used in a virtual cast.
-        Type * getVirtualTableType( const VirtualCastExpr * castExpr ) {
-                const Type * objectType;
-                if ( auto target = dynamic_cast<const PointerType *>( castExpr->result ) ) {
-                        objectType = target->base;
-                } else if ( auto target = dynamic_cast<const ReferenceType *>( castExpr->result ) ) {
-                        objectType = target->base;
+        /// Get the base type from a pointer or reference.
+        const Type * getBaseType( const Type * type ) {
+                if ( auto target = dynamic_cast<const PointerType *>( type ) ) {
+                        return target->base;
+                } else if ( auto target = dynamic_cast<const ReferenceType *>( type ) ) {
+                        return target->base;
                 } else {
-                        castError( castExpr, "Virtual cast type must be a pointer or reference type." );
-                }
-                assert( objectType );
-
-                const StructInstType * structType = dynamic_cast<const StructInstType *>( objectType );
-                if ( nullptr == structType ) {
-                        castError( castExpr, "Virtual cast type must refer to a structure type." );
-                }
-                const StructDecl * structDecl = structType->baseStruct;
-                assert( structDecl );
-
-                const ObjectDecl * fieldDecl = nullptr;
-                if ( 0 < structDecl->members.size() ) {
-                        const Declaration * memberDecl = structDecl->members.front();
+                        return nullptr;
+                }
+        }
+
+        /* Attempt to follow the "head" field of the structure to get the...
+         * Returns nullptr on error, otherwise owner must free returned node.
+         */
+        StructInstType * followHeadPointerType(
+                        const StructInstType * oldType,
+                        const std::string& fieldName,
+                        const CodeLocation& errorLocation ) {
+
+                // First section of the function is all about trying to fill this variable in.
+                StructInstType * newType = nullptr;
+                {
+                        const StructDecl * oldDecl = oldType->baseStruct;
+                        assert( oldDecl );
+
+                        // Helper function for throwing semantic errors.
+                        auto throwError = [&fieldName, &errorLocation, &oldDecl](const std::string& message) {
+                                const std::string& context = "While following head pointer of " +
+                                        oldDecl->name + " named '" + fieldName + "': ";
+                                SemanticError( errorLocation, context + message );
+                        };
+
+                        if ( oldDecl->members.empty() ) {
+                                throwError( "Type has no fields." );
+                        }
+                        const Declaration * memberDecl = oldDecl->members.front();
                         assert( memberDecl );
-                        fieldDecl = dynamic_cast<const ObjectDecl *>( memberDecl );
-                        if ( fieldDecl && fieldDecl->name != "virtual_table" ) {
-                                fieldDecl = nullptr;
-                        }
-                }
-                if ( nullptr == fieldDecl ) {
-                        castError( castExpr, "Virtual cast type must have a leading virtual_table field." );
-                }
-                const PointerType * fieldType = dynamic_cast<const PointerType *>( fieldDecl->type );
-                if ( nullptr == fieldType ) {
-                        castError( castExpr, "Virtual cast type virtual_table field is not a pointer." );
-                }
-                assert( fieldType->base );
-                auto virtualStructType = dynamic_cast<const StructInstType *>( fieldType->base );
-                assert( virtualStructType );
-
-                // Here is the type, but if it is polymorphic it will have lost information.
-                // (Always a clone so that it may always be deleted.)
-                StructInstType * virtualType = virtualStructType->clone();
-                if ( ! structType->parameters.empty() ) {
-                        deleteAll( virtualType->parameters );
-                        virtualType->parameters.clear();
-                        cloneAll( structType->parameters, virtualType->parameters );
-                }
-                return virtualType;
+                        const ObjectDecl * fieldDecl = dynamic_cast<const ObjectDecl *>( memberDecl );
+                        assert( fieldDecl );
+                        if ( fieldName != fieldDecl->name ) {
+                                throwError( "Head field did not have expected name." );
+                        }
+
+                        const Type * fieldType = fieldDecl->type;
+                        if ( nullptr == fieldType ) {
+                                throwError( "Could not get head field." );
+                        }
+                        const PointerType * ptrType = dynamic_cast<const PointerType *>( fieldType );
+                        if ( nullptr == ptrType ) {
+                                throwError( "First field is not a pointer type." );
+                        }
+                        assert( ptrType->base );
+                        newType = dynamic_cast<StructInstType *>( ptrType->base );
+                        if ( nullptr == newType ) {
+                                throwError( "First field does not point to a structure type." );
+                        }
+                }
+
+                // Now we can look into copying it.
+                newType = newType->clone();
+                if ( ! oldType->parameters.empty() ) {
+                        deleteAll( newType->parameters );
+                        newType->parameters.clear();
+                        cloneAll( oldType->parameters, newType->parameters );
+                }
+                return newType;
+        }
+
+        /// Get the type-id type from a virtual type.
+        StructInstType * getTypeIdType( const Type * type, const CodeLocation& errorLocation ) {
+                const StructInstType * typeInst = dynamic_cast<const StructInstType *>( type );
+                if ( nullptr == typeInst ) {
+                        return nullptr;
+                }
+                StructInstType * tableInst =
+                        followHeadPointerType( typeInst, "virtual_table", errorLocation );
+                if ( nullptr == tableInst ) {
+                        return nullptr;
+                }
+                StructInstType * typeIdInst =
+                        followHeadPointerType( tableInst, "__cfavir_typeid", errorLocation );
+                delete tableInst;
+                return typeIdInst;
         }
 
@@ -228 +237 @@
                 assert( pvt_decl );
 
-                const Type * vtable_type = getVirtualTableType( castExpr );
-                ObjectDecl * table = indexer.lookup( vtable_type );
-                if ( nullptr == table ) {
-                        SemanticError( castLocation( castExpr ),
-                                "Could not find virtual table instance." );
+                const Type * base_type = getBaseType( castExpr->result );
+                if ( nullptr == base_type ) {
+                        castError( castExpr, "Virtual cast target must be a pointer or reference type." );
+                }
+                const Type * type_id_type = getTypeIdType( base_type, castLocation( castExpr ) );
+                if ( nullptr == type_id_type ) {
+                        castError( castExpr, "Ill formed virtual cast target type." );
+                }
+                ObjectDecl * type_id = indexer.lookup( type_id_type );
+                delete type_id_type;
+                if ( nullptr == type_id ) {
+                        castError( castExpr, "Virtual cast does not target a virtual type." );
                 }
 
                 Expression * result = new CastExpr(
                         new ApplicationExpr( VariableExpr::functionPointer( vcast_decl ), {
-                                        new CastExpr(
-                                                new AddressExpr( new VariableExpr( table ) ),
-                                                pointer_to_pvt(1)
-                                        ),
-                                        new CastExpr(
-                                                castExpr->get_arg(),
-                                                pointer_to_pvt(2)
-                                        )
+                                cast_to_type_id( new AddressExpr( new VariableExpr( type_id ) ), 1 ),
+                                cast_to_type_id( castExpr->get_arg(), 2 ),
                         } ),
                         castExpr->get_result()->clone()
@@ -252 +262 @@
                 castExpr->set_result( nullptr );
                 delete castExpr;
-                delete vtable_type;
                 return result;
         }

src/Virtual/Tables.cc

@@ -10 +10 @@
 // Created On       : Mon Aug 31 11:11:00 2020
 // Last Modified By : Andrew Beach
-// Last Modified On : Tue Sep  3 14:56:00 2020
-// Update Count     : 0
+// Last Modified On : Wed Apr 21 15:36:00 2021
+// Update Count     : 2
 //
 
@@ -22 +22 @@
 namespace Virtual {
 
+std::string typeIdType( std::string const & type_name ) {
+        return "__cfatid_struct_" + type_name;
+}
+
+std::string typeIdName( std::string const & type_name ) {
+        return "__cfatid_" + type_name;
+}
+
+static std::string typeIdTypeToInstance( std::string const & type_name ) {
+        return typeIdName(type_name.substr(16));
+}
+
 std::string vtableTypeName( std::string const & name ) {
         return name + "_vtable";
 }
 
+std::string baseTypeName( std::string const & vtable_type_name ) {
+        return vtable_type_name.substr(0, vtable_type_name.size() - 7);
+}
+
 std::string instanceName( std::string const & name ) {
         return std::string("_") + name + "_instance";
@@ -32 +48 @@
 std::string vtableInstanceName( std::string const & name ) {
         return instanceName( vtableTypeName( name ) );
+}
+
+std::string concurrentDefaultVTableName() {
+        return "_default_vtable";
 }
 
@@ -41 +61 @@
 
 static ObjectDecl * makeVtableDeclaration(
+                std::string const & name,
                 StructInstType * type, Initializer * init ) {
-        std::string const & name = instanceName( type->name );
         Type::StorageClasses storage = noStorageClasses;
         if ( nullptr == init ) {
@@ -57 +77 @@
 }
 
-ObjectDecl * makeVtableForward( StructInstType * type ) {
+ObjectDecl * makeVtableForward( std::string const & name, StructInstType * type ) {
         assert( type );
-        return makeVtableDeclaration( type, nullptr );
+        return makeVtableDeclaration( name, type, nullptr );
 }
 
 ObjectDecl * makeVtableInstance(
-                StructInstType * vtableType, Type * objectType, Initializer * init ) {
+                std::string const & name, StructInstType * vtableType,
+                Type * objectType, Initializer * init ) {
         assert( vtableType );
         assert( objectType );
@@ -81 +102 @@
                                 inits.push_back(
                                                 new SingleInit( new AddressExpr( new NameExpr( parentInstance ) ) ) );
+                        } else if ( std::string( "__cfavir_typeid" ) == field->name ) {
+                                std::string const & baseType = baseTypeName( vtableType->name );
+                                std::string const & typeId = typeIdName( baseType );
+                                inits.push_back( new SingleInit( new AddressExpr( new NameExpr( typeId ) ) ) );
                         } else if ( std::string( "size" ) == field->name ) {
                                 inits.push_back( new SingleInit( new SizeofExpr( objectType->clone() ) ) );
@@ -95 +120 @@
                 assert(false);
         }
-        return makeVtableDeclaration( vtableType, init );
+        return makeVtableDeclaration( name, vtableType, init );
 }
 
@@ -147 +172 @@
 }
 
-}
+Attribute * linkonce( const std::string & subsection ) {
+        const std::string section = ".gnu.linkonce." + subsection;
+        return new Attribute( "section", {
+                new ConstantExpr( Constant::from_string( section ) ),
+        } );
+}
+
+ObjectDecl * makeTypeIdInstance( StructInstType const * typeIdType ) {
+        assert( typeIdType );
+        StructInstType * type = typeIdType->clone();
+        type->tq.is_const = true;
+        std::string const & typeid_name = typeIdTypeToInstance( typeIdType->name );
+        return new ObjectDecl(
+                typeid_name,
+                noStorageClasses,
+                LinkageSpec::Cforall,
+                /* bitfieldWidth */ nullptr,
+                type,
+                new ListInit( { new SingleInit(
+                        new AddressExpr( new NameExpr( "__cfatid_exception_t" ) )
+                        ) } ),
+                { linkonce( typeid_name ) },
+                noFuncSpecifiers
+        );
+}
+
+}

src/Virtual/Tables.h

@@ -10 +10 @@
 // Created On       : Mon Aug 31 11:07:00 2020
 // Last Modified By : Andrew Beach
-// Last Modified On : Tue Sep  1 14:29:00 2020
-// Update Count     : 0
+// Last Modified On : Wed Apr 21 10:30:00 2021
+// Update Count     : 2
 //
 
@@ -22 +22 @@
 namespace Virtual {
 
+std::string typeIdType( std::string const & type_name );
+std::string typeIdName( std::string const & type_name );
 std::string vtableTypeName( std::string const & type_name );
 std::string instanceName( std::string const & vtable_name );
 std::string vtableInstanceName( std::string const & type_name );
+std::string concurrentDefaultVTableName();
 bool isVTableInstanceName( std::string const & name );
 
-ObjectDecl * makeVtableForward( StructInstType * vtableType );
+ObjectDecl * makeVtableForward(
+        std::string const & name, StructInstType * vtableType );
 /* Create a forward declaration of a vtable of the given type.
  * vtableType node is consumed.
  */
 
-ObjectDecl * makeVtableInstance( StructInstType * vtableType, Type * objectType,
+ObjectDecl * makeVtableInstance(
+        std::string const & name,
+        StructInstType * vtableType, Type * objectType,
         Initializer * init = nullptr );
 /* Create an initialized definition of a vtable.
@@ -50 +56 @@
  */
 
+ObjectDecl * makeTypeIdInstance( StructInstType const * typeIdType );
+/* Build an instance of the type-id from the type of the type-id.
+ * TODO: Should take the parent type. Currently locked to the exception_t.
+ */
+
 }

src/main.cc

@@ -10 +10 @@
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Feb  8 21:10:16 2021
-// Update Count     : 642
+// Last Modified On : Sat Mar  6 15:49:00 2021
+// Update Count     : 656
 //
 
@@ -101 +101 @@
 static string PreludeDirector = "";
 
-static void parse_cmdline( int argc, char *argv[] );
+static void parse_cmdline( int argc, char * argv[] );
 static void parse( FILE * input, LinkageSpec::Spec linkage, bool shouldExit = false );
 static void dump( list< Declaration * > & translationUnit, ostream & out = cout );
+static void dump( ast::TranslationUnit && transUnit, ostream & out = cout );
 
 static void backtrace( int start ) {                                    // skip first N stack frames
@@ -158 +159 @@
 #define SIGPARMS int sig __attribute__(( unused )), siginfo_t * sfp __attribute__(( unused )), ucontext_t * cxt __attribute__(( unused ))
 
-static void Signal( int sig, void (*handler)(SIGPARMS), int flags ) {
+static void Signal( int sig, void (* handler)(SIGPARMS), int flags ) {
         struct sigaction act;
 
@@ -165 +166 @@
 
         if ( sigaction( sig, &act, nullptr ) == -1 ) {
-            cerr << "*CFA runtime error* problem installing signal handler, error(" << errno << ") " << strerror( errno ) << endl;
+            cerr << "*cfa-cpp compilation error* problem installing signal handler, error(" << errno << ") " << strerror( errno ) << endl;
             _exit( EXIT_FAILURE );
         } // if
@@ -349 +350 @@
                         PASS( "Resolve", ResolvExpr::resolve( transUnit ) );
                         if ( exprp ) {
-                                translationUnit = convert( move( transUnit ) );
-                                dump( translationUnit );
+                                dump( move( transUnit ) );
                                 return EXIT_SUCCESS;
                         } // if
@@ -421 +421 @@
                         delete output;
                 } // if
-        } catch ( SemanticErrorException &e ) {
+        } catch ( SemanticErrorException & e ) {
                 if ( errorp ) {
                         cerr << "---AST at error:---" << endl;
@@ -432 +432 @@
                 } // if
                 return EXIT_FAILURE;
-        } catch ( UnimplementedError &e ) {
+        } catch ( UnimplementedError & e ) {
                 cout << "Sorry, " << e.get_what() << " is not currently implemented" << endl;
                 if ( output != &cout ) {
@@ -438 +438 @@
                 } // if
                 return EXIT_FAILURE;
-        } catch ( CompilerError &e ) {
+        } catch ( CompilerError & e ) {
                 cerr << "Compiler Error: " << e.get_what() << endl;
                 cerr << "(please report bugs to [REDACTED])" << endl;
@@ -445 +445 @@
                 } // if
                 return EXIT_FAILURE;
+        } catch ( std::bad_alloc & ) {
+                cerr << "*cfa-cpp compilation error* std::bad_alloc" << endl;
+                backtrace( 1 );
+                abort();
         } catch ( ... ) {
                 exception_ptr eptr = current_exception();
@@ -451 +455 @@
                                 rethrow_exception(eptr);
                         } else {
-                                cerr << "Exception Uncaught and Unknown" << endl;
-                        } // if
-                } catch(const exception& e) {
-                        cerr << "Uncaught Exception \"" << e.what() << "\"\n";
+                                cerr << "*cfa-cpp compilation error* exception uncaught and unknown" << endl;
+                        } // if
+                } catch( const exception & e ) {
+                        cerr << "*cfa-cpp compilation error* uncaught exception \"" << e.what() << "\"\n";
                 } // try
                 return EXIT_FAILURE;
@@ -544 +548 @@
 enum { printoptsSize = sizeof( printopts ) / sizeof( printopts[0] ) };
 
-static void usage( char *argv[] ) {
+static void usage( char * argv[] ) {
     cout << "Usage: " << argv[0] << " [options] [input-file (default stdin)] [output-file (default stdout)], where options are:" << endl;
         int i = 0, j = 1;                                                                       // j skips starting colon
@@ -732 +736 @@
 } // dump
 
+static void dump( ast::TranslationUnit && transUnit, ostream & out ) {
+        std::list< Declaration * > translationUnit = convert( move( transUnit ) );
+        dump( translationUnit, out );
+}
+
 // Local Variables: //
 // tab-width: 4 //