Changes in / [ed5e798:746ae82]


Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/AST/Convert.cpp

    red5e798 r746ae82  
    571571
    572572        const ast::Expr * visit( const ast::AddressExpr * node ) override final {
    573                 auto expr = visitBaseExpr( node,
    574                         new AddressExpr(
    575                                 get<Expression>().accept1(node->arg)
    576                         )
    577                 );
    578                 this->node = expr;
     573                (void)node;
    579574                return nullptr;
    580575        }
    581576
    582577        const ast::Expr * visit( const ast::LabelAddressExpr * node ) override final {
    583                 auto expr = visitBaseExpr( node,
    584                         new LabelAddressExpr(
    585                                 makeLabel(nullptr, node->arg)
    586                         )
    587                 );
    588                 this->node = expr;
     578                (void)node;
    589579                return nullptr;
    590580        }
    591581
    592582        const ast::Expr * visit( const ast::CastExpr * node ) override final {
    593                 auto expr = visitBaseExpr( node,
    594                         new CastExpr(
    595                                 get<Expression>().accept1(node->arg),
    596                                 (node->isGenerated == ast::GeneratedCast)
    597                         )
    598                 );
    599                 this->node = expr;
     583                (void)node;
    600584                return nullptr;
    601585        }
    602586
    603587        const ast::Expr * visit( const ast::KeywordCastExpr * node ) override final {
    604                 KeywordCastExpr::Target castTarget = KeywordCastExpr::NUMBER_OF_TARGETS;
    605                 switch (node->target) {
    606                         case ast::KeywordCastExpr::Coroutine:
    607                                 castTarget = KeywordCastExpr::Coroutine;
    608                                 break;
    609                         case ast::KeywordCastExpr::Thread:
    610                                 castTarget = KeywordCastExpr::Thread;
    611                                 break;
    612                         case ast::KeywordCastExpr::Monitor:
    613                                 castTarget = KeywordCastExpr::Monitor;
    614                                 break;
    615                         default:
    616                                 break;
    617                 }
    618                 assert ( castTarget < KeywordCastExpr::NUMBER_OF_TARGETS );
    619                 auto expr = visitBaseExpr( node,
    620                         new KeywordCastExpr(
    621                                 get<Expression>().accept1(node->arg),
    622                                 castTarget
    623                         )
    624                 );
    625                 this->node = expr;
     588                (void)node;
    626589                return nullptr;
    627590        }
    628591
    629592        const ast::Expr * visit( const ast::VirtualCastExpr * node ) override final {
    630                 auto expr = visitBaseExpr( node,
    631                         new VirtualCastExpr(
    632                                 get<Expression>().accept1(node->arg),
    633                                 nullptr // cast's "to" type is expr's result type; converted in visitBaseExpr
    634                         )
    635                 );
    636                 this->node = expr;
     593                (void)node;
    637594                return nullptr;
    638595        }
    639596
    640597        const ast::Expr * visit( const ast::UntypedMemberExpr * node ) override final {
    641                 auto expr = visitBaseExpr( node,
    642                         new UntypedMemberExpr(
    643                                 get<Expression>().accept1(node->member),
    644                                 get<Expression>().accept1(node->aggregate)
    645                         )
    646                 );
    647                 this->node = expr;
     598                (void)node;
    648599                return nullptr;
    649600        }
    650601
    651602        const ast::Expr * visit( const ast::MemberExpr * node ) override final {
    652                 auto expr = visitBaseExpr( node,
    653                         new MemberExpr(
    654                                 inCache(node->member) ?
    655                                         dynamic_cast<DeclarationWithType *>(this->node) :
    656                                         get<DeclarationWithType>().accept1(node->member),
    657                                 get<Expression>().accept1(node->aggregate)
    658                         )
    659                 );
    660                 this->node = expr;
     603                (void)node;
    661604                return nullptr;
    662605        }
    663606
    664607        const ast::Expr * visit( const ast::VariableExpr * node ) override final {
    665                 auto expr = visitBaseExpr( node,
    666                         new VariableExpr(
    667                                 inCache(node->var) ?
    668                                         dynamic_cast<DeclarationWithType *>(this->node) :
    669                                         get<DeclarationWithType>().accept1(node->var)
    670                         )
    671                 );
    672                 this->node = expr;
    673                 return nullptr;
    674         }
    675 
    676         bool isIntlikeConstantType(const ast::Type *t) {
    677                 if ( const ast::BasicType * basicType = dynamic_cast< const ast::BasicType * >( t ) ) {
    678                         if ( basicType->isInteger() ) {
    679                                 return true;
    680                         }
    681                 } else if ( dynamic_cast< const ast::OneType * >( t ) ) {
    682                         return true;
    683                 } else if ( dynamic_cast< const ast::ZeroType * >( t ) ) {
    684                         return true;
    685                 } else if ( dynamic_cast< const ast::PointerType * >( t ) ) {
    686                         // null pointer constants, with zero int-values
    687                         return true;
    688                 }
    689                 return false;
    690         }
    691 
    692         bool isFloatlikeConstantType(const ast::Type *t) {
    693                 if ( const ast::BasicType * bty = dynamic_cast< const ast::BasicType * >( t ) ) {
    694                         if ( ! bty->isInteger() ) {
    695                                 return true;
    696                         }
    697                 }
    698                 return false;
    699         }
    700 
    701         bool isStringlikeConstantType(const ast::Type *t) {
    702                 if ( const ast::ArrayType * aty = dynamic_cast< const ast::ArrayType * >( t ) ) {
    703                         if ( const ast::BasicType * bty = aty->base.as<ast::BasicType>() ) {
    704                            if ( bty->kind == ast::BasicType::Kind::Char ) {
    705                                    return true;
    706                            }
    707                         }
    708                 }
    709                 return false;
     608                (void)node;
     609                return nullptr;
    710610        }
    711611
    712612        const ast::Expr * visit( const ast::ConstantExpr * node ) override final {
    713                 ConstantExpr *rslt = nullptr;
    714                 if (isIntlikeConstantType(node->result)) {
    715                         rslt = new ConstantExpr(Constant(
    716                                 get<Type>().accept1(node->result),
    717                                 node->rep,
    718                                 (unsigned long long) node->intValue()
    719                         ));
    720                 } else if (isFloatlikeConstantType(node->result)) {
    721                         rslt = new ConstantExpr(Constant(
    722                                 get<Type>().accept1(node->result),
    723                                 node->rep,
    724                                 (double) node->floatValue()
    725                         ));
    726                 } else if (isStringlikeConstantType(node->result)) {
    727                         rslt = new ConstantExpr(Constant::from_string(
    728                                 node->rep
    729                         ));
    730                 }
    731                 assert(rslt);
    732                 auto expr = visitBaseExpr( node, rslt );
    733                 this->node = expr;
     613                (void)node;
    734614                return nullptr;
    735615        }
    736616
    737617        const ast::Expr * visit( const ast::SizeofExpr * node ) override final {
    738                 assert (node->expr || node->type);
    739                 assert (! (node->expr && node->type));
    740                 SizeofExpr *rslt;
    741                 if (node->expr) {
    742                         rslt = new SizeofExpr(
    743                                 get<Expression>().accept1(node->expr)
    744                         );
    745                         assert (!rslt->isType);
    746                 }
    747                 if (node->type) {
    748                         rslt = new SizeofExpr(
    749                                 get<Type>().accept1(node->type)
    750                         );
    751                         assert (rslt->isType);
    752                 }
    753                 auto expr = visitBaseExpr( node, rslt );
    754                 this->node = expr;
     618                (void)node;
    755619                return nullptr;
    756620        }
    757621
    758622        const ast::Expr * visit( const ast::AlignofExpr * node ) override final {
    759                 assert (node->expr || node->type);
    760                 assert (! (node->expr && node->type));
    761                 AlignofExpr *rslt;
    762                 if (node->expr) {
    763                         rslt = new AlignofExpr(
    764                                 get<Expression>().accept1(node->expr)
    765                         );
    766                         assert (!rslt->isType);
    767                 }
    768                 if (node->type) {
    769                         rslt = new AlignofExpr(
    770                                 get<Type>().accept1(node->type)
    771                         );
    772                         assert (rslt->isType);
    773                 }
    774                 auto expr = visitBaseExpr( node, rslt );
    775                 this->node = expr;
     623                (void)node;
    776624                return nullptr;
    777625        }
    778626
    779627        const ast::Expr * visit( const ast::UntypedOffsetofExpr * node ) override final {
    780                 auto expr = visitBaseExpr( node,
    781                         new UntypedOffsetofExpr(
    782                                 get<Type>().accept1(node->type),
    783                                 node->member
    784                         )
    785                 );
    786                 this->node = expr;
     628                (void)node;
    787629                return nullptr;
    788630        }
    789631
    790632        const ast::Expr * visit( const ast::OffsetofExpr * node ) override final {
    791                 auto expr = visitBaseExpr( node,
    792                         new OffsetofExpr(
    793                                 get<Type>().accept1(node->type),
    794                                 inCache(node->member) ?
    795                                         dynamic_cast<DeclarationWithType *>(this->node) :
    796                                         get<DeclarationWithType>().accept1(node->member)
    797                         )
    798                 );
    799                 this->node = expr;
     633                (void)node;
    800634                return nullptr;
    801635        }
    802636
    803637        const ast::Expr * visit( const ast::OffsetPackExpr * node ) override final {
    804                 auto expr = visitBaseExpr( node,
    805                         new OffsetPackExpr(
    806                                 get<StructInstType>().accept1(node->type)
    807                         )
    808                 );
    809                 this->node = expr;
     638                (void)node;
    810639                return nullptr;
    811640        }
    812641
    813642        const ast::Expr * visit( const ast::LogicalExpr * node ) override final {
    814                 assert (node->isAnd == ast::LogicalFlag::AndExpr ||
    815                                 node->isAnd == ast::LogicalFlag::OrExpr );
    816                 auto expr = visitBaseExpr( node,
    817                         new LogicalExpr(
    818                                 get<Expression>().accept1(node->arg1),
    819                                 get<Expression>().accept1(node->arg2),
    820                                 (node->isAnd == ast::LogicalFlag::AndExpr)
    821                         )
    822                 );
    823                 this->node = expr;
     643                (void)node;
    824644                return nullptr;
    825645        }
    826646
    827647        const ast::Expr * visit( const ast::ConditionalExpr * node ) override final {
    828                 auto expr = visitBaseExpr( node,
    829                         new ConditionalExpr(
    830                                 get<Expression>().accept1(node->arg1),
    831                                 get<Expression>().accept1(node->arg2),
    832                                 get<Expression>().accept1(node->arg3)
    833                         )
    834                 );
    835                 this->node = expr;
     648                (void)node;
    836649                return nullptr;
    837650        }
    838651
    839652        const ast::Expr * visit( const ast::CommaExpr * node ) override final {
    840                 auto expr = visitBaseExpr( node,
    841                         new CommaExpr(
    842                                 get<Expression>().accept1(node->arg1),
    843                                 get<Expression>().accept1(node->arg2)
    844                         )
    845                 );
    846                 this->node = expr;
     653                (void)node;
    847654                return nullptr;
    848655        }
    … …  
    17401547                        new ast::CastExpr(
    17411548                                old->location,
    1742                                 GET_ACCEPT_1(arg, Expr),
     1549                                nullptr, // cast's "to" type is expr's result type; converted in visitBaseExpr
    17431550                                old->isGenerated ? ast::GeneratedCast : ast::ExplicitCast
    17441551                        )
    … …  
    17461553        }
    17471554
    1748         virtual void visit( KeywordCastExpr * old) override final {
    1749                 ast::KeywordCastExpr::Target castTarget = ast::KeywordCastExpr::NUMBER_OF_TARGETS;
    1750                 switch (old->target) {
    1751                         case KeywordCastExpr::Coroutine:
    1752                                 castTarget = ast::KeywordCastExpr::Coroutine;
    1753                                 break;
    1754                         case KeywordCastExpr::Thread:
    1755                                 castTarget = ast::KeywordCastExpr::Thread;
    1756                                 break;
    1757                         case KeywordCastExpr::Monitor:
    1758                                 castTarget = ast::KeywordCastExpr::Monitor;
    1759                                 break;
    1760                         default:
    1761                                 break;
    1762                 }
    1763                 assert ( castTarget < ast::KeywordCastExpr::NUMBER_OF_TARGETS );
    1764                 this->node = visitBaseExpr( old,
    1765                         new ast::KeywordCastExpr(
    1766                                 old->location,
    1767                                 GET_ACCEPT_1(arg, Expr),
    1768                                 castTarget
    1769                         )
    1770                 );
    1771         }
    1772 
    1773         virtual void visit( VirtualCastExpr * old ) override final {
    1774                 this->node = visitBaseExpr( old,
    1775                         new ast::VirtualCastExpr(
    1776                                 old->location,
    1777                                 GET_ACCEPT_1(arg, Expr),
    1778                                 nullptr // cast's "to" type is expr's result type; converted in visitBaseExpr
    1779                         )
    1780                 );
    1781         }
    1782 
    1783         virtual void visit( AddressExpr * old ) override final {
    1784                 this->node = visitBaseExpr( old,
    1785                         new ast::AddressExpr(
    1786                                 old->location,
    1787                                 GET_ACCEPT_1(arg, Expr)
    1788                         )
    1789                 );
    1790         }
    1791 
    1792         virtual void visit( LabelAddressExpr * old ) override final {
    1793                 this->node = visitBaseExpr( old,
    1794                         new ast::LabelAddressExpr(
    1795                                 old->location,
    1796                                 make_label(&old->arg)
    1797                         )
    1798                 );
    1799         }
    1800 
    1801         virtual void visit( UntypedMemberExpr * old ) override final {
    1802                 this->node = visitBaseExpr( old,
    1803                         new ast::UntypedMemberExpr(
    1804                                 old->location,
    1805                                 GET_ACCEPT_1(member, Expr),
    1806                                 GET_ACCEPT_1(aggregate, Expr)
    1807                         )
    1808                 );
    1809         }
    1810 
    1811         virtual void visit( MemberExpr * old ) override final {
    1812                 this->node = visitBaseExpr( old,
    1813                         new ast::MemberExpr(
    1814                                 old->location,
    1815                                 inCache(old->member) ?
    1816                                         dynamic_cast<ast::DeclWithType *>(this->node) :
    1817                                         GET_ACCEPT_1(member, DeclWithType),
    1818                                 GET_ACCEPT_1(aggregate, Expr)
    1819                         )
    1820                 );
    1821         }
    1822 
    1823         virtual void visit( VariableExpr * old ) override final {
    1824                 this->node = visitBaseExpr( old,
    1825                         new ast::VariableExpr(
    1826                                 old->location,
    1827                                 inCache(old->var) ?
    1828                                         dynamic_cast<ast::DeclWithType *>(this->node) :
    1829                                         GET_ACCEPT_1(var, DeclWithType)
    1830                         )
    1831                 );
    1832         }
    1833 
    1834         bool isIntlikeConstantType(const Type *t) {
    1835                 if ( const BasicType * basicType = dynamic_cast< const BasicType * >( t ) ) {
    1836                         if ( basicType->isInteger() ) {
    1837                                 return true;
    1838                         }
    1839                 } else if ( dynamic_cast< const OneType * >( t ) ) {
    1840                         return true;
    1841                 } else if ( dynamic_cast< const ZeroType * >( t ) ) {
    1842                         return true;
    1843                 } else if ( dynamic_cast< const PointerType * >( t ) ) {
    1844                         // null pointer constants, with zero int-values
    1845                         return true;
    1846                 }
    1847                 return false;
    1848         }
    1849 
    1850         int isFloatlikeConstantType(const Type *t) {
    1851                 if ( const BasicType * bty = dynamic_cast< const BasicType * >( t ) ) {
    1852                         if ( ! bty->isInteger() ) {
    1853                                 return true;
    1854                         }
    1855                 }
    1856                 return false;
    1857         }
    1858 
    1859         int isStringlikeConstantType(const Type *t) {
    1860                 if ( const ArrayType * aty = dynamic_cast< const ArrayType * >( t ) ) {
    1861                         if ( const BasicType * bty = dynamic_cast< const BasicType * >( aty->base ) ) {
    1862                            if ( bty->kind == BasicType::Kind::Char ) {
    1863                                    return true;
    1864                            }
    1865                         }
    1866                 }
    1867                 return false;
    1868         }
    1869 
    1870         virtual void visit( ConstantExpr * old ) override final {
    1871                 ast::ConstantExpr *rslt = nullptr;
    1872                 if (isIntlikeConstantType(old->result)) {
    1873                         rslt = new ast::ConstantExpr(
    1874                                 old->location,
    1875                                 GET_ACCEPT_1(result, Type),
    1876                                 old->constant.get_value(),
    1877                                 (unsigned long long) old->intValue()
    1878                         );
    1879                 } else if (isFloatlikeConstantType(old->result)) {
    1880                         rslt = new ast::ConstantExpr(
    1881                                 old->location,
    1882                                 GET_ACCEPT_1(result, Type),
    1883                                 old->constant.get_value(),
    1884                                 (double) old->constant.get_dval()
    1885                         );
    1886                 } else if (isStringlikeConstantType(old->result)) {
    1887                         rslt = ast::ConstantExpr::from_string(
    1888                                 old->location,
    1889                                 old->constant.get_value()
    1890                         );
    1891                 }
    1892                 assert(rslt);
    1893                 this->node = visitBaseExpr( old, rslt );
    1894         }
    1895 
    1896         virtual void visit( SizeofExpr * old ) override final {
    1897                 assert (old->expr || old->type);
    1898                 assert (! (old->expr && old->type));
    1899                 ast::SizeofExpr *rslt;
    1900                 if (old->expr) {
    1901                         assert(!old->isType);
    1902                         rslt = new ast::SizeofExpr(
    1903                                 old->location,
    1904                                 GET_ACCEPT_1(expr, Expr)
    1905                         );
    1906                 }
    1907                 if (old->type) {
    1908                         assert(old->isType);
    1909                         rslt = new ast::SizeofExpr(
    1910                                 old->location,
    1911                                 GET_ACCEPT_1(type, Type)
    1912                         );
    1913                 }
    1914                 this->node = visitBaseExpr( old, rslt );
    1915         }
    1916 
    1917         virtual void visit( AlignofExpr * old ) override final {
    1918                 assert (old->expr || old->type);
    1919                 assert (! (old->expr && old->type));
    1920                 ast::AlignofExpr *rslt;
    1921                 if (old->expr) {
    1922                         assert(!old->isType);
    1923                         rslt = new ast::AlignofExpr(
    1924                                 old->location,
    1925                                 GET_ACCEPT_1(expr, Expr)
    1926                         );
    1927                 }
    1928                 if (old->type) {
    1929                         assert(old->isType);
    1930                         rslt = new ast::AlignofExpr(
    1931                                 old->location,
    1932                                 GET_ACCEPT_1(type, Type)
    1933                         );
    1934                 }
    1935                 this->node = visitBaseExpr( old, rslt );
    1936         }
    1937 
    1938         virtual void visit( UntypedOffsetofExpr * old ) override final {
    1939                 this->node = visitBaseExpr( old,
    1940                         new ast::UntypedOffsetofExpr(
    1941                                 old->location,
    1942                                 GET_ACCEPT_1(type, Type),
    1943                                 old->member
    1944                         )
    1945                 );
    1946         }
    1947 
    1948         virtual void visit( OffsetofExpr * old ) override final {
    1949                 this->node = visitBaseExpr( old,
    1950                         new ast::OffsetofExpr(
    1951                                 old->location,
    1952                                 GET_ACCEPT_1(type, Type),
    1953                                 inCache(old->member) ?
    1954                                         dynamic_cast<ast::DeclWithType *>(this->node) :
    1955                                         GET_ACCEPT_1(member, DeclWithType)
    1956                         )
    1957                 );
    1958         }
    1959 
    1960         virtual void visit( OffsetPackExpr * old ) override final {
    1961                 this->node = visitBaseExpr( old,
    1962                         new ast::OffsetPackExpr(
    1963                                 old->location,
    1964                                 GET_ACCEPT_1(type, StructInstType)
    1965                         )
    1966                 );
    1967         }
    1968 
    1969         virtual void visit( LogicalExpr * old ) override final {
    1970                 this->node = visitBaseExpr( old,
    1971                         new ast::LogicalExpr(
    1972                                 old->location,
    1973                                 GET_ACCEPT_1(arg1, Expr),
    1974                                 GET_ACCEPT_1(arg2, Expr),
    1975                                 old->get_isAnd() ?
    1976                                         ast::LogicalFlag::AndExpr :
    1977                                         ast::LogicalFlag::OrExpr
    1978                         )
    1979                 );
    1980         }
    1981 
    1982         virtual void visit( ConditionalExpr * old ) override final {
    1983                 this->node = visitBaseExpr( old,
    1984                         new ast::ConditionalExpr(
    1985                                 old->location,
    1986                                 GET_ACCEPT_1(arg1, Expr),
    1987                                 GET_ACCEPT_1(arg2, Expr),
    1988                                 GET_ACCEPT_1(arg3, Expr)
    1989                         )
    1990                 );
    1991         }
    1992 
    1993         virtual void visit( CommaExpr * old ) override final {
    1994                 this->node = visitBaseExpr( old,
    1995                         new ast::CommaExpr(
    1996                                 old->location,
    1997                                 GET_ACCEPT_1(arg1, Expr),
    1998                                 GET_ACCEPT_1(arg2, Expr)
    1999                         )
    2000                 );
     1555        virtual void visit( KeywordCastExpr * ) override final {
     1556
     1557        }
     1558
     1559        virtual void visit( VirtualCastExpr * ) override final {
     1560
     1561        }
     1562
     1563        virtual void visit( AddressExpr * ) override final {
     1564
     1565        }
     1566
     1567        virtual void visit( LabelAddressExpr * ) override final {
     1568
     1569        }
     1570
     1571        virtual void visit( UntypedMemberExpr * ) override final {
     1572
     1573        }
     1574
     1575        virtual void visit( MemberExpr * ) override final {
     1576
     1577        }
     1578
     1579        virtual void visit( VariableExpr * ) override final {
     1580
     1581        }
     1582
     1583        virtual void visit( ConstantExpr * ) override final {
     1584
     1585        }
     1586
     1587        virtual void visit( SizeofExpr * ) override final {
     1588
     1589        }
     1590
     1591        virtual void visit( AlignofExpr * ) override final {
     1592
     1593        }
     1594
     1595        virtual void visit( UntypedOffsetofExpr * ) override final {
     1596
     1597        }
     1598
     1599        virtual void visit( OffsetofExpr * ) override final {
     1600
     1601        }
     1602
     1603        virtual void visit( OffsetPackExpr * ) override final {
     1604
     1605        }
     1606
     1607        virtual void visit( LogicalExpr * ) override final {
     1608
     1609        }
     1610
     1611        virtual void visit( ConditionalExpr * ) override final {
     1612
     1613        }
     1614
     1615        virtual void visit( CommaExpr * ) override final {
     1616
    20011617        }
    20021618
Note: See TracChangeset for help on using the changeset viewer.