Changes in / [054514d:da60c631]


Ignore:
Location:
src
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • src/CodeGen/CodeGenerator.cc

    r054514d rda60c631  
    172172        // *** Declarations
    173173        void CodeGenerator::postvisit( FunctionDecl * functionDecl ) {
    174                 // deleted decls should never be used, so don't print them
    175                 if ( functionDecl->isDeleted && genC ) return;
    176174                extension( functionDecl );
    177175                genAttributes( functionDecl->get_attributes() );
    … …  
    187185                        functionDecl->get_statements()->accept( *visitor );
    188186                } // if
    189                 if ( functionDecl->isDeleted ) {
    190                         output << " = void";
    191                 }
    192187        }
    193188
    194189        void CodeGenerator::postvisit( ObjectDecl * objectDecl ) {
    195                 // deleted decls should never be used, so don't print them
    196                 if ( objectDecl->isDeleted && genC ) return;
    197190                if (objectDecl->get_name().empty() && genC ) {
    198191                        // only generate an anonymous name when generating C code, otherwise it clutters the output too much
    … …  
    213206                        objectDecl->get_init()->accept( *visitor );
    214207                } // if
    215                 if ( objectDecl->isDeleted ) {
    216                         output << " = void";
    217                 }
    218208
    219209                if ( objectDecl->get_bitfieldWidth() ) {
    … …  
    837827                expr->expr->accept( *visitor );
    838828        }
    839 
    840         void CodeGenerator::postvisit( GenericExpr * expr ) {
    841                 assertf( ! genC, "C11 _Generic expressions should not reach code generation." );
    842                 output << "_Generic(";
    843                 expr->control->accept( *visitor );
    844                 output << ", ";
    845                 unsigned int numAssocs = expr->associations.size();
    846                 unsigned int i = 0;
    847                 for ( GenericExpr::Association & assoc : expr->associations ) {
    848                         if (assoc.isDefault) {
    849                                 output << "default: ";
    850                         } else {
    851                                 output << genType( assoc.type, "", pretty, genC ) << ": ";
    852                         }
    853                         assoc.expr->accept( *visitor );
    854                         if ( i+1 != numAssocs ) {
    855                                 output << ", ";
    856                         }
    857                         i++;
    858                 }
    859                 output << ")";
    860         }
    861 
    862829
    863830        // *** Statements

  • src/CodeGen/CodeGenerator.h

    r054514d rda60c631  
    9494                void postvisit( ConstructorExpr * );
    9595                void postvisit( DeletedExpr * );
    96                 void postvisit( GenericExpr * );
    9796
    9897                //*** Statements

  • src/Common/PassVisitor.h

    r054514d rda60c631  
    125125        virtual void visit( InitExpr *  initExpr ) override final;
    126126        virtual void visit( DeletedExpr *  delExpr ) override final;
    127         virtual void visit( GenericExpr * genExpr ) override final;
    128127
    129128        virtual void visit( VoidType * basicType ) override final;
    … …  
    224223        virtual Expression * mutate( InitExpr *  initExpr ) override final;
    225224        virtual Expression * mutate( DeletedExpr *  delExpr ) override final;
    226         virtual Expression * mutate( GenericExpr * genExpr ) override final;
    227225
    228226        virtual Type * mutate( VoidType * basicType ) override final;
    … …  
    313311        void indexerAddUnionFwd ( UnionDecl                 * node  ) { indexer_impl_addUnionFwd ( pass, 0, node ); }
    314312        void indexerAddTrait    ( TraitDecl                 * node  ) { indexer_impl_addTrait    ( pass, 0, node ); }
    315         void indexerAddWith     ( std::list< Expression * > & exprs, BaseSyntaxNode * withStmt ) { indexer_impl_addWith( pass, 0, exprs, withStmt ); }
     313        void indexerAddWith     ( std::list< Expression * > & exprs, BaseSyntaxNode * withStmt ) { indexer_impl_addWith     ( pass, 0, exprs, withStmt ); }
    316314
    317315

  • src/Common/PassVisitor.impl.h

    r054514d rda60c631  
    20732073
    20742074//--------------------------------------------------------------------------
    2075 // GenericExpr
    2076 template< typename pass_type >
    2077 void PassVisitor< pass_type >::visit( GenericExpr * node ) {
    2078         VISIT_START( node );
    2079 
    2080         indexerScopedAccept( node->result, *this );
    2081         maybeAccept_impl( node->control, *this );
    2082         for ( GenericExpr::Association & assoc : node->associations ) {
    2083                 indexerScopedAccept( assoc.type, *this );
    2084                 maybeAccept_impl( assoc.expr, *this );
    2085         }
    2086 
    2087         VISIT_END( node );
    2088 }
    2089 
    2090 template< typename pass_type >
    2091 Expression * PassVisitor< pass_type >::mutate( GenericExpr * node ) {
    2092         MUTATE_START( node );
    2093 
    2094         indexerScopedMutate( node->env, *this );
    2095         indexerScopedMutate( node->result, *this );
    2096         maybeMutate_impl( node->control, *this );
    2097         for ( GenericExpr::Association & assoc : node->associations ) {
    2098                 indexerScopedMutate( assoc.type, *this );
    2099                 maybeMutate_impl( assoc.expr, *this );
    2100         }
    2101 
    2102         MUTATE_END( Expression, node );
    2103 }
    2104 
    2105 //--------------------------------------------------------------------------
    21062075// VoidType
    21072076template< typename pass_type >

  • src/Parser/DeclarationNode.cc

    r054514d rda60c631  
    10671067                        SemanticError( this, "invalid function specifier for " );
    10681068                } // if
    1069                 bool isDelete = initializer && initializer->get_isDelete();
    1070                 Declaration * decl = buildDecl( type, name ? *name : string( "" ), storageClasses, maybeBuild< Expression >( bitfieldWidth ), funcSpecs, linkage, asmName, isDelete ? nullptr : maybeBuild< Initializer >(initializer), attributes )->set_extension( extension );
    1071                 if ( isDelete ) {
    1072                         DeclarationWithType * dwt = strict_dynamic_cast<DeclarationWithType *>( decl );
    1073                         dwt->isDeleted = true;
    1074                 }
    1075                 return decl;
     1069                return buildDecl( type, name ? *name : string( "" ), storageClasses, maybeBuild< Expression >( bitfieldWidth ), funcSpecs, linkage, asmName, maybeBuild< Initializer >(initializer), attributes )->set_extension( extension );
    10761070        } // if
    10771071

  • src/Parser/InitializerNode.cc

    r054514d rda60c631  
    2727
    2828InitializerNode::InitializerNode( ExpressionNode * _expr, bool aggrp, ExpressionNode * des )
    29                 : expr( _expr ), aggregate( aggrp ), designator( des ), kids( nullptr ), maybeConstructed( true ), isDelete( false ) {
     29                : expr( _expr ), aggregate( aggrp ), designator( des ), kids( nullptr ), maybeConstructed( true ) {
    3030        if ( aggrp )
    3131                kids = dynamic_cast< InitializerNode * >( get_next() );
    … …  
    3636
    3737InitializerNode::InitializerNode( InitializerNode * init, bool aggrp, ExpressionNode * des )
    38                 : expr( nullptr ), aggregate( aggrp ), designator( des ), kids( nullptr ), maybeConstructed( true ), isDelete( false ) {
     38                : expr( nullptr ), aggregate( aggrp ), designator( des ), kids( nullptr ), maybeConstructed( true ) {
    3939        if ( init )
    4040                set_last( init );
    … …  
    4646                set_next( nullptr );
    4747} // InitializerNode::InitializerNode
    48 
    49 InitializerNode::InitializerNode( bool isDelete ) : expr( nullptr ), aggregate( false ), designator( nullptr ), kids( nullptr ), maybeConstructed( false ), isDelete( isDelete ) {}
    5048
    5149InitializerNode::~InitializerNode() {
    … …  
    8684
    8785Initializer * InitializerNode::build() const {
    88         assertf( ! isDelete, "Should not build delete stmt InitializerNode" );
    8986        if ( aggregate ) {
    9087                // steal designators from children

  • src/Parser/ParseNode.h

    r054514d rda60c631  
    8787        InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode * des = nullptr );
    8888        InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr );
    89         InitializerNode( bool isDelete );
    9089        ~InitializerNode();
    9190        virtual InitializerNode * clone() const { assert( false ); return nullptr; }
    … …  
    9897        InitializerNode * set_maybeConstructed( bool value ) { maybeConstructed = value; return this; }
    9998        bool get_maybeConstructed() const { return maybeConstructed; }
    100 
    101         bool get_isDelete() const { return isDelete; }
    10299
    103100        InitializerNode * next_init() const { return kids; }
    … …  
    113110        InitializerNode * kids;
    114111        bool maybeConstructed;
    115         bool isDelete;
    116112}; // InitializerNode
    117113

  • src/Parser/parser.yy

    r054514d rda60c631  
    175175        bool flag;
    176176        CatchStmt::Kind catch_kind;
    177         GenericExpr * genexpr;
    178177}
    179178
    … …  
    260259%type<flag> asm_volatile_opt
    261260%type<en> handler_predicate_opt
    262 %type<genexpr> generic_association generic_assoc_list
    263261
    264262// statements
    … …  
    503501                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
    504502        | GENERIC '(' assignment_expression ',' generic_assoc_list ')' // C11
    505                 {
    506                         // add the missing control expression to the GenericExpr and return it
    507                         $5->control = maybeMoveBuild<Expression>( $3 );
    508                         $$ = new ExpressionNode( $5 );
    509                 }
     503                { SemanticError( yylloc, "_Generic is currently unimplemented." ); $$ = nullptr; }
    510504        ;
    511505
    512506generic_assoc_list:                                                                             // C11
    513         generic_association
     507        | generic_association
    514508        | generic_assoc_list ',' generic_association
    515                 {
    516                         // steal the association node from the singleton and delete the wrapper
    517                         $1->associations.splice($1->associations.end(), $3->associations);
    518                         delete $3;
    519                         $$ = $1;
    520                 }
    521509        ;
    522510
    523511generic_association:                                                                    // C11
    524512        type_no_function ':' assignment_expression
    525                 {
    526                         // create a GenericExpr wrapper with one association pair
    527                         $$ = new GenericExpr( nullptr, { { maybeMoveBuildType($1), maybeMoveBuild<Expression>($3) } } );
    528                 }
    529513        | DEFAULT ':' assignment_expression
    530                 { $$ = new GenericExpr( nullptr, { { maybeMoveBuild<Expression>($3) } } ); }
    531514        ;
    532515
    … …  
    21012084                { $$ = $2; }
    21022085        | '=' VOID
    2103                 { $$ = new InitializerNode( true ); }
     2086                { $$ = nullptr; }
    21042087        | ATassign initializer
    21052088                { $$ = $2->set_maybeConstructed( false ); }

  • src/ResolvExpr/AlternativeFinder.cc

    r054514d rda60c631  
    9797                void postvisit( InitExpr * initExpr );
    9898                void postvisit( DeletedExpr * delExpr );
    99                 void postvisit( GenericExpr * genExpr );
    10099
    101100                /// Adds alternatives for anonymous members
    … …  
    17571756                assertf( false, "AlternativeFinder should never see a DeletedExpr." );
    17581757        }
    1759 
    1760         void AlternativeFinder::Finder::postvisit( GenericExpr * ) {
    1761                 assertf( false, "_Generic is not yet supported." );
    1762         }
    17631758} // namespace ResolvExpr
    17641759

  • src/SymTab/Indexer.cc

    r054514d rda60c631  
    148148                for ( auto decl : copy ) {
    149149                        if ( FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl.id ) ) {
    150                                 std::list< DeclarationWithType * > & params = function->type->parameters;
     150                                std::list< DeclarationWithType * > & params = function->get_functionType()->get_parameters();
    151151                                assert( ! params.empty() );
    152152                                // use base type of pointer, so that qualifiers on the pointer type aren't considered.
    … …  
    170170                                bool noUserDefinedFunc = ! val.existsUserDefinedFunc;
    171171                                bool isUserDefinedFunc = ball.isUserDefinedFunc;
    172                                 bool isAcceptableDefaultCtor = (! val.existsUserDefinedCtor || (! val.existsUserDefinedDefaultCtor && ball.decl.id->linkage == LinkageSpec::Intrinsic)) && ball.isDefaultCtor; // allow default constructors only when no user-defined constructors exist, except in the case of intrinsics, which require exact overrides
     172                                bool isAcceptableDefaultCtor = (! val.existsUserDefinedCtor || (! val.existsUserDefinedDefaultCtor && ball.decl.id->get_linkage() == LinkageSpec::Intrinsic)) && ball.isDefaultCtor; // allow default constructors only when no user-defined constructors exist, except in the case of intrinsics, which require exact overrides
    173173                                bool isAcceptableCopyFunc = ! val.existsUserDefinedCopyFunc && ball.isCopyFunc; // handles copy ctor and assignment operator
    174174                                bool isAcceptableDtor = ! val.existsUserDefinedDtor && ball.isDtor;
    … …  
    471471        void Indexer::addId( DeclarationWithType * decl, Expression * baseExpr ) {
    472472                // default handling of conflicts is to raise an error
    473                 addId( decl, [decl](IdData &, const std::string & msg) { SemanticError( decl, msg ); return true; }, baseExpr, decl->isDeleted ? decl : nullptr );
     473                addId( decl, [decl](IdData &, const std::string & msg) { SemanticError( decl, msg ); return true; }, baseExpr );
    474474        }
    475475

  • src/SymTab/Mangler.cc

    r054514d rda60c631  
    225225                                GuardValue( inFunctionType );
    226226                                inFunctionType = true;
    227                                 std::list< Type* > returnTypes = getTypes( functionType->returnVals );
     227                                std::list< Type* > returnTypes = getTypes( functionType->get_returnVals() );
    228228                                acceptAll( returnTypes, *visitor );
    229229                                mangleName << "_";
    230                                 std::list< Type* > paramTypes = getTypes( functionType->parameters );
     230                                std::list< Type* > paramTypes = getTypes( functionType->get_parameters() );
    231231                                acceptAll( paramTypes, *visitor );
    232232                                mangleName << "_";
    … …  
    236236                                printQualifiers( refType );
    237237
    238                                 mangleName << ( refType->name.length() + prefix.length() ) << prefix << refType->name;
     238                                mangleName << ( refType->get_name().length() + prefix.length() ) << prefix << refType->get_name();
    239239
    240240                                if ( mangleGenericParams ) {
    241                                         std::list< Expression* >& params = refType->parameters;
     241                                        std::list< Expression* >& params = refType->get_parameters();
    242242                                        if ( ! params.empty() ) {
    243243                                                mangleName << "_";
    244244                                                for ( std::list< Expression* >::const_iterator param = params.begin(); param != params.end(); ++param ) {
    245245                                                        TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
    246                                                         assertf(paramType, "Aggregate parameters should be type expressions: %s", toCString(*param));
    247                                                         maybeAccept( paramType->type, *visitor );
     246                                                        assertf(paramType, "Aggregate parameters should be type expressions: %s", toString(*param).c_str());
     247                                                        maybeAccept( paramType->get_type(), *visitor );
    248248                                                }
    249249                                                mangleName << "_";

  • src/SynTree/Declaration.cc

    r054514d rda60c631  
    104104}
    105105
    106 
    107106// Local Variables: //
    108107// tab-width: 4 //

  • src/SynTree/Declaration.h

    r054514d rda60c631  
    8484        Expression *asmName;
    8585        std::list< Attribute * > attributes;
    86         bool isDeleted = false;
    8786
    8887        DeclarationWithType( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, Type::FuncSpecifiers fs );

  • src/SynTree/Expression.cc

    r054514d rda60c631  
    748748}
    749749
    750 GenericExpr::Association::Association( Type * type, Expression * expr ) : type( type ), expr( expr ), isDefault( false ) {}
    751 GenericExpr::Association::Association( Expression * expr ) : type( nullptr ), expr( expr ), isDefault( true ) {}
    752 GenericExpr::Association::Association( const Association & other ) : type( maybeClone( other.type ) ), expr( maybeClone( other.expr ) ), isDefault( other.isDefault ) {}
    753 GenericExpr::Association::~Association() {
    754         delete type;
    755         delete expr;
    756 }
    757 
    758 GenericExpr::GenericExpr( Expression * control, const std::list<Association> & assoc ) : Expression(), control( control ), associations( assoc ) {}
    759 GenericExpr::GenericExpr( const GenericExpr & other ) : Expression(other), control( maybeClone( other.control ) ), associations( other.associations ) {
    760 }
    761 GenericExpr::~GenericExpr() {
    762         delete control;
    763 }
    764 
    765 void GenericExpr::print( std::ostream & os, Indenter indent ) const {
    766         os << "C11 _Generic Expression" << std::endl << indent+1;
    767         control->print( os, indent+1 );
    768         os << std::endl << indent+1 << "... with associations: " << std::endl;
    769         for ( const Association & assoc : associations ) {
    770                 os << indent+1;
    771                 if (assoc.isDefault) {
    772                         os << "... default: ";
    773                         assoc.expr->print( os, indent+1 );
    774                 } else {
    775                         os << "... type: ";
    776                         assoc.type->print( os, indent+1 );
    777                         os << std::endl << indent+1 << "... expression: ";
    778                         assoc.expr->print( os, indent+1 );
    779                         os << std::endl;
    780                 }
    781                 os << std::endl;
    782         }
    783 }
    784750
    785751// Local Variables: //

  • src/SynTree/Expression.h

    r054514d rda60c631  
    865865};
    866866
    867 /// C11 _Generic expression
    868 class GenericExpr : public Expression {
    869 public:
    870         struct Association {
    871                 Type * type = nullptr;
    872                 Expression * expr = nullptr;
    873                 bool isDefault = false;
    874 
    875                 Association( Type * type, Expression * expr );
    876                 Association( Expression * expr );
    877                 Association( const Association & other );
    878                 Association & operator=( const Association & other ) = delete; // at the moment this isn't used, and I don't want to implement it
    879                 ~Association();
    880         };
    881 
    882         Expression * control;
    883         std::list<Association> associations;
    884 
    885         GenericExpr( Expression * control, const std::list<Association> & assoc );
    886         GenericExpr( const GenericExpr & other );
    887         virtual ~GenericExpr();
    888 
    889         virtual GenericExpr * clone() const { return new GenericExpr( * this ); }
    890         virtual void accept( Visitor & v ) { v.visit( this ); }
    891         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    892         virtual void print( std::ostream & os, Indenter indent = {} ) const;
    893 };
    894 
    895867// Local Variables: //
    896868// tab-width: 4 //

  • src/SynTree/Mutator.h

    r054514d rda60c631  
    9393        virtual Expression * mutate( InitExpr  * initExpr ) = 0;
    9494        virtual Expression * mutate( DeletedExpr * delExpr ) = 0;
    95         virtual Expression * mutate( GenericExpr * genExpr ) = 0;
    9695
    9796        virtual Type * mutate( VoidType * basicType ) = 0;

  • src/SynTree/SynTree.h

    r054514d rda60c631  
    101101class InitExpr;
    102102class DeletedExpr;
    103 class GenericExpr;
    104103
    105104class Type;

  • src/SynTree/Visitor.h

    r054514d rda60c631  
    9595        virtual void visit( InitExpr *  initExpr ) = 0;
    9696        virtual void visit( DeletedExpr * delExpr ) = 0;
    97         virtual void visit( GenericExpr * genExpr ) = 0;
    9897
    9998        virtual void visit( VoidType * basicType ) = 0;
Note: See TracChangeset for help on using the changeset viewer.