Changes in / [15934a6:9a0cd9c]


Ignore:
Location:
src
Files:
2 deleted
9 edited

Legend:

Unmodified
Added
Removed

  • src/AST/Bitfield.hpp

    r15934a6 r9a0cd9c  
    5757};
    5858
    59 template<typename T>
    60 inline bool operator== ( const bitfield<T> & a, const bitfield<T> & b ) {
    61         return a.val == b.val;
    62 }
    63 
    64 template<typename T>
    65 inline bool operator!= ( const bitfield<T> & a, const bitfield<T> & b ) {
    66         return !(a == b);
    67 }
     59/// Adds default printing operator to a bitfield type.
     60/// Include in definition to add print function, requires other bitfield operators.
     61/// @param N  Number of bits in bitfield
     62#define MakeBitfieldPrint( N ) \
     63        static const char* Names[]; \
     64 \
     65        void print( std::ostream & os ) const { \
     66                if ( (*this).any() ) { \
     67                        for ( unsigned int i = 0; i < N; i += 1 ) { \
     68                                if ( (*this)[i] ) { \
     69                                        os << Names[i] << ' '; \
     70                                } \
     71                        } \
     72                } \
     73        }
    6874
    6975// Local Variables: //

  • src/AST/Convert.cpp

    r15934a6 r9a0cd9c  
    525525        }
    526526
    527         Expression * visitBaseExpr_skipResultType(const ast::Expr * src, Expression * tgt) {
    528 
    529                 tgt->location  = src->location;
    530                 tgt->env       = convertTypeSubstitution(src->env);
     527        Expression * visitBaseExpr(const ast::Expr * src, Expression * tgt) {
     528
     529                tgt->location = src->location;
     530
     531                tgt->result = get<Type>().accept1(src->result);
     532                tgt->env    = convertTypeSubstitution(src->env);
     533
    531534                tgt->extension = src->extension;
    532 
    533535                convertInferUnion(tgt->inferParams, tgt->resnSlots, src->inferred);
     536
    534537                return tgt;
    535         }
    536 
    537         Expression * visitBaseExpr(const ast::Expr * src, Expression * tgt) {
    538 
    539                 tgt->result = get<Type>().accept1(src->result);
    540                 return visitBaseExpr_skipResultType(src, tgt);
    541538        }
    542539
    … …  
    631628
    632629        const ast::Expr * visit( const ast::VirtualCastExpr * node ) override final {
    633                 auto expr = visitBaseExpr_skipResultType( node,
     630                auto expr = visitBaseExpr( node,
    634631                        new VirtualCastExpr(
    635632                                get<Expression>().accept1(node->arg),
    636                                 get<Type>().accept1(node->result)
     633                                nullptr // cast's "to" type is expr's result type; converted in visitBaseExpr
    637634                        )
    638635                );
    … …  
    852849
    853850        const ast::Expr * visit( const ast::TypeExpr * node ) override final {
    854                 auto expr = visitBaseExpr( node,
    855                         new TypeExpr(
    856                                 get<Type>().accept1(node->type)
    857                         )
    858                 );
    859                 this->node = expr;
     851                (void)node;
    860852                return nullptr;
    861853        }
    862854
    863855        const ast::Expr * visit( const ast::AsmExpr * node ) override final {
    864                 auto expr = visitBaseExpr( node,
    865                         new AsmExpr(
    866                                 get<Expression>().accept1(node->inout),
    867                                 get<Expression>().accept1(node->constraint),
    868                                 get<Expression>().accept1(node->operand)
    869                         )
    870                 );
    871                 this->node = expr;
     856                (void)node;
    872857                return nullptr;
    873858        }
    874859
    875860        const ast::Expr * visit( const ast::ImplicitCopyCtorExpr * node ) override final {
    876                 auto rslt = new ImplicitCopyCtorExpr(
    877                         get<ApplicationExpr>().accept1(node->callExpr)
    878                 );
    879 
    880                 rslt->tempDecls = get<ObjectDecl>().acceptL(node->tempDecls);
    881                 rslt->returnDecls = get<ObjectDecl>().acceptL(node->returnDecls);
    882                 rslt->dtors = get<Expression>().acceptL(node->dtors);
    883 
    884                 auto expr = visitBaseExpr( node, rslt );
    885                 this->node = expr;
     861                (void)node;
    886862                return nullptr;
    887863        }
    888864
    889865        const ast::Expr * visit( const ast::ConstructorExpr * node ) override final {
    890                 auto expr = visitBaseExpr( node,
    891                         new ConstructorExpr(
    892                                 get<Expression>().accept1(node->callExpr)
    893                         )
    894                 );
    895                 this->node = expr;
     866                (void)node;
    896867                return nullptr;
    897868        }
    898869
    899870        const ast::Expr * visit( const ast::CompoundLiteralExpr * node ) override final {
    900                 auto expr = visitBaseExpr_skipResultType( node,
    901                         new CompoundLiteralExpr(
    902                                 get<Type>().accept1(node->result),
    903                                 get<Initializer>().accept1(node->init)
    904                         )
    905                 );
    906                 this->node = expr;
     871                (void)node;
    907872                return nullptr;
    908873        }
    909874
    910875        const ast::Expr * visit( const ast::RangeExpr * node ) override final {
    911                 auto expr = visitBaseExpr( node,
    912                         new RangeExpr(
    913                                 get<Expression>().accept1(node->low),
    914                                 get<Expression>().accept1(node->high)
    915                         )
    916                 );
    917                 this->node = expr;
     876                (void)node;
    918877                return nullptr;
    919878        }
    920879
    921880        const ast::Expr * visit( const ast::UntypedTupleExpr * node ) override final {
    922                 auto expr = visitBaseExpr( node,
    923                         new UntypedTupleExpr(
    924                                 get<Expression>().acceptL(node->exprs)
    925                         )
    926                 );
    927                 this->node = expr;
     881                (void)node;
    928882                return nullptr;
    929883        }
    930884
    931885        const ast::Expr * visit( const ast::TupleExpr * node ) override final {
    932                 auto expr = visitBaseExpr( node,
    933                         new UntypedTupleExpr(
    934                                 get<Expression>().acceptL(node->exprs)
    935                         )
    936                 );
    937                 this->node = expr;
     886                (void)node;
    938887                return nullptr;
    939888        }
    940889
    941890        const ast::Expr * visit( const ast::TupleIndexExpr * node ) override final {
    942                 auto expr = visitBaseExpr( node,
    943                         new TupleIndexExpr(
    944                                 get<Expression>().accept1(node->tuple),
    945                                 node->index
    946                         )
    947                 );
    948                 this->node = expr;
     891                (void)node;
    949892                return nullptr;
    950893        }
    951894
    952895        const ast::Expr * visit( const ast::TupleAssignExpr * node ) override final {
    953                 auto expr = visitBaseExpr( node,
    954                         new TupleAssignExpr(
    955                                 get<StmtExpr>().accept1(node->stmtExpr)
    956                         )
    957                 );
    958                 this->node = expr;
     896                (void)node;
    959897                return nullptr;
    960898        }
    961899
    962900        const ast::Expr * visit( const ast::StmtExpr * node ) override final {
    963                 auto rslt = new StmtExpr(
    964                         get<CompoundStmt>().accept1(node->stmts)
    965                 );
    966 
    967                 rslt->returnDecls = get<ObjectDecl>().acceptL(node->returnDecls);
    968                 rslt->dtors       = get<Expression>().acceptL(node->dtors);
    969 
    970                 auto expr = visitBaseExpr( node, rslt );
    971                 this->node = expr;
     901                (void)node;
    972902                return nullptr;
    973903        }
    974904
    975905        const ast::Expr * visit( const ast::UniqueExpr * node ) override final {
    976                 auto rslt = new UniqueExpr(
    977                         get<Expression>().accept1(node->expr)
    978                 );
    979 
    980                 rslt->object = get<ObjectDecl>  ().accept1(node->object);
    981                 rslt->var    = get<VariableExpr>().accept1(node->var);
    982 
    983                 auto expr = visitBaseExpr( node, rslt );
    984                 this->node = expr;
     906                (void)node;
    985907                return nullptr;
    986908        }
    987909
    988910        const ast::Expr * visit( const ast::UntypedInitExpr * node ) override final {
    989                 std::list<InitAlternative> initAlts;
    990                 for (auto ia : node->initAlts) {
    991                         initAlts.push_back(InitAlternative(
    992                                 get<Type>       ().accept1(ia.type),
    993                                 get<Designation>().accept1(ia.designation)
    994                         ));
    995                 }
    996                 auto expr = visitBaseExpr( node,
    997                         new UntypedInitExpr(
    998                                 get<Expression>().accept1(node->expr),
    999                                 initAlts
    1000                         )
    1001                 );
    1002                 this->node = expr;
     911                (void)node;
    1003912                return nullptr;
    1004913        }
    1005914
    1006915        const ast::Expr * visit( const ast::InitExpr * node ) override final {
    1007                 auto expr = visitBaseExpr( node,
    1008                         new InitExpr(
    1009                                 get<Expression>().accept1(node->expr),
    1010                                 get<Designation>().accept1(node->designation)
    1011                         )
    1012                 );
    1013                 this->node = expr;
     916                (void)node;
    1014917                return nullptr;
    1015918        }
    1016919
    1017920        const ast::Expr * visit( const ast::DeletedExpr * node ) override final {
    1018                 auto expr = visitBaseExpr( node,
    1019                         new DeletedExpr(
    1020                                 get<Expression>().accept1(node->expr),
    1021                                 inCache(node->deleteStmt) ?
    1022                                         this->node :
    1023                                         get<BaseSyntaxNode>().accept1(node->deleteStmt)
    1024                         )
    1025                 );
    1026                 this->node = expr;
     921                (void)node;
    1027922                return nullptr;
    1028923        }
    1029924
    1030925        const ast::Expr * visit( const ast::DefaultArgExpr * node ) override final {
    1031                 auto expr = visitBaseExpr( node,
    1032                         new DefaultArgExpr(
    1033                                 get<Expression>().accept1(node->expr)
    1034                         )
    1035                 );
    1036                 this->node = expr;
     926                (void)node;
    1037927                return nullptr;
    1038928        }
    1039929
    1040930        const ast::Expr * visit( const ast::GenericExpr * node ) override final {
    1041                 std::list<GenericExpr::Association> associations;
    1042                 for (auto association : node->associations) {
    1043                         associations.push_back(GenericExpr::Association(
    1044                                 get<Type>      ().accept1(association.type),
    1045                                 get<Expression>().accept1(association.expr)
    1046                         ));
    1047                 }
    1048                 auto expr = visitBaseExpr( node,
    1049                         new GenericExpr(
    1050                                 get<Expression>().accept1(node->control),
    1051                                 associations
    1052                         )
    1053                 );
    1054                 this->node = expr;
     931                (void)node;
    1055932                return nullptr;
    1056933        }
    … …  
    18641741        }
    18651742
    1866         ast::Expr * visitBaseExpr_SkipResultType(Expression * old, ast::Expr * nw) {
    1867 
     1743        ast::Expr * visitBaseExpr(Expression * old, ast::Expr * nw) {
     1744
     1745                nw->result = GET_ACCEPT_1(result, Type);
    18681746                nw->env    = convertTypeSubstitution(old->env);
    18691747
    … …  
    18721750
    18731751                return nw;
    1874         }
    1875 
    1876         ast::Expr * visitBaseExpr(Expression * old, ast::Expr * nw) {
    1877 
    1878                 nw->result = GET_ACCEPT_1(result, Type);
    1879                 return visitBaseExpr_SkipResultType(old, nw);;
    18801752        }
    18811753
    … …  
    19451817
    19461818        virtual void visit( VirtualCastExpr * old ) override final {
    1947                 this->node = visitBaseExpr_SkipResultType( old,
     1819                this->node = visitBaseExpr( old,
    19481820                        new ast::VirtualCastExpr(
    19491821                                old->location,
    19501822                                GET_ACCEPT_1(arg, Expr),
    1951                                 GET_ACCEPT_1(result, Type)
     1823                                nullptr // cast's "to" type is expr's result type; converted in visitBaseExpr
    19521824                        )
    19531825                );
    … …  
    21742046        }
    21752047
    2176         virtual void visit( TypeExpr * old ) override final {
    2177                 this->node = visitBaseExpr( old,
    2178                         new ast::TypeExpr(
    2179                                 old->location,
    2180                                 GET_ACCEPT_1(type, Type)
    2181                         )
    2182                 );
    2183         }
    2184 
    2185         virtual void visit( AsmExpr * old ) override final {
    2186                 this->node = visitBaseExpr( old,
    2187                         new ast::AsmExpr(
    2188                                 old->location,
    2189                                 GET_ACCEPT_1(inout, Expr),
    2190                                 GET_ACCEPT_1(constraint, Expr),
    2191                                 GET_ACCEPT_1(operand, Expr)
    2192                         )
    2193                 );
    2194         }
    2195 
    2196         virtual void visit( ImplicitCopyCtorExpr * old ) override final {
    2197                 auto rslt = new ast::ImplicitCopyCtorExpr(
    2198                         old->location,
    2199                         GET_ACCEPT_1(callExpr, ApplicationExpr)
    2200                 );
    2201 
    2202                 rslt->tempDecls = GET_ACCEPT_V(tempDecls, ObjectDecl);
    2203                 rslt->returnDecls = GET_ACCEPT_V(returnDecls, ObjectDecl);
    2204                 rslt->dtors = GET_ACCEPT_V(dtors, Expr);
    2205 
    2206                 this->node = visitBaseExpr( old, rslt );
    2207         }
    2208 
    2209         virtual void visit( ConstructorExpr * old ) override final {
    2210                 this->node = visitBaseExpr( old,
    2211                         new ast::ConstructorExpr(
    2212                                 old->location,
    2213                                 GET_ACCEPT_1(callExpr, Expr)
    2214                         )
    2215                 );
    2216         }
    2217 
    2218         virtual void visit( CompoundLiteralExpr * old ) override final {
    2219                 this->node = visitBaseExpr_SkipResultType( old,
    2220                         new ast::CompoundLiteralExpr(
    2221                                 old->location,
    2222                                 GET_ACCEPT_1(result, Type),
    2223                                 GET_ACCEPT_1(initializer, Init)
    2224                         )
    2225                 );
    2226         }
    2227 
    2228         virtual void visit( RangeExpr * old ) override final {
    2229                 this->node = visitBaseExpr( old,
    2230                         new ast::RangeExpr(
    2231                                 old->location,
    2232                                 GET_ACCEPT_1(low, Expr),
    2233                                 GET_ACCEPT_1(high, Expr)
    2234                         )
    2235                 );
    2236         }
    2237 
    2238         virtual void visit( UntypedTupleExpr * old ) override final {
    2239                 this->node = visitBaseExpr( old,
    2240                         new ast::UntypedTupleExpr(
    2241                                 old->location,
    2242                                 GET_ACCEPT_V(exprs, Expr)
    2243                         )
    2244                 );
    2245         }
    2246 
    2247         virtual void visit( TupleExpr * old ) override final {
    2248                 this->node = visitBaseExpr( old,
    2249                         new ast::TupleExpr(
    2250                                 old->location,
    2251                                 GET_ACCEPT_V(exprs, Expr)
    2252                         )
    2253                 );
    2254         }
    2255 
    2256         virtual void visit( TupleIndexExpr * old ) override final {
    2257                 this->node = visitBaseExpr( old,
    2258                         new ast::TupleIndexExpr(
    2259                                 old->location,
    2260                                 GET_ACCEPT_1(tuple, Expr),
    2261                                 old->index
    2262                         )
    2263                 );
    2264         }
    2265 
    2266         virtual void visit( TupleAssignExpr * old ) override final {
    2267                 this->node = visitBaseExpr_SkipResultType( old,
    2268                         new ast::TupleAssignExpr(
    2269                                 old->location,
    2270                                 GET_ACCEPT_1(result, Type),
    2271                                 GET_ACCEPT_1(stmtExpr, StmtExpr)
    2272                         )
    2273                 );
    2274         }
    2275 
    2276         virtual void visit( StmtExpr * old ) override final {
    2277                 auto rslt = new ast::StmtExpr(
    2278                         old->location,
    2279                         GET_ACCEPT_1(statements, CompoundStmt)
    2280                 );
    2281                 rslt->returnDecls = GET_ACCEPT_V(returnDecls, ObjectDecl);
    2282                 rslt->dtors       = GET_ACCEPT_V(dtors      , Expr);
    2283 
    2284                 this->node = visitBaseExpr_SkipResultType( old, rslt );
    2285         }
    2286 
    2287         virtual void visit( UniqueExpr * old ) override final {
    2288                 auto rslt = new ast::UniqueExpr(
    2289                         old->location,
    2290                         GET_ACCEPT_1(expr, Expr)
    2291                 );
    2292                 rslt->object = GET_ACCEPT_1(object, ObjectDecl);
    2293                 rslt->var    = GET_ACCEPT_1(var   , VariableExpr);
    2294 
    2295                 this->node = visitBaseExpr( old, rslt );
    2296         }
    2297 
    2298         virtual void visit( UntypedInitExpr * old ) override final {
    2299                 std::vector<ast::InitAlternative> initAlts;
    2300                 for (auto ia : old->initAlts) {
    2301                         initAlts.push_back(ast::InitAlternative(
    2302                                 getAccept1< ast::Type, Type * >( ia.type ),
    2303                                 getAccept1< ast::Designation, Designation * >( ia.designation )
    2304                         ));
    2305                 }
    2306                 this->node = visitBaseExpr( old,
    2307                         new ast::UntypedInitExpr(
    2308                                 old->location,
    2309                                 GET_ACCEPT_1(expr, Expr),
    2310                                 std::move(initAlts)
    2311                         )
    2312                 );
    2313         }
    2314 
    2315         virtual void visit( InitExpr * old ) override final {
    2316                 this->node = visitBaseExpr( old,
    2317                         new ast::InitExpr(
    2318                                 old->location,
    2319                                 GET_ACCEPT_1(expr, Expr),
    2320                                 GET_ACCEPT_1(designation, Designation)
    2321                         )
    2322                 );
    2323         }
    2324 
    2325         virtual void visit( DeletedExpr * old ) override final {
    2326                 this->node = visitBaseExpr( old,
    2327                         new ast::DeletedExpr(
    2328                                 old->location,
    2329                                 GET_ACCEPT_1(expr, Expr),
    2330                                 inCache(old->deleteStmt) ?
    2331                                         this->node :
    2332                                         GET_ACCEPT_1(deleteStmt, Node)
    2333                         )
    2334                 );
    2335         }
    2336 
    2337         virtual void visit( DefaultArgExpr * old ) override final {
    2338                 this->node = visitBaseExpr( old,
    2339                         new ast::DefaultArgExpr(
    2340                                 old->location,
    2341                                 GET_ACCEPT_1(expr, Expr)
    2342                         )
    2343                 );
    2344         }
    2345 
    2346         virtual void visit( GenericExpr * old ) override final {
    2347                 std::vector<ast::GenericExpr::Association> associations;
    2348                 for (auto association : old->associations) {
    2349                         associations.push_back(ast::GenericExpr::Association(
    2350                                 getAccept1< ast::Type, Type * >( association.type ),
    2351                                 getAccept1< ast::Expr, Expression * >( association.expr )
    2352                         ));
    2353                 }
    2354                 this->node = visitBaseExpr( old,
    2355                         new ast::GenericExpr(
    2356                                 old->location,
    2357                                 GET_ACCEPT_1(control, Expr),
    2358                                 std::move(associations)
    2359                         )
    2360                 );
     2048        virtual void visit( TypeExpr * ) override final {
     2049
     2050        }
     2051
     2052        virtual void visit( AsmExpr * ) override final {
     2053
     2054        }
     2055
     2056        virtual void visit( ImplicitCopyCtorExpr * ) override final {
     2057
     2058        }
     2059
     2060        virtual void visit( ConstructorExpr *  ) override final {
     2061
     2062        }
     2063
     2064        virtual void visit( CompoundLiteralExpr * ) override final {
     2065
     2066        }
     2067
     2068        virtual void visit( RangeExpr * ) override final {
     2069
     2070        }
     2071
     2072        virtual void visit( UntypedTupleExpr * ) override final {
     2073
     2074        }
     2075
     2076        virtual void visit( TupleExpr * ) override final {
     2077
     2078        }
     2079
     2080        virtual void visit( TupleIndexExpr * ) override final {
     2081
     2082        }
     2083
     2084        virtual void visit( TupleAssignExpr * ) override final {
     2085
     2086        }
     2087
     2088        virtual void visit( StmtExpr *  ) override final {
     2089
     2090        }
     2091
     2092        virtual void visit( UniqueExpr *  ) override final {
     2093
     2094        }
     2095
     2096        virtual void visit( UntypedInitExpr *  ) override final {
     2097
     2098        }
     2099
     2100        virtual void visit( InitExpr *  ) override final {
     2101
     2102        }
     2103
     2104        virtual void visit( DeletedExpr * ) override final {
     2105
     2106        }
     2107
     2108        virtual void visit( DefaultArgExpr * ) override final {
     2109
     2110        }
     2111
     2112        virtual void visit( GenericExpr * ) override final {
     2113
    23612114        }
    23622115

  • src/AST/Expr.cpp

    r15934a6 r9a0cd9c  
    335335}
    336336
    337 TupleAssignExpr::TupleAssignExpr(
    338         const CodeLocation & loc, const Type * result, const StmtExpr * s )
    339 : Expr( loc, result ), stmtExpr() {
    340         stmtExpr = s;
    341 }
    342 
    343337// --- StmtExpr
    344338

  • src/AST/Expr.hpp

    r15934a6 r9a0cd9c  
    3030#define MUTATE_FRIEND template<typename node_t> friend node_t * mutate(const node_t * node);
    3131
    32 class ConverterOldToNew;
    33 
    3432namespace ast {
    3533
    … …  
    530528        std::vector<ptr<ObjectDecl>> tempDecls;
    531529        std::vector<ptr<ObjectDecl>> returnDecls;
    532         std::vector<ptr<Expr>> dtors;
     530        std::vector<ptr<ObjectDecl>> dtors;
    533531
    534532        ImplicitCopyCtorExpr( const CodeLocation& loc, const ApplicationExpr * call )
    … …  
    637635
    638636        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
    639 
    640         friend class ::ConverterOldToNew;
    641 
    642637private:
    643638        TupleAssignExpr * clone() const override { return new TupleAssignExpr{ *this }; }
    644     TupleAssignExpr( const CodeLocation & loc, const Type * result, const StmtExpr * s );
    645 
    646639        MUTATE_FRIEND
    647640};

  • src/AST/Node.cpp

    r15934a6 r9a0cd9c  
    2626#include "Type.hpp"
    2727#include "TypeSubstitution.hpp"
    28 
    29 #include "Print.hpp"
    3028
    3129template< typename node_t, enum ast::Node::ref_type ref_t >
    … …  
    4947
    5048std::ostream & ast::operator<< ( std::ostream & out, const ast::Node * node ) {
    51         print(out, node);
     49        (void)node;
     50        #warning unimplemented
     51        assertf(false, "Unimplemented");
    5252        return out;
    5353}

  • src/AST/module.mk

    r15934a6 r9a0cd9c  
    2424        AST/LinkageSpec.cpp \
    2525        AST/Node.cpp \
    26         AST/Print.cpp \
    2726        AST/Stmt.cpp \
    2827        AST/Type.cpp \

  • src/Makefile.in

    r15934a6 r9a0cd9c  
    169169        AST/Expr.$(OBJEXT) AST/Init.$(OBJEXT) \
    170170        AST/LinkageSpec.$(OBJEXT) AST/Node.$(OBJEXT) \
    171         AST/Print.$(OBJEXT) AST/Stmt.$(OBJEXT) AST/Type.$(OBJEXT) \
     171        AST/Stmt.$(OBJEXT) AST/Type.$(OBJEXT) \
    172172        AST/TypeSubstitution.$(OBJEXT)
    173173am__objects_2 = CodeGen/CodeGenerator.$(OBJEXT) \
    … …  
    577577        AST/LinkageSpec.cpp \
    578578        AST/Node.cpp \
    579         AST/Print.cpp \
    580579        AST/Stmt.cpp \
    581580        AST/Type.cpp \
    … …  
    742741        AST/$(DEPDIR)/$(am__dirstamp)
    743742AST/Node.$(OBJEXT): AST/$(am__dirstamp) AST/$(DEPDIR)/$(am__dirstamp)
    744 AST/Print.$(OBJEXT): AST/$(am__dirstamp) AST/$(DEPDIR)/$(am__dirstamp)
    745743AST/Stmt.$(OBJEXT): AST/$(am__dirstamp) AST/$(DEPDIR)/$(am__dirstamp)
    746744AST/Type.$(OBJEXT): AST/$(am__dirstamp) AST/$(DEPDIR)/$(am__dirstamp)
    … …  
    11741172@AMDEP_TRUE@@am__include@ @am__quote@AST/$(DEPDIR)/LinkageSpec.Po@am__quote@
    11751173@AMDEP_TRUE@@am__include@ @am__quote@AST/$(DEPDIR)/Node.Po@am__quote@
    1176 @AMDEP_TRUE@@am__include@ @am__quote@AST/$(DEPDIR)/Print.Po@am__quote@
    11771174@AMDEP_TRUE@@am__include@ @am__quote@AST/$(DEPDIR)/Stmt.Po@am__quote@
    11781175@AMDEP_TRUE@@am__include@ @am__quote@AST/$(DEPDIR)/Type.Po@am__quote@

  • src/SynTree/Expression.h

    r15934a6 r9a0cd9c  
    741741        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    742742        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    743 
    744         friend class ConverterNewToOld;
    745   private:
    746     TupleAssignExpr( StmtExpr * stmts );
    747743};
    748744

  • src/SynTree/TupleExpr.cc

    r15934a6 r9a0cd9c  
    105105}
    106106
    107 TupleAssignExpr::TupleAssignExpr(
    108         StmtExpr * s )
    109 : Expression(), stmtExpr(s) {
    110 }
    111 
    112 
    113107TupleAssignExpr::~TupleAssignExpr() {
    114108        delete stmtExpr;
Note: See TracChangeset for help on using the changeset viewer.