Changeset 15934a6


Ignore:
Timestamp:
May 22, 2019, 1:10:58 PM (3 years ago)
Author:
Aaron Moss <a3moss@…>
Branches:
arm-eh, cleanup-dtors, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr
Children:
4073b16, 74ad8c0
Parents:
9a0cd9c (diff), 9d23c2d (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:
src
Files:
2 added
9 edited

Legend:

Unmodified
Added
Removed
  • src/AST/Bitfield.hpp

    r9a0cd9c r15934a6  
    5757};
    5858
    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         }
     59template<typename T>
     60inline bool operator== ( const bitfield<T> & a, const bitfield<T> & b ) {
     61        return a.val == b.val;
     62}
     63
     64template<typename T>
     65inline bool operator!= ( const bitfield<T> & a, const bitfield<T> & b ) {
     66        return !(a == b);
     67}
    7468
    7569// Local Variables: //
  • src/AST/Convert.cpp

    r9a0cd9c r15934a6  
    525525        }
    526526
     527        Expression * visitBaseExpr_skipResultType(const ast::Expr * src, Expression * tgt) {
     528
     529                tgt->location  = src->location;
     530                tgt->env       = convertTypeSubstitution(src->env);
     531                tgt->extension = src->extension;
     532
     533                convertInferUnion(tgt->inferParams, tgt->resnSlots, src->inferred);
     534                return tgt;
     535        }
     536
    527537        Expression * visitBaseExpr(const ast::Expr * src, Expression * tgt) {
    528538
    529                 tgt->location = src->location;
    530 
    531539                tgt->result = get<Type>().accept1(src->result);
    532                 tgt->env    = convertTypeSubstitution(src->env);
    533 
    534                 tgt->extension = src->extension;
    535                 convertInferUnion(tgt->inferParams, tgt->resnSlots, src->inferred);
    536 
    537                 return tgt;
     540                return visitBaseExpr_skipResultType(src, tgt);
    538541        }
    539542
     
    628631
    629632        const ast::Expr * visit( const ast::VirtualCastExpr * node ) override final {
    630                 auto expr = visitBaseExpr( node,
     633                auto expr = visitBaseExpr_skipResultType( node,
    631634                        new VirtualCastExpr(
    632635                                get<Expression>().accept1(node->arg),
    633                                 nullptr // cast's "to" type is expr's result type; converted in visitBaseExpr
     636                                get<Type>().accept1(node->result)
    634637                        )
    635638                );
     
    849852
    850853        const ast::Expr * visit( const ast::TypeExpr * node ) override final {
    851                 (void)node;
     854                auto expr = visitBaseExpr( node,
     855                        new TypeExpr(
     856                                get<Type>().accept1(node->type)
     857                        )
     858                );
     859                this->node = expr;
    852860                return nullptr;
    853861        }
    854862
    855863        const ast::Expr * visit( const ast::AsmExpr * node ) override final {
    856                 (void)node;
     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;
    857872                return nullptr;
    858873        }
    859874
    860875        const ast::Expr * visit( const ast::ImplicitCopyCtorExpr * node ) override final {
    861                 (void)node;
     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;
    862886                return nullptr;
    863887        }
    864888
    865889        const ast::Expr * visit( const ast::ConstructorExpr * node ) override final {
    866                 (void)node;
     890                auto expr = visitBaseExpr( node,
     891                        new ConstructorExpr(
     892                                get<Expression>().accept1(node->callExpr)
     893                        )
     894                );
     895                this->node = expr;
    867896                return nullptr;
    868897        }
    869898
    870899        const ast::Expr * visit( const ast::CompoundLiteralExpr * node ) override final {
    871                 (void)node;
     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;
    872907                return nullptr;
    873908        }
    874909
    875910        const ast::Expr * visit( const ast::RangeExpr * node ) override final {
    876                 (void)node;
     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;
    877918                return nullptr;
    878919        }
    879920
    880921        const ast::Expr * visit( const ast::UntypedTupleExpr * node ) override final {
    881                 (void)node;
     922                auto expr = visitBaseExpr( node,
     923                        new UntypedTupleExpr(
     924                                get<Expression>().acceptL(node->exprs)
     925                        )
     926                );
     927                this->node = expr;
    882928                return nullptr;
    883929        }
    884930
    885931        const ast::Expr * visit( const ast::TupleExpr * node ) override final {
    886                 (void)node;
     932                auto expr = visitBaseExpr( node,
     933                        new UntypedTupleExpr(
     934                                get<Expression>().acceptL(node->exprs)
     935                        )
     936                );
     937                this->node = expr;
    887938                return nullptr;
    888939        }
    889940
    890941        const ast::Expr * visit( const ast::TupleIndexExpr * node ) override final {
    891                 (void)node;
     942                auto expr = visitBaseExpr( node,
     943                        new TupleIndexExpr(
     944                                get<Expression>().accept1(node->tuple),
     945                                node->index
     946                        )
     947                );
     948                this->node = expr;
    892949                return nullptr;
    893950        }
    894951
    895952        const ast::Expr * visit( const ast::TupleAssignExpr * node ) override final {
    896                 (void)node;
     953                auto expr = visitBaseExpr( node,
     954                        new TupleAssignExpr(
     955                                get<StmtExpr>().accept1(node->stmtExpr)
     956                        )
     957                );
     958                this->node = expr;
    897959                return nullptr;
    898960        }
    899961
    900962        const ast::Expr * visit( const ast::StmtExpr * node ) override final {
    901                 (void)node;
     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;
    902972                return nullptr;
    903973        }
    904974
    905975        const ast::Expr * visit( const ast::UniqueExpr * node ) override final {
    906                 (void)node;
     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;
    907985                return nullptr;
    908986        }
    909987
    910988        const ast::Expr * visit( const ast::UntypedInitExpr * node ) override final {
    911                 (void)node;
     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;
    9121003                return nullptr;
    9131004        }
    9141005
    9151006        const ast::Expr * visit( const ast::InitExpr * node ) override final {
    916                 (void)node;
     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;
    9171014                return nullptr;
    9181015        }
    9191016
    9201017        const ast::Expr * visit( const ast::DeletedExpr * node ) override final {
    921                 (void)node;
     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;
    9221027                return nullptr;
    9231028        }
    9241029
    9251030        const ast::Expr * visit( const ast::DefaultArgExpr * node ) override final {
    926                 (void)node;
     1031                auto expr = visitBaseExpr( node,
     1032                        new DefaultArgExpr(
     1033                                get<Expression>().accept1(node->expr)
     1034                        )
     1035                );
     1036                this->node = expr;
    9271037                return nullptr;
    9281038        }
    9291039
    9301040        const ast::Expr * visit( const ast::GenericExpr * node ) override final {
    931                 (void)node;
     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;
    9321055                return nullptr;
    9331056        }
     
    17411864        }
    17421865
    1743         ast::Expr * visitBaseExpr(Expression * old, ast::Expr * nw) {
    1744 
    1745                 nw->result = GET_ACCEPT_1(result, Type);
     1866        ast::Expr * visitBaseExpr_SkipResultType(Expression * old, ast::Expr * nw) {
     1867
    17461868                nw->env    = convertTypeSubstitution(old->env);
    17471869
     
    17501872
    17511873                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);;
    17521880        }
    17531881
     
    18171945
    18181946        virtual void visit( VirtualCastExpr * old ) override final {
    1819                 this->node = visitBaseExpr( old,
     1947                this->node = visitBaseExpr_SkipResultType( old,
    18201948                        new ast::VirtualCastExpr(
    18211949                                old->location,
    18221950                                GET_ACCEPT_1(arg, Expr),
    1823                                 nullptr // cast's "to" type is expr's result type; converted in visitBaseExpr
     1951                                GET_ACCEPT_1(result, Type)
    18241952                        )
    18251953                );
     
    20462174        }
    20472175
    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 
     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                );
    21142361        }
    21152362
  • src/AST/Expr.cpp

    r9a0cd9c r15934a6  
    335335}
    336336
     337TupleAssignExpr::TupleAssignExpr(
     338        const CodeLocation & loc, const Type * result, const StmtExpr * s )
     339: Expr( loc, result ), stmtExpr() {
     340        stmtExpr = s;
     341}
     342
    337343// --- StmtExpr
    338344
  • src/AST/Expr.hpp

    r9a0cd9c r15934a6  
    3030#define MUTATE_FRIEND template<typename node_t> friend node_t * mutate(const node_t * node);
    3131
     32class ConverterOldToNew;
     33
    3234namespace ast {
    3335
     
    528530        std::vector<ptr<ObjectDecl>> tempDecls;
    529531        std::vector<ptr<ObjectDecl>> returnDecls;
    530         std::vector<ptr<ObjectDecl>> dtors;
     532        std::vector<ptr<Expr>> dtors;
    531533
    532534        ImplicitCopyCtorExpr( const CodeLocation& loc, const ApplicationExpr * call )
     
    635637
    636638        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
     639
     640        friend class ::ConverterOldToNew;
     641
    637642private:
    638643        TupleAssignExpr * clone() const override { return new TupleAssignExpr{ *this }; }
     644    TupleAssignExpr( const CodeLocation & loc, const Type * result, const StmtExpr * s );
     645
    639646        MUTATE_FRIEND
    640647};
  • src/AST/Node.cpp

    r9a0cd9c r15934a6  
    2626#include "Type.hpp"
    2727#include "TypeSubstitution.hpp"
     28
     29#include "Print.hpp"
    2830
    2931template< typename node_t, enum ast::Node::ref_type ref_t >
     
    4749
    4850std::ostream & ast::operator<< ( std::ostream & out, const ast::Node * node ) {
    49         (void)node;
    50         #warning unimplemented
    51         assertf(false, "Unimplemented");
     51        print(out, node);
    5252        return out;
    5353}
  • src/AST/module.mk

    r9a0cd9c r15934a6  
    2424        AST/LinkageSpec.cpp \
    2525        AST/Node.cpp \
     26        AST/Print.cpp \
    2627        AST/Stmt.cpp \
    2728        AST/Type.cpp \
  • src/Makefile.in

    r9a0cd9c r15934a6  
    169169        AST/Expr.$(OBJEXT) AST/Init.$(OBJEXT) \
    170170        AST/LinkageSpec.$(OBJEXT) AST/Node.$(OBJEXT) \
    171         AST/Stmt.$(OBJEXT) AST/Type.$(OBJEXT) \
     171        AST/Print.$(OBJEXT) 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 \
    579580        AST/Stmt.cpp \
    580581        AST/Type.cpp \
     
    741742        AST/$(DEPDIR)/$(am__dirstamp)
    742743AST/Node.$(OBJEXT): AST/$(am__dirstamp) AST/$(DEPDIR)/$(am__dirstamp)
     744AST/Print.$(OBJEXT): AST/$(am__dirstamp) AST/$(DEPDIR)/$(am__dirstamp)
    743745AST/Stmt.$(OBJEXT): AST/$(am__dirstamp) AST/$(DEPDIR)/$(am__dirstamp)
    744746AST/Type.$(OBJEXT): AST/$(am__dirstamp) AST/$(DEPDIR)/$(am__dirstamp)
     
    11721174@AMDEP_TRUE@@am__include@ @am__quote@AST/$(DEPDIR)/LinkageSpec.Po@am__quote@
    11731175@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@
    11741177@AMDEP_TRUE@@am__include@ @am__quote@AST/$(DEPDIR)/Stmt.Po@am__quote@
    11751178@AMDEP_TRUE@@am__include@ @am__quote@AST/$(DEPDIR)/Type.Po@am__quote@
  • src/SynTree/Expression.h

    r9a0cd9c r15934a6  
    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 );
    743747};
    744748
  • src/SynTree/TupleExpr.cc

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