Changes in / [d93b813:3d618a0]


Ignore:
Files:
22 edited

Legend:

Unmodified
Added
Removed

  • src/AST/Expr.cpp

    rd93b813 r3d618a0  
    276276// --- SizeofExpr
    277277
    278 SizeofExpr::SizeofExpr( const CodeLocation & loc, const Expr * e )
    279 : Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), expr( e ), type( nullptr ) {}
    280 
    281278SizeofExpr::SizeofExpr( const CodeLocation & loc, const Type * t )
    282 : Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), expr( nullptr ), type( t ) {}
     279: Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), type( t ) {}
    283280
    284281// --- CountExpr
    … …  
    292289// --- AlignofExpr
    293290
    294 AlignofExpr::AlignofExpr( const CodeLocation & loc, const Expr * e )
    295 : Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), expr( e ), type( nullptr ) {}
    296 
    297291AlignofExpr::AlignofExpr( const CodeLocation & loc, const Type * t )
    298 : Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), expr( nullptr ), type( t ) {}
     292: Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), type( t ) {}
    299293
    300294// --- OffsetofExpr

  • src/AST/Expr.hpp

    rd93b813 r3d618a0  
    480480class SizeofExpr final : public Expr {
    481481public:
     482        ptr<Type> type;
     483
     484        SizeofExpr( const CodeLocation & loc, const Type * t );
     485
     486        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
     487private:
     488        SizeofExpr * clone() const override { return new SizeofExpr{ *this }; }
     489        MUTATE_FRIEND
     490};
     491
     492class CountExpr final : public Expr {
     493public:
    482494        ptr<Expr> expr;
    483495        ptr<Type> type;
    484496
    485         SizeofExpr( const CodeLocation & loc, const Expr * e );
    486         SizeofExpr( const CodeLocation & loc, const Type * t );
    487         // deliberately no disambiguating overload for nullptr_t
    488 
    489         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
    490 private:
    491         SizeofExpr * clone() const override { return new SizeofExpr{ *this }; }
    492         MUTATE_FRIEND
    493 };
    494 
    495 class CountExpr final : public Expr {
    496 public:
    497         ptr<Expr> expr;
    498         ptr<Type> type;
    499 
    500497        CountExpr( const CodeLocation & loc, const Expr * t );
    501498        CountExpr( const CodeLocation & loc, const Type * t );
    … …  
    510507class AlignofExpr final : public Expr {
    511508public:
    512         ptr<Expr> expr;
    513509        ptr<Type> type;
    514510
    515         AlignofExpr( const CodeLocation & loc, const Expr * e );
    516511        AlignofExpr( const CodeLocation & loc, const Type * t );
    517         // deliberately no disambiguating overload for nullptr_t
    518512
    519513        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }

  • src/AST/Pass.hpp

    rd93b813 r3d618a0  
    342342/// set visit_children false of all child nodes should be ignored
    343343struct WithShortCircuiting {
    344         bool visit_children;
     344        bool visit_children = true;
    345345};
    346346

  • src/AST/Pass.impl.hpp

    rd93b813 r3d618a0  
    13191319                        maybe_accept( node, &SizeofExpr::result );
    13201320                }
    1321                 if ( node->type ) {
    1322                         maybe_accept( node, &SizeofExpr::type );
    1323                 } else {
    1324                         maybe_accept( node, &SizeofExpr::expr );
    1325                 }
     1321                maybe_accept( node, &SizeofExpr::type );
    13261322        }
    13271323
    … …  
    13591355                        maybe_accept( node, &AlignofExpr::result );
    13601356                }
    1361                 if ( node->type ) {
    1362                         maybe_accept( node, &AlignofExpr::type );
    1363                 } else {
    1364                         maybe_accept( node, &AlignofExpr::expr );
    1365                 }
     1357                maybe_accept( node, &AlignofExpr::type );
    13661358        }
    13671359

  • src/AST/Print.cpp

    rd93b813 r3d618a0  
    11521152                os << "Sizeof Expression on: ";
    11531153                ++indent;
     1154                node->type->accept( *this );
     1155                --indent;
     1156                postprint( node );
     1157
     1158                return node;
     1159        }
     1160
     1161        virtual const ast::Expr * visit( const ast::CountExpr * node ) override final {
     1162                os << "Count Expression on: ";
     1163                ++indent;
    11541164                if ( node->type ) node->type->accept( *this );
    11551165                else safe_print( node->expr );
    11561166                --indent;
    11571167                postprint( node );
    1158 
    1159                 return node;
    1160         }
    1161 
    1162         virtual const ast::Expr * visit( const ast::CountExpr * node ) override final {
    1163                 os << "Count Expression on: ";
    1164                 ++indent;
    1165                 if ( node->type ) node->type->accept( *this );
    1166                 else safe_print( node->expr );
    1167                 --indent;
    1168                 postprint( node );
    11691168                return node;
    11701169        }
    … …  
    11731172                os << "Alignof Expression on: ";
    11741173                ++indent;
    1175                 if ( node->type ) node->type->accept( *this );
    1176                 else safe_print( node->expr );
     1174                node->type->accept( *this );
    11771175                --indent;
    11781176                postprint( node );

  • src/AST/Util.cpp

    rd93b813 r3d618a0  
    104104        }
    105105        assertf( false, "Member not found." );
    106 }
    107 
    108 template<typename node_t>
    109 void oneOfExprOrType( const node_t * node ) {
    110         if ( node->expr ) {
    111                 assertf( node->expr && !node->type, "Exactly one of expr or type should be set." );
    112         } else {
    113                 assertf( !node->expr && node->type, "Exactly one of expr or type should be set." );
    114         }
    115106}
    116107
    … …  
    159150                previsit( (const ParseNode *)node );
    160151                memberMatchesAggregate( node );
    161         }
    162 
    163         void previsit( const SizeofExpr * node ) {
    164                 previsit( (const ParseNode *)node );
    165                 oneOfExprOrType( node );
    166         }
    167 
    168         void previsit( const AlignofExpr * node ) {
    169                 previsit( (const ParseNode *)node );
    170                 oneOfExprOrType( node );
    171152        }
    172153

  • src/CodeGen/CodeGenerator.cpp

    rd93b813 r3d618a0  
    744744        extension( expr );
    745745        output << "sizeof(";
    746         if ( expr->type ) {
     746        if ( auto type = expr->type.as<ast::TypeofType>() ) {
     747                type->expr->accept( *visitor );
     748        } else {
    747749                output << genType( expr->type, "", options );
    748         } else {
    749                 expr->expr->accept( *visitor );
    750750        }
    751751        output << ")";
    … …  
    756756        extension( expr );
    757757        output << "__alignof__(";
    758         if ( expr->type ) {
     758        if ( auto type = expr->type.as<ast::TypeofType>() ) {
     759                type->expr->accept( *visitor );
     760        } else {
    759761                output << genType( expr->type, "", options );
    760         } else {
    761                 expr->expr->accept( *visitor );
    762762        }
    763763        output << ")";

  • src/Concurrency/Waitfor.cpp

    rd93b813 r3d618a0  
    230230                        ast::ConstantExpr::from_int( location, 0 ),
    231231                        new ast::SizeofExpr( location,
    232                                 new ast::VariableExpr( location, acceptables ) ),
     232                                new ast::TypeofType(
     233                                        new ast::VariableExpr( location, acceptables ) ) ),
    233234                }
    234235        );

  • src/GenPoly/Box.cpp

    rd93b813 r3d618a0  
    19251925ast::Expr const * PolyGenericCalculator::postvisit(
    19261926                ast::SizeofExpr const * expr ) {
    1927         ast::Type const * type = expr->type ? expr->type : expr->expr->result;
    1928         ast::Expr const * gen = genSizeof( expr->location, type );
     1927        ast::Expr const * gen = genSizeof( expr->location, expr->type );
    19291928        return ( gen ) ? gen : expr;
    19301929}
    … …  
    19321931ast::Expr const * PolyGenericCalculator::postvisit(
    19331932                ast::AlignofExpr const * expr ) {
    1934         ast::Type const * type = expr->type ? expr->type : expr->expr->result;
    1935         ast::Expr const * gen = genAlignof( expr->location, type );
     1933        ast::Expr const * gen = genAlignof( expr->location, expr->type );
    19361934        return ( gen ) ? gen : expr;
    19371935}

  • src/GenPoly/GenPoly.cpp

    rd93b813 r3d618a0  
    299299                ast::SizeofExpr const * r = as<ast::SizeofExpr>(rhs);
    300300
    301                 assert((l->type != nullptr) ^ (l->expr != nullptr));
    302                 assert((r->type != nullptr) ^ (r->expr != nullptr));
    303                 if ( !(l->type && r->type) ) return false;
     301                assert( l->type );
     302                assert( r->type );
    304303
    305304                // mutual recursion with type poly compatibility

  • src/GenPoly/Lvalue.cpp

    rd93b813 r3d618a0  
    607607ast::SizeofExpr const * ReferenceTypeElimination::previsit(
    608608                ast::SizeofExpr const * expr ) {
    609         if ( expr->expr ) return expr;
    610609        return ast::mutate_field( expr, &ast::SizeofExpr::type,
    611610                expr->type->stripReferences() );
    … …  
    614613ast::AlignofExpr const * ReferenceTypeElimination::previsit(
    615614                ast::AlignofExpr const * expr ) {
    616         if ( expr->expr ) return expr;
    617615        return ast::mutate_field( expr, &ast::AlignofExpr::type,
    618616                expr->type->stripReferences() );

  • src/Parser/StatementNode.cpp

    rd93b813 r3d618a0  
    1111// Created On       : Sat May 16 14:59:41 2015
    1212// Last Modified By : Peter A. Buhr
    13 // Last Modified On : Fri Aug 11 11:44:15 2023
    14 // Update Count     : 429
     13// Last Modified On : Mon Sep  9 11:28:07 2024
     14// Update Count     : 430
    1515//
    1616
    … …  
    208208
    209209ast::Stmt * build_for( const CodeLocation & location, ForCtrl * forctl, StatementNode * stmt, StatementNode * else_ ) {
    210         std::vector<ast::ptr<ast::Stmt>> astinit;                                               // maybe empty
     210        std::vector<ast::ptr<ast::Stmt>> astinit;                       // maybe empty
    211211        buildMoveList( forctl->init, astinit );
    212212
    213213        if ( forctl->range_over ) {
    214214                ast::Expr * range_over = maybeMoveBuild( forctl->range_over );
     215                auto kind = forctl->kind;                                               // save before delete, used in return
    215216                delete forctl;
    216217                return new ast::ForStmt( location,
    217218                        std::move( astinit ),
    218                         range_over, forctl->kind == OperKinds::LEThan,
     219                        range_over, kind == OperKinds::LEThan,
    219220                        buildMoveSingle( stmt ),
    220221                        buildMoveOptional( else_ )

  • src/Parser/TypeData.cpp

    rd93b813 r3d618a0  
    14761476                } else if ( cur->has_enumeratorValue() ) {
    14771477                        ast::Expr * initValue;
    1478                         if (ret->isCfa && ret->base) {
    1479                                 initValue = new ast::CastExpr( cur->enumeratorValue->location, maybeMoveBuild( cur->consume_enumeratorValue() ), ret->base  );
     1478                        if ( ret->isCfa && ret->base ) {
     1479                                CodeLocation location = cur->enumeratorValue->location;
     1480                                initValue = new ast::CastExpr( location, maybeMoveBuild( cur->consume_enumeratorValue() ), ret->base );
    14801481                        } else {
    14811482                                initValue = maybeMoveBuild( cur->consume_enumeratorValue() );

  • src/Parser/parser.yy

    rd93b813 r3d618a0  
    927927                { $$ = new ExpressionNode( build_unary_val( yylloc, OperKinds::Decr, $2 ) ); }
    928928        | SIZEOF unary_expression
    929                 { $$ = new ExpressionNode( new ast::SizeofExpr( yylloc, maybeMoveBuild( $2 ) ) ); }
     929                { $$ = new ExpressionNode( new ast::SizeofExpr( yylloc, new ast::TypeofType( maybeMoveBuild( $2 ) ) ) ); }
    930930        | SIZEOF '(' type_no_function ')'
    931931                { $$ = new ExpressionNode( new ast::SizeofExpr( yylloc, maybeMoveBuildType( $3 ) ) ); }
    932932        | ALIGNOF unary_expression                                                      // GCC, variable alignment
    933                 { $$ = new ExpressionNode( new ast::AlignofExpr( yylloc, maybeMoveBuild( $2 ) ) ); }
     933                { $$ = new ExpressionNode( new ast::AlignofExpr( yylloc, new ast::TypeofType( maybeMoveBuild( $2 ) ) ) ); }
    934934        | ALIGNOF '(' type_no_function ')'                                      // GCC, type alignment
    935935                { $$ = new ExpressionNode( new ast::AlignofExpr( yylloc, maybeMoveBuildType( $3 ) ) ); }

  • src/ResolvExpr/CandidateFinder.cpp

    rd93b813 r3d618a0  
    1010// Created On       : Wed Jun 5 14:30:00 2019
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jun 22 08:07:26 2024
    13 // Update Count     : 4
     12// Last Modified On : Mon Sep  9 11:30:11 2024
     13// Update Count     : 5
    1414//
    1515
    … …  
    12391239                CandidateList matches;
    12401240                Cost minExprCost = Cost::infinity;
    1241                 Cost minCastCost = Cost::infinity;
     1241                // Cost minCastCost = Cost::infinity;
    12421242                for ( CandidateRef & cand : finder.candidates ) {
    12431243                        ast::ptr< ast::Type > fromType = cand->expr->result;
    … …  
    14821482
    14831483        void Finder::postvisit( const ast::SizeofExpr * sizeofExpr ) {
    1484                 if ( sizeofExpr->type ) {
    1485                         addCandidate(
    1486                                 new ast::SizeofExpr{
    1487                                         sizeofExpr->location, resolveTypeof( sizeofExpr->type, context ) },
    1488                                 tenv );
    1489                 } else {
    1490                         // find all candidates for the argument to sizeof
    1491                         CandidateFinder finder( context, tenv );
    1492                         finder.find( sizeofExpr->expr );
    1493                         // find the lowest-cost candidate, otherwise ambiguous
    1494                         CandidateList winners = findMinCost( finder.candidates );
    1495                         if ( winners.size() != 1 ) {
    1496                                 SemanticError(
    1497                                         sizeofExpr->expr.get(), "Ambiguous expression in sizeof operand: " );
    1498                         }
    1499                         // return the lowest-cost candidate
    1500                         CandidateRef & choice = winners.front();
    1501                         choice->expr = referenceToRvalueConversion( choice->expr, choice->cost );
    1502                         choice->cost = Cost::zero;
    1503                         addCandidate( *choice, new ast::SizeofExpr{ sizeofExpr->location, choice->expr } );
    1504                 }
     1484                addCandidate(
     1485                        new ast::SizeofExpr{
     1486                                sizeofExpr->location, resolveTypeof( sizeofExpr->type, context ) },
     1487                        tenv );
    15051488        }
    15061489
    … …  
    15371520
    15381521        void Finder::postvisit( const ast::AlignofExpr * alignofExpr ) {
    1539                 if ( alignofExpr->type ) {
    1540                         addCandidate(
    1541                                 new ast::AlignofExpr{
    1542                                         alignofExpr->location, resolveTypeof( alignofExpr->type, context ) },
    1543                                 tenv );
    1544                 } else {
    1545                         // find all candidates for the argument to alignof
    1546                         CandidateFinder finder( context, tenv );
    1547                         finder.find( alignofExpr->expr );
    1548                         // find the lowest-cost candidate, otherwise ambiguous
    1549                         CandidateList winners = findMinCost( finder.candidates );
    1550                         if ( winners.size() != 1 ) {
    1551                                 SemanticError(
    1552                                         alignofExpr->expr.get(), "Ambiguous expression in alignof operand: " );
    1553                         }
    1554                         // return the lowest-cost candidate
    1555                         CandidateRef & choice = winners.front();
    1556                         choice->expr = referenceToRvalueConversion( choice->expr, choice->cost );
    1557                         choice->cost = Cost::zero;
    1558                         addCandidate(
    1559                                 *choice, new ast::AlignofExpr{ alignofExpr->location, choice->expr } );
    1560                 }
     1522                addCandidate(
     1523                        new ast::AlignofExpr{
     1524                                alignofExpr->location, resolveTypeof( alignofExpr->type, context ) },
     1525                        tenv );
    15611526        }
    15621527

  • src/ResolvExpr/ConversionCost.cpp

    rd93b813 r3d618a0  
    192192
    193193Cost enumCastCost (
    194         const ast::EnumInstType * src, const ast::EnumInstType * dst, 
     194        const ast::EnumInstType * src, const ast::EnumInstType * dst,
    195195        const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
    196196);
    … …  
    488488// (dst) src is safe is src is a subtype of dst, or dst {inline src, ...}
    489489Cost enumCastCost (
    490         const ast::EnumInstType * src, const ast::EnumInstType * dst, 
     490        const ast::EnumInstType * src, const ast::EnumInstType * dst,
    491491        const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
    492492) {

  • src/ResolvExpr/Unify.cpp

    rd93b813 r3d618a0  
    234234                        if ( !e2so ) return;
    235235
    236                         assert((e1->type != nullptr) ^ (e1->expr != nullptr));
    237                         assert((e2so->type != nullptr) ^ (e2so->expr != nullptr));
    238                         if ( !(e1->type && e2so->type) ) return;
    239 
    240236                        // expression unification calls type unification (mutual recursion)
    241237                        result = unifyExact( e1->type, e2so->type, tenv, need, have, open, widen );

  • src/Validate/InitializerLength.cpp

    rd93b813 r3d618a0  
    2929///   int x[] = { 1, 2, 3 };
    3030///   int y[][2] = { { 1, 2, 3 }, { 1, 2, 3 } };
     31///   char z[] = "hello";
    3132/// here x and y are known at compile-time to have length 3, so change this into
    3233///   int x[3] = { 1, 2, 3 };
    3334///   int y[3][2] = { { 1, 2, 3 }, { 1, 2, 3 } };
     35///   char z[6] = "hello";
    3436struct InitializerLength {
    3537        const ast::ObjectDecl * previsit( const ast::ObjectDecl * decl );
    3638};
    3739
     40ast::ConstantExpr * makeDimension( const ast::ObjectDecl * decl ) {
     41        if ( auto init = decl->init.as<ast::ListInit>() ) {
     42                return ast::ConstantExpr::from_ulong( decl->location, init->size() );
     43        } else if ( auto init = decl->init.as<ast::SingleInit>() ) {
     44                if ( auto constant = init->value.as<ast::ConstantExpr>() ) {
     45                        if ( auto type = constant->result.as<ast::ArrayType>() ) {
     46                                if ( auto dim = type->dimension.as<ast::ConstantExpr>() ) {
     47                                        ast::ConstantExpr * dimension = ast::deepCopy( dim );
     48                                        dimension->location = decl->location;
     49                                        return dimension;
     50                                }
     51                        }
     52                }
     53        }
     54        return nullptr;
     55}
     56
    3857const ast::ObjectDecl * InitializerLength::previsit( const ast::ObjectDecl * decl ) {
    3958        if ( auto type = decl->type.as<ast::ArrayType>() ) {
    4059                if ( type->dimension ) return decl;
    41                 if ( auto init = decl->init.as<ast::ListInit>() ) {
     60                if ( auto dimension = makeDimension( decl ) ) {
    4261                        ast::ObjectDecl * mutDecl = ast::mutate( decl );
    4362                        ast::ArrayType * mutType = ast::mutate( type );
    44                         mutType->dimension = ast::ConstantExpr::from_ulong(
    45                                 mutDecl->location, init->size() );
     63                        mutType->dimension = dimension;
    4664                        mutDecl->type = mutType;
    4765                        return mutDecl;

  • tests/.expect/alloc-ERROR.txt

    rd93b813 r3d618a0  
    1111    ...to:
    1212      Name: dim
    13       Sizeof Expression on: Applying untyped:
     13      Sizeof Expression on: type-of expression Applying untyped:
    1414          Name: *?
    1515        ...to:

  • tests/.expect/extension.arm64.txt

    rd93b813 r3d618a0  
    465465    }
    466466    {
    467         ((void)__extension__ sizeof(3));
     467        ((void)__extension__ sizeof(signed int ));
    468468    }
    469469
    … …  
    473473
    474474    {
    475         ((void)__extension__ __alignof__(__extension__ _X1ai_2));
     475        ((void)__extension__ __alignof__(signed int ));
    476476    }
    477477

  • tests/.expect/extension.x64.txt

    rd93b813 r3d618a0  
    465465    }
    466466    {
    467         ((void)__extension__ sizeof(3));
     467        ((void)__extension__ sizeof(signed int ));
    468468    }
    469469
    … …  
    473473
    474474    {
    475         ((void)__extension__ __alignof__(__extension__ _X1ai_2));
     475        ((void)__extension__ __alignof__(signed int ));
    476476    }
    477477

  • tests/.expect/extension.x86.txt

    rd93b813 r3d618a0  
    465465    }
    466466    {
    467         ((void)__extension__ sizeof(3));
     467        ((void)__extension__ sizeof(signed int ));
    468468    }
    469469
    … …  
    473473
    474474    {
    475         ((void)__extension__ __alignof__(__extension__ _X1ai_2));
     475        ((void)__extension__ __alignof__(signed int ));
    476476    }
    477477
Note: See TracChangeset for help on using the changeset viewer.