Index: src/Parser/DeclarationNode.cc =================================================================== --- src/Parser/DeclarationNode.cc (revision 0522ebe7b3ae7204a1d2c50a1bc7273bfa36762a) +++ src/Parser/DeclarationNode.cc (revision f1149acdd1aec2da8d7e43ad6e4025f8b736412b) @@ -10,6 +10,6 @@ // Created On : Sat May 16 12:34:05 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Dec 14 19:05:17 2023 -// Update Count : 1407 +// Last Modified On : Fri Feb 23 18:25:57 2024 +// Update Count : 1533 // @@ -159,7 +159,8 @@ if ( ! attributes.empty() ) { - os << string( indent + 2, ' ' ) << "with attributes " << endl; + os << string( indent + 2, ' ' ) << "with attributes" << endl; for ( ast::ptr const & attr : reverseIterate( attributes ) ) { - os << string( indent + 4, ' ' ) << attr->name.c_str() << endl; + os << string( indent + 4, ' ' ); + ast::print( os, attr, indent + 2 ); } // for } // if @@ -537,14 +538,16 @@ } // DeclarationNode::checkSpecifiers -DeclarationNode * DeclarationNode::copySpecifiers( DeclarationNode * q ) { +DeclarationNode * DeclarationNode::copySpecifiers( DeclarationNode * q, bool copyattr ) { funcSpecs |= q->funcSpecs; storageClasses |= q->storageClasses; - std::vector> tmp; - tmp.reserve( q->attributes.size() ); - for ( auto const & attr : q->attributes ) { - tmp.emplace_back( ast::shallowCopy( attr.get() ) ); - } - spliceBegin( attributes, tmp ); + if ( copyattr ) { + std::vector> tmp; + tmp.reserve( q->attributes.size() ); + for ( auto const & attr : q->attributes ) { + tmp.emplace_back( ast::shallowCopy( attr.get() ) ); + } // for + spliceBegin( attributes, tmp ); + } // if return this; @@ -681,13 +684,15 @@ } -DeclarationNode * DeclarationNode::addType( DeclarationNode * o ) { +DeclarationNode * DeclarationNode::addType( DeclarationNode * o, bool copyattr ) { if ( o ) { checkSpecifiers( o ); - copySpecifiers( o ); + copySpecifiers( o, copyattr ); if ( o->type ) { if ( ! type ) { if ( o->type->kind == TypeData::Aggregate || o->type->kind == TypeData::Enum ) { + // Hide type information aggregate instances. type = new TypeData( TypeData::AggregateInst ); - type->aggInst.aggregate = o->type; + type->aggInst.aggregate = o->type; // change ownership + type->aggInst.aggregate->aggregate.attributes.swap( o->attributes ); // change ownership if ( o->type->kind == TypeData::Aggregate ) { type->aggInst.hoistType = o->type->aggregate.body; @@ -700,5 +705,5 @@ type = o->type; } // if - o->type = nullptr; + o->type = nullptr; // change ownership } else { addTypeToType( o->type, type ); @@ -953,8 +958,8 @@ } -DeclarationNode * DeclarationNode::cloneBaseType( DeclarationNode * o ) { +DeclarationNode * DeclarationNode::cloneBaseType( DeclarationNode * o, bool copyattr ) { if ( ! o ) return nullptr; - o->copySpecifiers( this ); + o->copySpecifiers( this, copyattr ); if ( type ) { TypeData * srcType = type; @@ -999,4 +1004,7 @@ DeclarationNode * newnode = new DeclarationNode; newnode->type = ret; + if ( ret->kind == TypeData::Aggregate ) { + newnode->attributes.swap( ret->aggregate.attributes ); + } // if return newnode; } // if @@ -1110,8 +1118,8 @@ if ( extr->type->kind == TypeData::Aggregate ) { // typedef struct { int A } B is the only case? - extracted_named = !extr->type->aggregate.anon; + extracted_named = ! extr->type->aggregate.anon; } else if ( extr->type->kind == TypeData::Enum ) { // typedef enum { A } B is the only case? - extracted_named = !extr->type->enumeration.anon; + extracted_named = ! extr->type->enumeration.anon; } else { extracted_named = true; Index: src/Parser/DeclarationNode.h =================================================================== --- src/Parser/DeclarationNode.h (revision 0522ebe7b3ae7204a1d2c50a1bc7273bfa36762a) +++ src/Parser/DeclarationNode.h (revision f1149acdd1aec2da8d7e43ad6e4025f8b736412b) @@ -9,7 +9,7 @@ // Author : Andrew Beach // Created On : Wed Apr 5 11:38:00 2023 -// Last Modified By : Andrew Beach -// Last Modified On : Wed Apr 5 11:55:00 2023 -// Update Count : 0 +// Last Modified By : Peter A. Buhr +// Last Modified On : Sat Feb 17 09:24:12 2024 +// Update Count : 4 // @@ -83,6 +83,6 @@ void checkQualifiers( const TypeData *, const TypeData * ); void checkSpecifiers( DeclarationNode * ); - DeclarationNode * copySpecifiers( DeclarationNode * ); - DeclarationNode * addType( DeclarationNode * ); + DeclarationNode * copySpecifiers( DeclarationNode *, bool = true ); + DeclarationNode * addType( DeclarationNode *, bool = true ); DeclarationNode * addTypedef(); DeclarationNode * addEnumBase( DeclarationNode * ); @@ -106,5 +106,5 @@ DeclarationNode * cloneType( std::string * newName ); - DeclarationNode * cloneBaseType( DeclarationNode * newdecl ); + DeclarationNode * cloneBaseType( DeclarationNode * newdecl, bool = true ); DeclarationNode * appendList( DeclarationNode * node ) { Index: src/Parser/TypeData.cc =================================================================== --- src/Parser/TypeData.cc (revision 0522ebe7b3ae7204a1d2c50a1bc7273bfa36762a) +++ src/Parser/TypeData.cc (revision f1149acdd1aec2da8d7e43ad6e4025f8b736412b) @@ -10,6 +10,6 @@ // Created On : Sat May 16 15:12:51 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Dec 14 18:59:12 2023 -// Update Count : 684 +// Last Modified On : Fri Feb 23 08:58:30 2024 +// Update Count : 734 // @@ -20,8 +20,10 @@ #include "AST/Decl.hpp" // for AggregateDecl, ObjectDecl, TypeDe... +#include "AST/Attribute.hpp" // for Attribute #include "AST/Init.hpp" // for SingleInit, ListInit #include "AST/Print.hpp" // for print #include "Common/SemanticError.h" // for SemanticError #include "Common/utility.h" // for splice, spliceBegin +#include "Common/Iterate.hpp" // for reverseIterate #include "Parser/ExpressionNode.h" // for ExpressionNode #include "Parser/StatementNode.h" // for StatementNode @@ -199,11 +201,12 @@ newtype->aggregate.kind = aggregate.kind; newtype->aggregate.name = aggregate.name ? new string( *aggregate.name ) : nullptr; + newtype->aggregate.parent = aggregate.parent ? new string( *aggregate.parent ) : nullptr; newtype->aggregate.params = maybeCopy( aggregate.params ); newtype->aggregate.actuals = maybeCopy( aggregate.actuals ); newtype->aggregate.fields = maybeCopy( aggregate.fields ); + newtype->aggregate.attributes = aggregate.attributes; newtype->aggregate.body = aggregate.body; newtype->aggregate.anon = aggregate.anon; newtype->aggregate.tagged = aggregate.tagged; - newtype->aggregate.parent = aggregate.parent ? new string( *aggregate.parent ) : nullptr; break; case AggregateInst: @@ -336,5 +339,12 @@ } // if if ( aggregate.body ) { - os << string( indent + 2, ' ' ) << " with body" << endl; + os << string( indent + 2, ' ' ) << "with body" << endl; + } // if + if ( ! aggregate.attributes.empty() ) { + os << string( indent + 2, ' ' ) << "with attributes" << endl; + for ( ast::ptr const & attr : reverseIterate( aggregate.attributes ) ) { + os << string( indent + 4, ' ' ); + ast::print( os, attr, indent + 2 ); + } // for } // if break; @@ -358,5 +368,5 @@ } // if if ( enumeration.body ) { - os << string( indent + 2, ' ' ) << " with body" << endl; + os << string( indent + 2, ' ' ) << "with body" << endl; } // if if ( base ) { @@ -1088,28 +1098,28 @@ ast::BaseInstType * buildComAggInst( - const TypeData * type, + const TypeData * td, std::vector> && attributes, ast::Linkage::Spec linkage ) { - switch ( type->kind ) { + switch ( td->kind ) { case TypeData::Enum: - if ( type->enumeration.body ) { + if ( td->enumeration.body ) { ast::EnumDecl * typedecl = - buildEnum( type, std::move( attributes ), linkage ); + buildEnum( td, std::move( attributes ), linkage ); return new ast::EnumInstType( typedecl, - buildQualifiers( type ) + buildQualifiers( td ) ); } else { return new ast::EnumInstType( - *type->enumeration.name, - buildQualifiers( type ) + *td->enumeration.name, + buildQualifiers( td ) ); } // if break; case TypeData::Aggregate: - if ( type->aggregate.body ) { + if ( td->aggregate.body ) { ast::AggregateDecl * typedecl = - buildAggregate( type, std::move( attributes ), linkage ); - switch ( type->aggregate.kind ) { + buildAggregate( td, std::move( attributes ), linkage ); + switch ( td->aggregate.kind ) { case ast::AggregateDecl::Struct: case ast::AggregateDecl::Coroutine: @@ -1118,10 +1128,10 @@ return new ast::StructInstType( strict_dynamic_cast( typedecl ), - buildQualifiers( type ) + buildQualifiers( td ) ); case ast::AggregateDecl::Union: return new ast::UnionInstType( strict_dynamic_cast( typedecl ), - buildQualifiers( type ) + buildQualifiers( td ) ); case ast::AggregateDecl::Trait: @@ -1132,5 +1142,5 @@ } // switch } else { - switch ( type->aggregate.kind ) { + switch ( td->aggregate.kind ) { case ast::AggregateDecl::Struct: case ast::AggregateDecl::Coroutine: @@ -1138,16 +1148,16 @@ case ast::AggregateDecl::Thread: return new ast::StructInstType( - *type->aggregate.name, - buildQualifiers( type ) + *td->aggregate.name, + buildQualifiers( td ) ); case ast::AggregateDecl::Union: return new ast::UnionInstType( - *type->aggregate.name, - buildQualifiers( type ) + *td->aggregate.name, + buildQualifiers( td ) ); case ast::AggregateDecl::Trait: return new ast::TraitInstType( - *type->aggregate.name, - buildQualifiers( type ) + *td->aggregate.name, + buildQualifiers( td ) ); default: Index: src/Parser/TypeData.h =================================================================== --- src/Parser/TypeData.h (revision 0522ebe7b3ae7204a1d2c50a1bc7273bfa36762a) +++ src/Parser/TypeData.h (revision f1149acdd1aec2da8d7e43ad6e4025f8b736412b) @@ -9,7 +9,7 @@ // Author : Peter A. Buhr // Created On : Sat May 16 15:18:36 2015 -// Last Modified By : Andrew Beach -// Last Modified On : Wed Mar 1 10:44:00 2023 -// Update Count : 206 +// Last Modified By : Peter A. Buhr +// Last Modified On : Thu Feb 22 16:30:31 2024 +// Update Count : 210 // @@ -30,11 +30,12 @@ ast::AggregateDecl::Aggregate kind; const std::string * name = nullptr; + const std::string * parent = nullptr; DeclarationNode * params = nullptr; ExpressionNode * actuals = nullptr; // holds actual parameters later applied to AggInst DeclarationNode * fields = nullptr; + std::vector> attributes; bool body; bool anon; bool tagged; - const std::string * parent = nullptr; }; Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision 0522ebe7b3ae7204a1d2c50a1bc7273bfa36762a) +++ src/Parser/parser.yy (revision f1149acdd1aec2da8d7e43ad6e4025f8b736412b) @@ -10,6 +10,6 @@ // Created On : Sat Sep 1 20:22:55 2001 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun Nov 26 13:18:06 2023 -// Update Count : 6398 +// Last Modified On : Fri Feb 23 18:25:46 2024 +// Update Count : 6484 // @@ -102,16 +102,36 @@ DeclarationNode * distAttr( DeclarationNode * typeSpec, DeclarationNode * declList ) { - // distribute declaration_specifier across all declared variables, e.g., static, const, but not __attribute__. + // Distribute type specifier across all declared variables, e.g., static, const, __attribute__. assert( declList ); - // printf( "distAttr1 typeSpec %p\n", typeSpec ); typeSpec->print( std::cout ); - DeclarationNode * cl = (new DeclarationNode)->addType( typeSpec ); - // printf( "distAttr2 cl %p\n", cl ); cl->type->print( std::cout ); - // cl->type->aggregate.name = cl->type->aggInst.aggregate->aggregate.name; - + + // Do not distribute attributes for aggregates because the attributes surrounding the aggregate belong it not the + // variables in the declaration list, e.g., + // + // struct __attribute__(( aligned(128) )) S { ... + // } v1 __attribute__(( aligned(64) )), v2 __attribute__(( aligned(32) )), v3; + // struct S v4; + // + // v1 => 64, v2 =>32, v3 => 128, v2 => 128 + // + // Anonymous aggregates are a special case because there is no aggregate to bind the attribute to; hence it floats + // to the declaration list. + // + // struct __attribute__(( aligned(128) )) /*anonymous */ { ... } v1; + // + // v1 => 128 + + bool copyattr = ! (typeSpec->type && typeSpec->type->kind == TypeData::Aggregate && ! typeSpec->type->aggregate.anon ); + + // addType copies the type information for the aggregate instances from typeSpec into cl's aggInst.aggregate. + DeclarationNode * cl = (new DeclarationNode)->addType( typeSpec ); // typeSpec IS DELETED!!! + + // Start at second variable in declaration list and clone the type specifiers for each variable.. for ( DeclarationNode * cur = dynamic_cast( declList->get_next() ); cur != nullptr; cur = dynamic_cast( cur->get_next() ) ) { - cl->cloneBaseType( cur ); + cl->cloneBaseType( cur, copyattr ); // cur is modified } // for - declList->addType( cl ); - // printf( "distAttr3 declList %p\n", declList ); declList->print( std::cout, 0 ); + + // Add first variable in declaration list with hidden type information in aggInst.aggregate, which is used by + // extractType to recover the type for the aggregate instances. + declList->addType( cl, copyattr ); // cl IS DELETED!!! return declList; } // distAttr @@ -192,8 +212,7 @@ fieldList = DeclarationNode::newName( nullptr ); } // if -// return distAttr( typeSpec, fieldList ); // mark all fields in list // printf( "fieldDecl3 typeSpec %p\n", typeSpec ); typeSpec->print( std::cout, 0 ); - DeclarationNode * temp = distAttr( typeSpec, fieldList ); // mark all fields in list + DeclarationNode * temp = distAttr( typeSpec, fieldList ); // mark all fields in list // printf( "fieldDecl4 temp %p\n", temp ); temp->print( std::cout, 0 ); return temp; @@ -761,6 +780,29 @@ | string_literal '`' identifier // CFA, postfix call { $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, build_postfix_name( $3 ) ) ), $1 ) ); } + + // SKULLDUGGERY: The typedef table used for parsing does not store fields in structures. To parse a qualified + // name, it is assumed all name-tokens after the first are identifiers, regardless of how the lexer identifies + // them. For example: + // + // struct S; + // forall(T) struct T; + // union U; + // enum E { S, T, E }; + // struct Z { int S, T, Z, E, U; }; + // void fred () { + // Z z; + // z.S; // lexer returns S is TYPEDEFname + // z.T; // lexer returns T is TYPEGENname + // z.Z; // lexer returns Z is TYPEDEFname + // z.U; // lexer returns U is TYPEDEFname + // z.E; // lexer returns E is TYPEDEFname + // } | postfix_expression '.' identifier { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_varref( yylloc, $3 ) ) ); } + | postfix_expression '.' TYPEDEFname // CFA, SKULLDUGGERY + { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_varref( yylloc, $3 ) ) ); } + | postfix_expression '.' TYPEGENname // CFA, SKULLDUGGERY + { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_varref( yylloc, $3 ) ) ); } + | postfix_expression '.' INTEGERconstant // CFA, tuple index { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_constantInteger( yylloc, *$3 ) ) ); } @@ -1039,7 +1081,6 @@ | logical_OR_expression '?' comma_expression ':' conditional_expression { $$ = new ExpressionNode( build_cond( yylloc, $1, $3, $5 ) ); } - // FIX ME: computes $1 twice | logical_OR_expression '?' /* empty */ ':' conditional_expression // GCC, omitted first operand - { $$ = new ExpressionNode( build_cond( yylloc, $1, $1->clone(), $4 ) ); } + { $$ = new ExpressionNode( build_cond( yylloc, $1, nullptr, $4 ) ); } ; @@ -1856,6 +1897,5 @@ declaration_list: declaration - | declaration_list declaration - { $$ = $1->appendList( $2 ); } + | declaration_list declaration { $$ = $1->appendList( $2 ); } ; @@ -1890,10 +1930,4 @@ declaration: // old & new style declarations c_declaration ';' - { - // printf( "C_DECLARATION1 %p %s\n", $$, $$->name ? $$->name->c_str() : "(nil)" ); - // for ( Attribute * attr: reverseIterate( $$->attributes ) ) { - // printf( "\tattr %s\n", attr->name.c_str() ); - // } // for - } | cfa_declaration ';' // CFA | static_assert // C11 @@ -2348,10 +2382,4 @@ sue_declaration_specifier: // struct, union, enum + storage class + type specifier sue_type_specifier - { - // printf( "sue_declaration_specifier %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" ); - // for ( Attribute * attr: reverseIterate( $$->attributes ) ) { - // printf( "\tattr %s\n", attr->name.c_str() ); - // } // for - } | declaration_qualifier_list sue_type_specifier { $$ = $2->addQualifiers( $1 ); } @@ -2364,10 +2392,4 @@ sue_type_specifier: // struct, union, enum + type specifier elaborated_type - { - // printf( "sue_type_specifier %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" ); - // for ( Attribute * attr: reverseIterate( $$->attributes ) ) { - // printf( "\tattr %s\n", attr->name.c_str() ); - // } // for - } | type_qualifier_list { if ( $1->type != nullptr && $1->type->forall ) forall = true; } // remember generic type @@ -2442,10 +2464,4 @@ elaborated_type: // struct, union, enum aggregate_type - { - // printf( "elaborated_type %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" ); - // for ( Attribute * attr: reverseIterate( $$->attributes ) ) { - // printf( "\tattr %s\n", attr->name.c_str() ); - // } // for - } | enum_type ; @@ -2679,5 +2695,5 @@ { $$ = DeclarationNode::newEnum( nullptr, $4, true, false )->addQualifiers( $2 ); } | ENUM attribute_list_opt '!' '{' enumerator_list comma_opt '}' // invalid syntax rule - { SemanticError( yylloc, "syntax error, hiding '!' the enumerator names of an anonymous enumeration means the names are inaccessible." ); $$ = nullptr; } + { SemanticError( yylloc, "syntax error, hiding ('!') the enumerator names of an anonymous enumeration means the names are inaccessible." ); $$ = nullptr; } | ENUM attribute_list_opt identifier { typedefTable.makeTypedef( *$3, "enum_type 1" ); } @@ -2694,5 +2710,5 @@ } | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt '!' '{' enumerator_list comma_opt '}' // unqualified type name - { SemanticError( yylloc, "syntax error, hiding '!' the enumerator names of an anonymous enumeration means the names are inaccessible." ); $$ = nullptr; } + { SemanticError( yylloc, "syntax error, hiding ('!') the enumerator names of an anonymous enumeration means the names are inaccessible." ); $$ = nullptr; } | ENUM '(' ')' attribute_list_opt '{' enumerator_list comma_opt '}' { @@ -2700,5 +2716,5 @@ } | ENUM '(' ')' attribute_list_opt '!' '{' enumerator_list comma_opt '}' // invalid syntax rule - { SemanticError( yylloc, "syntax error, hiding '!' the enumerator names of an anonymous enumeration means the names are inaccessible." ); $$ = nullptr; } + { SemanticError( yylloc, "syntax error, hiding ('!') the enumerator names of an anonymous enumeration means the names are inaccessible." ); $$ = nullptr; } | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt { @@ -3177,5 +3193,6 @@ // unit, which is a dubious task, especially because C uses name rather than structural typing; hence it is // disallowed at the moment. - if ( $1->linkage == ast::Linkage::Cforall && ! $1->storageClasses.is_static && $1->type && $1->type->kind == TypeData::AggregateInst ) { + if ( $1->linkage == ast::Linkage::Cforall && ! $1->storageClasses.is_static && + $1->type && $1->type->kind == TypeData::AggregateInst ) { if ( $1->type->aggInst.aggregate->kind == TypeData::Enum && $1->type->aggInst.aggregate->enumeration.anon ) { SemanticError( yylloc, "extern anonymous enumeration is currently unimplemented." ); $$ = nullptr;