Changes in / [7821d6c:e1ff775]


Ignore:
Location:
src
Files:
2 deleted
61 edited

Legend:

Unmodified
Added
Removed

  • src/CodeGen/CodeGenerator.cc

    r7821d6c re1ff775  
    10881088} // namespace CodeGen
    10891089
    1090 
    1091 unsigned Indenter::tabsize = 2;
    1092 
    10931090std::ostream & operator<<( std::ostream & out, const BaseSyntaxNode * node ) {
    10941091        if ( node ) {

  • src/Common/Indenter.h

    r7821d6c re1ff775  
    1818
    1919struct Indenter {
    20         static unsigned tabsize;
    21 
    22         Indenter( unsigned int amt = tabsize, unsigned int indent = 0 ) : amt( amt ), indent( indent ) {}
    23         unsigned int amt;  // amount 1 level increases indent by (i.e. how much to increase by in operator++)
    24         unsigned int indent;
     20        Indenter( unsigned int amt = 2 ) : amt( amt ) {}
     21        unsigned int amt = 2;  // amount 1 level increases indent by (i.e. how much to increase by in operator++)
     22        unsigned int indent = 0;
    2523
    2624        Indenter & operator+=(int nlevels) { indent += amt*nlevels; return *this; }
    … …  
    3230};
    3331
    34 inline std::ostream & operator<<( std::ostream & out, const Indenter & indent ) {
     32inline std::ostream & operator<<( std::ostream & out, Indenter & indent ) {
    3533        return out << std::string(indent.indent, ' ');
    3634}

  • src/Common/utility.h

    r7821d6c re1ff775  
    2828#include <cassert>
    2929
    30 #include "Common/Indenter.h"
    31 
    3230template< typename T >
    3331static inline T * maybeClone( const T *orig ) {
    … …  
    7775
    7876template< typename Container >
    79 void printAll( const Container &container, std::ostream &os, Indenter indent = {} ) {
     77void printAll( const Container &container, std::ostream &os, int indent = 0 ) {
    8078        for ( typename Container::const_iterator i = container.begin(); i != container.end(); ++i ) {
    8179                if ( *i ) {
    82                         os << indent;
    83                         (*i)->print( os, indent );
     80                        os << std::string( indent,  ' ' );
     81                        (*i)->print( os, indent + 2 );
    8482                        // need an endl after each element because it's not easy to know when each individual item should end
    8583                        os << std::endl;
    … …  
    353351template< typename T1, typename T2 >
    354352struct group_iterate_t {
    355 private:
    356         std::tuple<T1, T2> args;
    357 public:
    358353        group_iterate_t( bool skipBoundsCheck, const T1 & v1, const T2 & v2 ) : args(v1, v2) {
    359354                assertf(skipBoundsCheck || v1.size() == v2.size(), "group iteration requires containers of the same size: <%zd, %zd>.", v1.size(), v2.size());
    360355        };
    361356
    362         typedef std::tuple<decltype(*std::get<0>(args).begin()), decltype(*std::get<1>(args).begin())> value_type;
    363         typedef decltype(std::get<0>(args).begin()) T1Iter;
    364         typedef decltype(std::get<1>(args).begin()) T2Iter;
    365 
    366357        struct iterator {
     358                typedef typename std::remove_reference<T1>::type T1val;
     359                typedef typename std::remove_reference<T2>::type T2val;
     360                typedef std::tuple<typename T1val::value_type &, typename T2val::value_type &> value_type;
     361                typedef typename T1val::iterator T1Iter;
     362                typedef typename T2val::iterator T2Iter;
    367363                typedef std::tuple<T1Iter, T2Iter> IterTuple;
    368364                IterTuple it;
    … …  
    374370                value_type operator*() const { return std::tie( *std::get<0>(it), *std::get<1>(it) ); }
    375371        };
    376 
    377372        iterator begin() { return iterator( std::get<0>(args).begin(), std::get<1>(args).begin() ); }
    378373        iterator end() { return iterator( std::get<0>(args).end(), std::get<1>(args).end() ); }
     374
     375private:
     376        std::tuple<T1, T2> args;
    379377};
    380378

  • src/GenPoly/Box.cc

    r7821d6c re1ff775  
    600600
    601601                        // add size/align for generic types to parameter list
    602                         if ( ! appExpr->get_function()->result ) return;
     602                        if ( ! appExpr->get_function()->has_result() ) return;
    603603                        FunctionType *funcType = getFunctionType( appExpr->get_function()->get_result() );
    604604                        assert( funcType );
    … …  
    714714
    715715                void Pass1::boxParam( Type *param, Expression *&arg, const TyVarMap &exprTyVars ) {
    716                         assertf( arg->result, "arg does not have result: %s", toString( arg ).c_str() );
     716                        assertf( arg->has_result(), "arg does not have result: %s", toString( arg ).c_str() );
    717717                        if ( isPolyType( param, exprTyVars ) ) {
    718718                                Type * newType = arg->get_result()->clone();
    … …  
    965965                                if ( varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic ) {
    966966                                        if ( varExpr->get_var()->get_name() == "?[?]" ) {
    967                                                 assert( appExpr->result );
     967                                                assert( appExpr->has_result() );
    968968                                                assert( appExpr->get_args().size() == 2 );
    969969                                                Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_result(), scopeTyVars, env );
    … …  
    999999                                                } // if
    10001000                                        } else if ( varExpr->get_var()->get_name() == "*?" ) {
    1001                                                 assert( appExpr->result );
     1001                                                assert( appExpr->has_result() );
    10021002                                                assert( ! appExpr->get_args().empty() );
    10031003                                                if ( isPolyType( appExpr->get_result(), scopeTyVars, env ) ) {
    … …  
    10161016                                                } // if
    10171017                                        } else if ( varExpr->get_var()->get_name() == "?++" || varExpr->get_var()->get_name() == "?--" ) {
    1018                                                 assert( appExpr->result );
     1018                                                assert( appExpr->has_result() );
    10191019                                                assert( appExpr->get_args().size() == 1 );
    10201020                                                if ( Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env ) ) {
    … …  
    10361036                                                } // if
    10371037                                        } else if ( varExpr->get_var()->get_name() == "++?" || varExpr->get_var()->get_name() == "--?" ) {
    1038                                                 assert( appExpr->result );
     1038                                                assert( appExpr->has_result() );
    10391039                                                assert( appExpr->get_args().size() == 1 );
    10401040                                                if ( Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env ) ) {
    … …  
    10421042                                                } // if
    10431043                                        } else if ( varExpr->get_var()->get_name() == "?+?" || varExpr->get_var()->get_name() == "?-?" ) {
    1044                                                 assert( appExpr->result );
     1044                                                assert( appExpr->has_result() );
    10451045                                                assert( appExpr->get_args().size() == 2 );
    10461046                                                Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_result(), scopeTyVars, env );
    … …  
    10681068                                                } // if
    10691069                                        } else if ( varExpr->get_var()->get_name() == "?+=?" || varExpr->get_var()->get_name() == "?-=?" ) {
    1070                                                 assert( appExpr->result );
     1070                                                assert( appExpr->has_result() );
    10711071                                                assert( appExpr->get_args().size() == 2 );
    10721072                                                Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env );
    … …  
    11621162                void Pass1::premutate( AddressExpr * ) { visit_children = false; }
    11631163                Expression * Pass1::postmutate( AddressExpr * addrExpr ) {
    1164                         assert( addrExpr->get_arg()->result && ! addrExpr->get_arg()->get_result()->isVoid() );
     1164                        assert( addrExpr->get_arg()->has_result() && ! addrExpr->get_arg()->get_result()->isVoid() );
    11651165
    11661166                        bool needs = false;
    11671167                        if ( UntypedExpr *expr = dynamic_cast< UntypedExpr *>( addrExpr->get_arg() ) ) {
    1168                                 if ( expr->result && isPolyType( expr->get_result(), scopeTyVars, env ) ) {
     1168                                if ( expr->has_result() && isPolyType( expr->get_result(), scopeTyVars, env ) ) {
    11691169                                        if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->get_function() ) ) {
    11701170                                                if ( name->get_name() == "*?" ) {
    11711171                                                        if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr->get_args().front() ) ) {
    1172                                                                 assert( appExpr->get_function()->result );
     1172                                                                assert( appExpr->get_function()->has_result() );
    11731173                                                                FunctionType *function = getFunctionType( appExpr->get_function()->get_result() );
    11741174                                                                assert( function );

  • src/GenPoly/FindFunction.cc

    r7821d6c re1ff775  
    1818#include <utility>                      // for pair
    1919
    20 #include "Common/PassVisitor.h"         // for PassVisitor
    2120#include "Common/SemanticError.h"       // for SemanticError
    2221#include "GenPoly/ErasableScopedMap.h"  // for ErasableScopedMap<>::iterator
    … …  
    2827
    2928namespace GenPoly {
    30         class FindFunction : public WithGuards, public WithVisitorRef<FindFunction>, public WithShortCircuiting {
     29        class FindFunction : public Mutator {
    3130          public:
    3231                FindFunction( std::list< FunctionType* > &functions, const TyVarMap &tyVars, bool replaceMode, FindFunctionPredicate predicate );
    3332
    34                 void premutate( FunctionType * functionType );
    35                 Type * postmutate( FunctionType * functionType );
    36                 void premutate( PointerType * pointerType );
     33                virtual Type *mutate( FunctionType *functionType );
     34                virtual Type *mutate( PointerType *pointerType );
    3735          private:
    3836                void handleForall( const Type::ForallList &forall );
    … …  
    4543
    4644        void findFunction( Type *type, std::list< FunctionType* > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate ) {
    47                 PassVisitor<FindFunction> finder( functions, tyVars, false, predicate );
     45                FindFunction finder( functions, tyVars, false, predicate );
    4846                type->acceptMutator( finder );
    4947        }
    5048
    5149        void findAndReplaceFunction( Type *&type, std::list< FunctionType* > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate ) {
    52                 PassVisitor<FindFunction> finder( functions, tyVars, true, predicate );
     50                FindFunction finder( functions, tyVars, true, predicate );
    5351                type = type->acceptMutator( finder );
    5452        }
    … …  
    5957
    6058        void FindFunction::handleForall( const Type::ForallList &forall ) {
    61                 for ( const Declaration * td : forall ) {
    62                         TyVarMap::iterator var = tyVars.find( td->name );
     59                for ( Type::ForallList::const_iterator i = forall.begin(); i != forall.end(); ++i ) {
     60                        TyVarMap::iterator var = tyVars.find( (*i)->get_name() );
    6361                        if ( var != tyVars.end() ) {
    6462                                tyVars.erase( var->first );
    … …  
    6765        }
    6866
    69         void FindFunction::premutate( FunctionType * functionType ) {
    70                 visit_children = false;
    71                 GuardScope( tyVars );
     67        Type * FindFunction::mutate( FunctionType *functionType ) {
     68                tyVars.beginScope();
    7269                handleForall( functionType->get_forall() );
    73                 mutateAll( functionType->get_returnVals(), *visitor );
    74         }
    75 
    76         Type * FindFunction::postmutate( FunctionType * functionType ) {
     70                mutateAll( functionType->get_returnVals(), *this );
    7771                Type *ret = functionType;
    7872                if ( predicate( functionType, tyVars ) ) {
    … …  
    8377                        } // if
    8478                } // if
     79                tyVars.endScope();
    8580                return ret;
    8681        }
    8782
    88         void FindFunction::premutate( PointerType * pointerType ) {
    89                 GuardScope( tyVars );
     83        Type * FindFunction::mutate( PointerType *pointerType ) {
     84                tyVars.beginScope();
    9085                handleForall( pointerType->get_forall() );
     86                Type *ret = Mutator::mutate( pointerType );
     87                tyVars.endScope();
     88                return ret;
    9189        }
    9290} // namespace GenPoly

  • src/GenPoly/Specialize.cc

    r7821d6c re1ff775  
    147147
    148148        Expression * Specialize::doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams ) {
    149                 assertf( actual->result, "attempting to specialize an untyped expression" );
     149                assertf( actual->has_result(), "attempting to specialize an untyped expression" );
    150150                if ( needsSpecialization( formalType, actual->get_result(), env ) ) {
    151151                        if ( FunctionType *funType = getFunctionType( formalType ) ) {

  • src/InitTweak/FixInit.cc

    r7821d6c re1ff775  
    390390                        assert( env );
    391391                        CP_CTOR_PRINT( std::cerr << "Type Substitution: " << *env << std::endl; )
    392                         assert( arg->result );
     392                        assert( arg->has_result() );
    393393                        Type * result = arg->get_result();
    394394                        if ( skipCopyConstruct( result ) ) return; // skip certain non-copyable types
    … …  
    552552                                Expression * retExpr = new CommaExpr( assign, new VariableExpr( returnDecl ) );
    553553                                // move env from callExpr to retExpr
    554                                 std::swap( retExpr->env, callExpr->env );
     554                                retExpr->set_env( callExpr->get_env() );
     555                                callExpr->set_env( nullptr );
    555556                                return retExpr;
    556557                        } else {
    … …  
    11251126                        static UniqueName tempNamer( "_tmp_ctor_expr" );
    11261127                        // xxx - is the size check necessary?
    1127                         assert( ctorExpr->result && ctorExpr->get_result()->size() == 1 );
     1128                        assert( ctorExpr->has_result() && ctorExpr->get_result()->size() == 1 );
    11281129
    11291130                        // xxx - ideally we would reuse the temporary generated from the copy constructor passes from within firstArg if it exists and not generate a temporary if it's unnecessary.

  • src/Parser/ExpressionNode.cc

    r7821d6c re1ff775  
    8787                } else {
    8888                        assertf( false, "internal error, bad integral length %s", str.c_str() );
    89                 } // if
     89                } // if         
    9090                posn += 1;
    9191        } // if
    … …  
    397397
    398398NameExpr * build_varref( const string * name ) {
    399         NameExpr * expr = new NameExpr( *name );
     399        NameExpr * expr = new NameExpr( *name, nullptr );
    400400        delete name;
    401401        return expr;
    … …  
    488488        list< Expression * > args;
    489489        buildMoveList( expr_node, args );
    490         return new UntypedExpr( maybeMoveBuild< Expression >(function), args );
     490        return new UntypedExpr( maybeMoveBuild< Expression >(function), args, nullptr );
    491491} // build_func
    492492

  • src/ResolvExpr/AdjustExprType.cc

    r7821d6c re1ff775  
    1414//
    1515
    16 #include "Common/PassVisitor.h"
    1716#include "SymTab/Indexer.h"       // for Indexer
    1817#include "SynTree/Declaration.h"  // for TypeDecl, TypeDecl::Kind::Ftype
    … …  
    2221
    2322namespace ResolvExpr {
    24         class AdjustExprType : public WithShortCircuiting {
     23        class AdjustExprType : public Mutator {
     24                typedef Mutator Parent;
     25                using Parent::mutate;
    2526          public:
    2627                AdjustExprType( const TypeEnvironment &env, const SymTab::Indexer &indexer );
    27                 void premutate( VoidType * ) { visit_children = false; }
    28                 void premutate( BasicType * ) { visit_children = false; }
    29                 void premutate( PointerType * ) { visit_children = false; }
    30                 void premutate( FunctionType * ) { visit_children = false; }
    31                 void premutate( StructInstType * ) { visit_children = false; }
    32                 void premutate( UnionInstType * ) { visit_children = false; }
    33                 void premutate( EnumInstType * ) { visit_children = false; }
    34                 void premutate( TraitInstType * ) { visit_children = false; }
    35                 void premutate( TypeInstType * ) { visit_children = false; }
    36                 void premutate( TupleType * ) { visit_children = false; }
    37                 void premutate( VarArgsType * ) { visit_children = false; }
    38                 void premutate( ZeroType * ) { visit_children = false; }
    39                 void premutate( OneType * ) { visit_children = false; }
     28          private:
     29                virtual Type* mutate( VoidType *voidType );
     30                virtual Type* mutate( BasicType *basicType );
     31                virtual Type* mutate( PointerType *pointerType );
     32                virtual Type* mutate( ArrayType *arrayType );
     33                virtual Type* mutate( FunctionType *functionType );
     34                virtual Type* mutate( StructInstType *aggregateUseType );
     35                virtual Type* mutate( UnionInstType *aggregateUseType );
     36                virtual Type* mutate( EnumInstType *aggregateUseType );
     37                virtual Type* mutate( TraitInstType *aggregateUseType );
     38                virtual Type* mutate( TypeInstType *aggregateUseType );
     39                virtual Type* mutate( TupleType *tupleType );
     40                virtual Type* mutate( VarArgsType *varArgsType );
     41                virtual Type* mutate( ZeroType *zeroType );
     42                virtual Type* mutate( OneType *oneType );
    4043
    41                 Type * postmutate( ArrayType *arrayType );
    42                 Type * postmutate( FunctionType *functionType );
    43                 Type * postmutate( TypeInstType *aggregateUseType );
    44 
    45           private:
    4644                const TypeEnvironment &env;
    4745                const SymTab::Indexer &indexer;
    … …  
    4947
    5048        void adjustExprType( Type *&type, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
    51                 PassVisitor<AdjustExprType> adjuster( env, indexer );
     49                AdjustExprType adjuster( env, indexer );
    5250                Type *newType = type->acceptMutator( adjuster );
    5351                type = newType;
    … …  
    5856        }
    5957
    60         Type * AdjustExprType::postmutate( ArrayType * arrayType ) {
     58        Type *AdjustExprType::mutate( VoidType *voidType ) {
     59                return voidType;
     60        }
     61
     62        Type *AdjustExprType::mutate( BasicType *basicType ) {
     63                return basicType;
     64        }
     65
     66        Type *AdjustExprType::mutate( PointerType *pointerType ) {
     67                return pointerType;
     68        }
     69
     70        Type *AdjustExprType::mutate( ArrayType *arrayType ) {
    6171                // need to recursively mutate the base type in order for multi-dimensional arrays to work.
    62                 PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->base );
    63                 arrayType->base = nullptr;
     72                PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->get_base()->clone()->acceptMutator( *this ) );
    6473                delete arrayType;
    6574                return pointerType;
    6675        }
    6776
    68         Type * AdjustExprType::postmutate( FunctionType * functionType ) {
    69                 return new PointerType( Type::Qualifiers(), functionType );
     77        Type *AdjustExprType::mutate( FunctionType *functionType ) {
     78                PointerType *pointerType = new PointerType( Type::Qualifiers(), functionType );
     79                return pointerType;
    7080        }
    7181
    72         Type * AdjustExprType::postmutate( TypeInstType * typeInst ) {
     82        Type *AdjustExprType::mutate( StructInstType *aggregateUseType ) {
     83                return aggregateUseType;
     84        }
     85
     86        Type *AdjustExprType::mutate( UnionInstType *aggregateUseType ) {
     87                return aggregateUseType;
     88        }
     89
     90        Type *AdjustExprType::mutate( EnumInstType *aggregateUseType ) {
     91                return aggregateUseType;
     92        }
     93
     94        Type *AdjustExprType::mutate( TraitInstType *aggregateUseType ) {
     95                return aggregateUseType;
     96        }
     97
     98        Type *AdjustExprType::mutate( TypeInstType *typeInst ) {
    7399                EqvClass eqvClass;
    74100                if ( env.lookup( typeInst->get_name(), eqvClass ) ) {
    … …  
    87113                return typeInst;
    88114        }
     115
     116        Type *AdjustExprType::mutate( TupleType *tupleType ) {
     117                return tupleType;
     118        }
     119
     120        Type *AdjustExprType::mutate( VarArgsType *varArgsType ) {
     121                return varArgsType;
     122        }
     123
     124        Type *AdjustExprType::mutate( ZeroType *zeroType ) {
     125                return zeroType;
     126        }
     127
     128        Type *AdjustExprType::mutate( OneType *oneType ) {
     129                return oneType;
     130        }
    89131} // namespace ResolvExpr
    90132

  • src/ResolvExpr/Alternative.cc

    r7821d6c re1ff775  
    6666        }
    6767
    68         void Alternative::print( std::ostream &os, Indenter indent ) const {
    69                 os << "Cost " << cost << ": ";
     68        void Alternative::print( std::ostream &os, int indent ) const {
     69                os << std::string( indent, ' ' ) << "Cost " << cost << ": ";
    7070                if ( expr ) {
    71                         expr->print( os, indent+1 );
    72                         os << std::endl << indent << "(types:" << std::endl;
    73                         os << indent+1;
    74                         expr->result->print( os, indent+1 );
    75                         os << std::endl << indent << ")" << std::endl;
     71                        expr->print( os, indent );
     72                        os << "(types:" << std::endl;
     73                        os << std::string( indent+4, ' ' );
     74                        expr->get_result()->print( os, indent + 4 );
     75                        os << std::endl << ")" << std::endl;
    7676                } else {
    7777                        os << "Null expression!" << std::endl;
    7878                } // if
    79                 os << indent << "Environment: ";
    80                 env.print( os, indent+1 );
     79                os << std::string( indent, ' ' ) << "Environment: ";
     80                env.print( os, indent+2 );
    8181                os << std::endl;
    8282        }

  • src/ResolvExpr/Alternative.h

    r7821d6c re1ff775  
    3939                ~Alternative();
    4040
    41                 void print( std::ostream &os, Indenter indent = {} ) const;
     41                void print( std::ostream &os, int indent = 0 ) const;
    4242
    4343                Cost cost;

  • src/ResolvExpr/AlternativeFinder.cc

    r7821d6c re1ff775  
    7575
    7676        namespace {
    77                 void printAlts( const AltList &list, std::ostream &os, unsigned int indentAmt = 0 ) {
    78                         Indenter indent = { Indenter::tabsize, indentAmt };
     77                void printAlts( const AltList &list, std::ostream &os, int indent = 0 ) {
    7978                        for ( AltList::const_iterator i = list.begin(); i != list.end(); ++i ) {
    8079                                i->print( os, indent );
    … …  
    196195                                AltList winners;
    197196                                findMinCost( alternatives.begin(), alternatives.end(), back_inserter( winners ) );
    198                                 stream << "Cannot choose between " << winners.size() << " alternatives for expression\n";
     197                                stream << "Cannot choose between " << winners.size() << " alternatives for expression ";
    199198                                expr->print( stream );
    200                                 stream << "Alternatives are:\n";
    201                                 printAlts( winners, stream, 1 );
     199                                stream << "Alternatives are:";
     200                                printAlts( winners, stream, 8 );
    202201                                throw SemanticError( stream.str() );
    203202                        }
    … …  
    729728                PRINT(
    730729                        std::cerr << "known function ops:" << std::endl;
    731                         printAlts( funcOpFinder.alternatives, std::cerr, 1 );
     730                        printAlts( funcOpFinder.alternatives, std::cerr, 8 );
    732731                )
    733732
    … …  
    839838        bool isLvalue( Expression *expr ) {
    840839                // xxx - recurse into tuples?
    841                 return expr->result && ( expr->get_result()->get_lvalue() || dynamic_cast< ReferenceType * >( expr->get_result() ) );
     840                return expr->has_result() && ( expr->get_result()->get_lvalue() || dynamic_cast< ReferenceType * >( expr->get_result() ) );
    842841        }
    843842
    … …  
    973972                PRINT( std::cerr << "nameExpr is " << nameExpr->get_name() << std::endl; )
    974973                for ( std::list< DeclarationWithType* >::iterator i = declList.begin(); i != declList.end(); ++i ) {
    975                         VariableExpr newExpr( *i );
     974                        VariableExpr newExpr( *i, nameExpr->get_argName() );
    976975                        alternatives.push_back( Alternative( newExpr.clone(), env, Cost::zero ) );
    977976                        PRINT(

  • src/ResolvExpr/ResolveTypeof.cc

    r7821d6c re1ff775  
    1818#include <cassert>               // for assert
    1919
    20 #include "Common/PassVisitor.h"  // for PassVisitor
    2120#include "Resolver.h"            // for resolveInVoidContext
    2221#include "SynTree/Expression.h"  // for Expression
    … …  
    4241        }
    4342
    44         class ResolveTypeof : public WithShortCircuiting {
     43        class ResolveTypeof : public Mutator {
    4544          public:
    4645                ResolveTypeof( const SymTab::Indexer &indexer ) : indexer( indexer ) {}
    47                 void premutate( TypeofType *typeofType );
    48                 Type * postmutate( TypeofType *typeofType );
     46                Type *mutate( TypeofType *typeofType );
    4947
    5048          private:
    … …  
    5250        };
    5351
    54         Type * resolveTypeof( Type *type, const SymTab::Indexer &indexer ) {
    55                 PassVisitor<ResolveTypeof> mutator( indexer );
     52        Type *resolveTypeof( Type *type, const SymTab::Indexer &indexer ) {
     53                ResolveTypeof mutator( indexer );
    5654                return type->acceptMutator( mutator );
    5755        }
    5856
    59         void ResolveTypeof::premutate( TypeofType * ) {
    60                 visit_children = false;
    61         }
    62 
    63         Type * ResolveTypeof::postmutate( TypeofType *typeofType ) {
     57        Type *ResolveTypeof::mutate( TypeofType *typeofType ) {
    6458#if 0
    65                 std::cerr << "resolving typeof: ";
    66                 typeofType->print( std::cerr );
    67                 std::cerr << std::endl;
     59                std::cout << "resolving typeof: ";
     60                typeofType->print( std::cout );
     61                std::cout << std::endl;
    6862#endif
    69                 if ( typeofType->expr ) {
    70                         Expression * newExpr = resolveInVoidContext( typeofType->expr, indexer );
    71                         assert( newExpr->result && ! newExpr->result->isVoid() );
    72                         Type * newType = newExpr->result;
    73                         newExpr->result = nullptr;
     63                if ( typeofType->get_expr() ) {
     64                        Expression *newExpr = resolveInVoidContext( typeofType->get_expr(), indexer );
     65                        assert( newExpr->has_result() && ! newExpr->get_result()->isVoid() );
     66                        Type *newType = newExpr->get_result();
     67                        newExpr->set_result( nullptr );
    7468                        delete typeofType;
    7569                        delete newExpr;

  • src/ResolvExpr/TypeEnvironment.cc

    r7821d6c re1ff775  
    6868        }
    6969
    70         void EqvClass::print( std::ostream &os, Indenter indent ) const {
    71                 os << "( ";
     70        void EqvClass::print( std::ostream &os, int indent ) const {
     71                os << std::string( indent, ' ' ) << "( ";
    7272                std::copy( vars.begin(), vars.end(), std::ostream_iterator< std::string >( os, " " ) );
    7373                os << ")";
    7474                if ( type ) {
    7575                        os << " -> ";
    76                         type->print( os, indent+1 );
     76                        type->print( os, indent );
    7777                } // if
    7878                if ( ! allowWidening ) {
    … …  
    144144        }
    145145
    146         void TypeEnvironment::print( std::ostream &os, Indenter indent ) const {
     146        void TypeEnvironment::print( std::ostream &os, int indent ) const {
    147147                for ( std::list< EqvClass >::const_iterator i = env.begin(); i != env.end(); ++i ) {
    148148                        i->print( os, indent );

  • src/ResolvExpr/TypeEnvironment.h

    r7821d6c re1ff775  
    6868                EqvClass &operator=( const EqvClass &other );
    6969                ~EqvClass();
    70                 void print( std::ostream &os, Indenter indent = {} ) const;
     70                void print( std::ostream &os, int indent = 0 ) const;
    7171        };
    7272
    … …  
    8080                void makeSubstitution( TypeSubstitution &result ) const;
    8181                bool isEmpty() const { return env.empty(); }
    82                 void print( std::ostream &os, Indenter indent = {} ) const;
     82                void print( std::ostream &os, int indent = 0 ) const;
    8383                void combine( const TypeEnvironment &second, Type *(*combineFunc)( Type*, Type* ) );
    8484                void simpleCombine( const TypeEnvironment &second );

  • src/ResolvExpr/Unify.cc

    r7821d6c re1ff775  
    2222#include <utility>                // for pair
    2323
    24 #include "Common/PassVisitor.h"   // for PassVisitor
    2524#include "FindOpenVars.h"         // for findOpenVars
    2625#include "Parser/LinkageSpec.h"   // for C
    … …  
    538537        /// If this isn't done then argument lists can have wildly different
    539538        /// size and structure, when they should be compatible.
    540         struct TtypeExpander : public WithShortCircuiting {
    541                 TypeEnvironment & tenv;
    542                 TtypeExpander( TypeEnvironment & tenv ) : tenv( tenv ) {}
    543                 void premutate( TypeInstType * ) { visit_children = false; }
    544                 Type * postmutate( TypeInstType * typeInst ) {
     539        struct TtypeExpander : public Mutator {
     540                TypeEnvironment & env;
     541                TtypeExpander( TypeEnvironment & env ) : env( env ) {}
     542                Type * mutate( TypeInstType * typeInst ) {
    545543                        EqvClass eqvClass;
    546                         if ( tenv.lookup( typeInst->get_name(), eqvClass ) ) {
     544                        if ( env.lookup( typeInst->get_name(), eqvClass ) ) {
    547545                                if ( eqvClass.data.kind == TypeDecl::Ttype ) {
    548546                                        // expand ttype parameter into its actual type
    … …  
    562560                dst.clear();
    563561                for ( DeclarationWithType * dcl : src ) {
    564                         PassVisitor<TtypeExpander> expander( env );
     562                        TtypeExpander expander( env );
    565563                        dcl->acceptMutator( expander );
    566564                        std::list< Type * > types;
    … …  
    752750                        std::list<Type *> types1, types2;
    753751
    754                         PassVisitor<TtypeExpander> expander( env );
     752                        TtypeExpander expander( env );
    755753                        flat1->acceptMutator( expander );
    756754                        flat2->acceptMutator( expander );

  • src/SymTab/FixFunction.cc

    r7821d6c re1ff775  
    2626        FixFunction::FixFunction() : isVoid( false ) {}
    2727
    28 
    29         DeclarationWithType * FixFunction::postmutate(FunctionDecl *functionDecl) {
     28        DeclarationWithType * FixFunction::mutate(FunctionDecl *functionDecl) {
    3029                // can't delete function type because it may contain assertions, so transfer ownership to new object
    31                 ObjectDecl *pointer = new ObjectDecl( functionDecl->name, functionDecl->get_storageClasses(), functionDecl->linkage, nullptr, new PointerType( Type::Qualifiers(), functionDecl->type ), nullptr, functionDecl->attributes );
    32                 functionDecl->attributes.clear();
     30                ObjectDecl *pointer = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClasses(), functionDecl->get_linkage(), 0, new PointerType( Type::Qualifiers(), functionDecl->get_type() ), 0, functionDecl->get_attributes() );
     31                functionDecl->get_attributes().clear();
    3332                functionDecl->type = nullptr;
    3433                delete functionDecl;
    … …  
    3635        }
    3736
    38         Type * FixFunction::postmutate(ArrayType *arrayType) {
     37        Type * FixFunction::mutate(VoidType *voidType) {
     38                isVoid = true;
     39                return voidType;
     40        }
     41
     42        Type * FixFunction::mutate(BasicType *basicType) {
     43                return basicType;
     44        }
     45
     46        Type * FixFunction::mutate(PointerType *pointerType) {
     47                return pointerType;
     48        }
     49
     50        Type * FixFunction::mutate(ArrayType *arrayType) {
    3951                // need to recursively mutate the base type in order for multi-dimensional arrays to work.
    40                 PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->base, arrayType->dimension, arrayType->isVarLen, arrayType->isStatic );
    41                 arrayType->base = nullptr;
    42                 arrayType->dimension = nullptr;
     52                PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->get_base()->clone()->acceptMutator( *this ), maybeClone( arrayType->get_dimension() ), arrayType->get_isVarLen(), arrayType->get_isStatic() );
    4353                delete arrayType;
    4454                return pointerType;
    4555        }
    4656
    47         void FixFunction::premutate(VoidType *) {
    48                 isVoid = true;
     57        Type * FixFunction::mutate(StructInstType *aggregateUseType) {
     58                return aggregateUseType;
    4959        }
    5060
    51         void FixFunction::premutate(FunctionDecl *) { visit_children = false; }
    52         void FixFunction::premutate(BasicType *) { visit_children = false; }
    53         void FixFunction::premutate(PointerType *) { visit_children = false; }
    54         void FixFunction::premutate(StructInstType *) { visit_children = false; }
    55         void FixFunction::premutate(UnionInstType *) { visit_children = false; }
    56         void FixFunction::premutate(EnumInstType *) { visit_children = false; }
    57         void FixFunction::premutate(TraitInstType *) { visit_children = false; }
    58         void FixFunction::premutate(TypeInstType *) { visit_children = false; }
    59         void FixFunction::premutate(TupleType *) { visit_children = false; }
    60         void FixFunction::premutate(VarArgsType *) { visit_children = false; }
    61         void FixFunction::premutate(ZeroType *) { visit_children = false; }
    62         void FixFunction::premutate(OneType *) { visit_children = false; }
     61        Type * FixFunction::mutate(UnionInstType *aggregateUseType) {
     62                return aggregateUseType;
     63        }
     64
     65        Type * FixFunction::mutate(EnumInstType *aggregateUseType) {
     66                return aggregateUseType;
     67        }
     68
     69        Type * FixFunction::mutate(TraitInstType *aggregateUseType) {
     70                return aggregateUseType;
     71        }
     72
     73        Type * FixFunction::mutate(TypeInstType *aggregateUseType) {
     74                return aggregateUseType;
     75        }
     76
     77        Type * FixFunction::mutate(TupleType *tupleType) {
     78                return tupleType;
     79        }
     80
     81        Type * FixFunction::mutate(VarArgsType *varArgsType) {
     82                return varArgsType;
     83        }
     84
     85        Type * FixFunction::mutate(ZeroType *zeroType) {
     86                return zeroType;
     87        }
     88
     89        Type * FixFunction::mutate(OneType *oneType) {
     90                return oneType;
     91        }
    6392} // namespace SymTab
    6493

  • src/SymTab/FixFunction.h

    r7821d6c re1ff775  
    1616#pragma once
    1717
    18 #include "Common/PassVisitor.h" // for PassVisitor
    19 #include "SynTree/SynTree.h"    // for Types
     18#include "SynTree/Mutator.h"  // for Mutator
     19#include "SynTree/SynTree.h"  // for Types
    2020
    2121namespace SymTab {
    2222        /// Replaces function and array types by equivalent pointer types.
    23         class FixFunction : public WithShortCircuiting {
     23        class FixFunction : public Mutator {
    2424                typedef Mutator Parent;
    2525          public:
    2626                FixFunction();
    2727
    28                 void premutate(FunctionDecl *functionDecl);
    29                 DeclarationWithType* postmutate(FunctionDecl *functionDecl);
     28                bool get_isVoid() const { return isVoid; }
     29                void set_isVoid( bool newValue ) { isVoid = newValue; }
     30          private:
     31                virtual DeclarationWithType* mutate(FunctionDecl *functionDecl);
    3032
    31                 Type * postmutate(ArrayType * arrayType);
    32 
    33                 void premutate(VoidType * voidType);
    34                 void premutate(BasicType * basicType);
    35                 void premutate(PointerType * pointerType);
    36                 void premutate(StructInstType * aggregateUseType);
    37                 void premutate(UnionInstType * aggregateUseType);
    38                 void premutate(EnumInstType * aggregateUseType);
    39                 void premutate(TraitInstType * aggregateUseType);
    40                 void premutate(TypeInstType * aggregateUseType);
    41                 void premutate(TupleType * tupleType);
    42                 void premutate(VarArgsType * varArgsType);
    43                 void premutate(ZeroType * zeroType);
    44                 void premutate(OneType * oneType);
     33                virtual Type* mutate(VoidType *voidType);
     34                virtual Type* mutate(BasicType *basicType);
     35                virtual Type* mutate(PointerType *pointerType);
     36                virtual Type* mutate(ArrayType *arrayType);
     37                virtual Type* mutate(StructInstType *aggregateUseType);
     38                virtual Type* mutate(UnionInstType *aggregateUseType);
     39                virtual Type* mutate(EnumInstType *aggregateUseType);
     40                virtual Type* mutate(TraitInstType *aggregateUseType);
     41                virtual Type* mutate(TypeInstType *aggregateUseType);
     42                virtual Type* mutate(TupleType *tupleType);
     43                virtual Type* mutate(VarArgsType *varArgsType);
     44                virtual Type* mutate(ZeroType *zeroType);
     45                virtual Type* mutate(OneType *oneType);
    4546
    4647                bool isVoid;

  • src/SymTab/Validate.cc

    r7821d6c re1ff775  
    369369                        DWTIterator begin( dwts.begin() ), end( dwts.end() );
    370370                        if ( begin == end ) return;
    371                         PassVisitor<FixFunction> fixer;
     371                        FixFunction fixer;
    372372                        DWTIterator i = begin;
    373373                        *i = (*i)->acceptMutator( fixer );
    374                         if ( fixer.pass.isVoid ) {
     374                        if ( fixer.get_isVoid() ) {
    375375                                DWTIterator j = i;
    376376                                ++i;
    … …  
    383383                                ++i;
    384384                                for ( ; i != end; ++i ) {
    385                                         PassVisitor<FixFunction> fixer;
     385                                        FixFunction fixer;
    386386                                        *i = (*i)->acceptMutator( fixer );
    387                                         if ( fixer.pass.isVoid ) {
     387                                        if ( fixer.get_isVoid() ) {
    388388                                                throw SemanticError( "invalid type void in function type ", func );
    389389                                        } // if
    … …  
    597597                        // apply FixFunction to every assertion to check for invalid void type
    598598                        for ( DeclarationWithType *& assertion : type->assertions ) {
    599                                 PassVisitor<FixFunction> fixer;
     599                                FixFunction fixer;
    600600                                assertion = assertion->acceptMutator( fixer );
    601                                 if ( fixer.pass.isVoid ) {
     601                                if ( fixer.get_isVoid() ) {
    602602                                        throw SemanticError( "invalid type void in assertion of function ", node );
    603603                                } // if

  • src/SynTree/AddressExpr.cc

    r7821d6c re1ff775  
    3333        Type * addrType( Type * type ) {
    3434                if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( type ) ) {
    35                         return new ReferenceType( refType->get_qualifiers(), addrType( refType->base ) );
     35                        return new ReferenceType( refType->get_qualifiers(), addrType( refType->get_base() ) );
    3636                } else {
    3737                        return new PointerType( Type::Qualifiers(), type->clone() );
    … …  
    4040}
    4141
    42 AddressExpr::AddressExpr( Expression *arg ) : Expression(), arg( arg ) {
    43         if ( arg->result ) {
    44                 if ( arg->result->get_lvalue() ) {
     42AddressExpr::AddressExpr( Expression *arg, Expression *_aname ) : Expression( _aname ), arg( arg ) {
     43        if ( arg->has_result() ) {
     44                if ( arg->get_result()->get_lvalue() ) {
    4545                        // lvalue, retains all layers of reference and gains a pointer inside the references
    46                         set_result( addrType( arg->result ) );
     46                        set_result( addrType( arg->get_result() ) );
    4747                } else {
    4848                        // taking address of non-lvalue -- must be a reference, loses one layer of reference
    49                         ReferenceType * refType = strict_dynamic_cast< ReferenceType * >( arg->result );
    50                         set_result( addrType( refType->base ) );
     49                        ReferenceType * refType = strict_dynamic_cast< ReferenceType * >( arg->get_result() );
     50                        set_result( addrType( refType->get_base() ) );
    5151                }
    5252                // result of & is never an lvalue
    … …  
    6262}
    6363
    64 void AddressExpr::print( std::ostream &os, Indenter indent ) const {
     64void AddressExpr::print( std::ostream &os, int indent ) const {
    6565        os << "Address of:" << std::endl;
    6666        if ( arg ) {
    67                 os << indent+1;
    68                 arg->print( os, indent+1 );
     67                os << std::string( indent+2, ' ' );
     68                arg->print( os, indent+2 );
    6969        } // if
    7070}
    … …  
    7777LabelAddressExpr::~LabelAddressExpr() {}
    7878
    79 void LabelAddressExpr::print( std::ostream & os, Indenter ) const {
    80         os << "Address of label:" << arg;
     79void LabelAddressExpr::print( std::ostream & os, int indent ) const {
     80        os << "Address of label:" << std::endl << std::string( indent+2, ' ' ) << arg;
    8181}
    8282

  • src/SynTree/AggregateDecl.cc

    r7821d6c re1ff775  
    4141}
    4242
    43 void AggregateDecl::print( std::ostream &os, Indenter indent ) const {
     43void AggregateDecl::print( std::ostream &os, int indent ) const {
    4444        using std::string;
    4545        using std::endl;
    4646
    47         os << typeString() << " " << name << ":";
     47        os << typeString() << " " << get_name() << ":";
    4848        if ( get_linkage() != LinkageSpec::Cforall ) {
    49                 os << " " << LinkageSpec::linkageName( linkage );
     49                os << " " << LinkageSpec::linkageName( get_linkage() );
    5050        } // if
    51         os << " with body " << has_body();
     51        os << " with body " << has_body() << endl;
    5252
    5353        if ( ! parameters.empty() ) {
    54                 os << endl << indent << "... with parameters" << endl;
    55                 printAll( parameters, os, indent+1 );
     54                os << endl << string( indent+2, ' ' ) << "with parameters" << endl;
     55                printAll( parameters, os, indent+4 );
    5656        } // if
    5757        if ( ! members.empty() ) {
    58                 os << endl << indent << "... with members" << endl;
    59                 printAll( members, os, indent+1 );
     58                os << endl << string( indent+2, ' ' ) << "with members" << endl;
     59                printAll( members, os, indent+4 );
    6060        } // if
    6161        if ( ! attributes.empty() ) {
    62                 os << endl << indent << "... with attributes" << endl;
    63                 printAll( attributes, os, indent+1 );
     62                os << endl << string( indent+2, ' ' ) << "with attributes" << endl;
     63                printAll( attributes, os, indent+4 );
    6464        } // if
    65         os << endl;
    6665}
    6766
    68 void AggregateDecl::printShort( std::ostream &os, Indenter indent ) const {
     67void AggregateDecl::printShort( std::ostream &os, int indent ) const {
    6968        using std::string;
    7069        using std::endl;
    7170
    72         os << typeString() << " " << name << " with body " << has_body() << endl;
     71        os << typeString() << " " << get_name();
     72        os << string( indent+2, ' ' ) << "with body " << has_body() << endl;
    7373
    7474        if ( ! parameters.empty() ) {
    75                 os << indent << "... with parameters" << endl;
    76                 printAll( parameters, os, indent+1 );
     75                os << endl << string( indent+2, ' ' ) << "with parameters" << endl;
     76                printAll( parameters, os, indent+4 );
    7777        } // if
    7878}

  • src/SynTree/ApplicationExpr.cc

    r7821d6c re1ff775  
    5555        set_result( ResolvExpr::extractResultType( function ) );
    5656
    57         assert( result );
     57        assert( has_result() );
    5858}
    5959
    … …  
    6868}
    6969
    70 void printInferParams( const InferredParams & inferParams, std::ostream &os, Indenter indent, int level ) {
     70void printInferParams( const InferredParams & inferParams, std::ostream &os, int indent, int level ) {
    7171        if ( ! inferParams.empty() ) {
    72                 os << indent << "with inferred parameters " << level << ":" << std::endl;
     72                os << std::string(indent, ' ') << "with inferred parameters " << level << ":" << std::endl;
    7373                for ( InferredParams::const_iterator i = inferParams.begin(); i != inferParams.end(); ++i ) {
    74                         os << indent+1;
    75                         Declaration::declFromId( i->second.decl )->printShort( os, indent+1 );
     74                        os << std::string(indent+2, ' ');
     75                        Declaration::declFromId( i->second.decl )->printShort( os, indent+2 );
    7676                        os << std::endl;
    77                         printInferParams( *i->second.inferParams, os, indent+1, level+1 );
     77                        printInferParams( *i->second.inferParams, os, indent+2, level+1 );
    7878                } // for
    7979        } // if
    8080}
    8181
    82 void ApplicationExpr::print( std::ostream &os, Indenter indent ) const {
    83         os << "Application of" << std::endl << indent+1;
    84         function->print( os, indent+1 );
    85         os << std::endl;
     82void ApplicationExpr::print( std::ostream &os, int indent ) const {
     83        os << "Application of" << std::endl << std::string(indent+2, ' ');
     84        function->print( os, indent+2 );
    8685        if ( ! args.empty() ) {
    87                 os << indent << "... to arguments" << std::endl;
    88                 printAll( args, os, indent+1 );
     86                os << std::string( indent, ' ' ) << "to arguments" << std::endl;
     87                printAll( args, os, indent+2 );
    8988        } // if
    90         printInferParams( inferParams, os, indent+1, 0 );
     89        printInferParams( inferParams, os, indent+2, 0 );
    9190        Expression::print( os, indent );
    9291}

  • src/SynTree/ArrayType.cc

    r7821d6c re1ff775  
    3939}
    4040
    41 void ArrayType::print( std::ostream &os, Indenter indent ) const {
     41void ArrayType::print( std::ostream &os, int indent ) const {
    4242        Type::print( os, indent );
    4343        if ( isStatic ) {

  • src/SynTree/AttrType.cc

    r7821d6c re1ff775  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // AttrType.cc.cc --
     7// AttrType.cc.cc -- 
    88//
    99// Author           : Richard C. Bilson
    … …  
    4242}
    4343
    44 void AttrType::print( std::ostream &os, Indenter indent ) const {
     44void AttrType::print( std::ostream &os, int indent ) const {
    4545        Type::print( os, indent );
    4646        os << "attribute " << name << " applied to ";

  • src/SynTree/Attribute.cc

    r7821d6c re1ff775  
    2828}
    2929
    30 void Attribute::print( std::ostream &os, Indenter indent ) const {
     30void Attribute::print( std::ostream &os, int indent ) const {
    3131  using std::endl;
    3232  using std::string;
    … …  
    3636    if ( ! parameters.empty() ) {
    3737      os << " with parameters: " << endl;
    38       printAll( parameters, os, indent+1 );
     38      printAll( parameters, os, indent );
    3939    }
    4040  }

  • src/SynTree/Attribute.h

    r7821d6c re1ff775  
    4646        virtual void accept( Visitor & v ) override { v.visit( this ); }
    4747        virtual Attribute * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    48         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     48        virtual void print( std::ostream & os, int indent = 0 ) const override;
    4949};
    5050

  • src/SynTree/BaseSyntaxNode.h

    r7821d6c re1ff775  
    1717
    1818#include "Common/CodeLocation.h"
    19 #include "Common/Indenter.h"
    2019class Visitor;
    2120class Mutator;
    … …  
    3029        virtual void accept( Visitor & v ) = 0;
    3130        virtual BaseSyntaxNode * acceptMutator( Mutator & m ) = 0;
    32   /// Notes:
    33   /// * each node is responsible for indenting its children.
    34   /// * Expressions should not finish with a newline, since the expression's parent has better information.
    35         virtual void print( std::ostream & os, Indenter indent = {} ) const = 0;
    36   void print( std::ostream & os, unsigned int indent ) {
    37     print( os, Indenter{ Indenter::tabsize, indent });
    38   }
     31        virtual void print( std::ostream & os, int indent = 0 ) const = 0;
    3932};
    4033

  • src/SynTree/BasicType.cc

    r7821d6c re1ff775  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // BasicType.cc --
     7// BasicType.cc -- 
    88//
    99// Author           : Richard C. Bilson
    … …  
    2424BasicType::BasicType( const Type::Qualifiers &tq, Kind bt, const std::list< Attribute * > & attributes ) : Type( tq, attributes ), kind( bt ) {}
    2525
    26 void BasicType::print( std::ostream &os, Indenter indent ) const {
     26void BasicType::print( std::ostream &os, int indent ) const {
    2727        Type::print( os, indent );
    2828        os << BasicType::typeNames[ kind ];

  • src/SynTree/CommaExpr.cc

    r7821d6c re1ff775  
    2121#include "Type.h"            // for Type
    2222
    23 CommaExpr::CommaExpr( Expression *arg1, Expression *arg2 )
    24                 : Expression(), arg1( arg1 ), arg2( arg2 ) {
     23CommaExpr::CommaExpr( Expression *arg1, Expression *arg2, Expression *_aname )
     24                : Expression( _aname ), arg1( arg1 ), arg2( arg2 ) {
    2525        // xxx - result of a comma expression is never an lvalue, so should set lvalue
    2626        // to false on all result types. Actually doing this causes some strange things
    … …  
    3939}
    4040
    41 void CommaExpr::print( std::ostream &os, Indenter indent ) const {
     41void CommaExpr::print( std::ostream &os, int indent ) const {
    4242        os << "Comma Expression:" << std::endl;
    43         os << (indent+1);
    44         arg1->print( os, indent+1 );
     43        os << std::string( indent+2, ' ' );
     44        arg1->print( os, indent+2 );
    4545        os << std::endl;
    46         os << (indent+1);
    47         arg2->print( os, indent+1 );
     46        os << std::string( indent+2, ' ' );
     47        arg2->print( os, indent+2 );
    4848        Expression::print( os, indent );
    4949}

  • src/SynTree/CompoundStmt.cc

    r7821d6c re1ff775  
    7373}
    7474
    75 void CompoundStmt::print( std::ostream &os, Indenter indent ) const {
    76         os << "CompoundStmt" << endl;
    77         printAll( kids, os, indent+1 );
     75void CompoundStmt::print( std::ostream &os, int indent ) const {
     76        os << "CompoundStmt" << endl ;
     77        printAll( kids, os, indent + 2 );
    7878}
    7979

  • src/SynTree/DeclStmt.cc

    r7821d6c re1ff775  
    3333}
    3434
    35 void DeclStmt::print( std::ostream &os, Indenter indent ) const {
     35void DeclStmt::print( std::ostream &os, int indent ) const {
    3636        assert( decl != 0 );
    3737        os << "Declaration of ";

  • src/SynTree/Declaration.cc

    r7821d6c re1ff775  
    7070}
    7171
    72 void AsmDecl::print( std::ostream &os, Indenter indent ) const {
     72void AsmDecl::print( std::ostream &os, int indent ) const {
    7373        stmt->print( os, indent );
    7474}
    7575
    76 void AsmDecl::printShort( std::ostream &os, Indenter indent ) const {
     76void AsmDecl::printShort( std::ostream &os, int indent ) const {
    7777        stmt->print( os, indent );
    7878}

  • src/SynTree/Declaration.h

    r7821d6c re1ff775  
    6464        virtual void accept( Visitor &v ) override = 0;
    6565        virtual Declaration *acceptMutator( Mutator &m ) override = 0;
    66         virtual void print( std::ostream &os, Indenter indent = {} ) const override = 0;
    67         virtual void printShort( std::ostream &os, Indenter indent = {} ) const = 0;
     66        virtual void print( std::ostream &os, int indent = 0 ) const override = 0;
     67        virtual void printShort( std::ostream &os, int indent = 0 ) const = 0;
    6868
    6969        static void dumpIds( std::ostream &os );
    … …  
    142142        virtual void accept( Visitor &v ) override { v.visit( this ); }
    143143        virtual DeclarationWithType *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    144         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
    145         virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
     144        virtual void print( std::ostream &os, int indent = 0 ) const override;
     145        virtual void printShort( std::ostream &os, int indent = 0 ) const override;
    146146};
    147147
    … …  
    170170        virtual void accept( Visitor &v ) override { v.visit( this ); }
    171171        virtual DeclarationWithType *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    172         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
    173         virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
     172        virtual void print( std::ostream &os, int indent = 0 ) const override;
     173        virtual void printShort( std::ostream &os, int indent = 0 ) const override;
    174174};
    175175
    … …  
    193193
    194194        virtual NamedTypeDecl *clone() const override = 0;
    195         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
    196         virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
     195        virtual void print( std::ostream &os, int indent = 0 ) const override;
     196        virtual void printShort( std::ostream &os, int indent = 0 ) const override;
    197197};
    198198
    … …  
    235235        virtual void accept( Visitor &v ) override { v.visit( this ); }
    236236        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    237         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     237        virtual void print( std::ostream &os, int indent = 0 ) const override;
    238238
    239239  private:
    … …  
    276276        AggregateDecl * set_body( bool body ) { AggregateDecl::body = body; return this; }
    277277
    278         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
    279         virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
     278        virtual void print( std::ostream &os, int indent = 0 ) const override;
     279        virtual void printShort( std::ostream &os, int indent = 0 ) const override;
    280280  protected:
    281281        virtual std::string typeString() const = 0;
    … …  
    355355        virtual void accept( Visitor &v ) override { v.visit( this ); }
    356356        virtual AsmDecl *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    357         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
    358         virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
     357        virtual void print( std::ostream &os, int indent = 0 ) const override;
     358        virtual void printShort( std::ostream &os, int indent = 0 ) const override;
    359359};
    360360

  • src/SynTree/Expression.cc

    r7821d6c re1ff775  
    3333#include "GenPoly/Lvalue.h"
    3434
    35 Expression::Expression() : result( 0 ), env( 0 ) {}
    36 
    37 Expression::Expression( const Expression &other ) : BaseSyntaxNode( other ), result( maybeClone( other.result ) ), env( maybeClone( other.env ) ), extension( other.extension ) {
     35Expression::Expression( Expression *_aname ) : result( 0 ), env( 0 ), argName( _aname ) {}
     36
     37Expression::Expression( const Expression &other ) : BaseSyntaxNode( other ), result( maybeClone( other.result ) ), env( maybeClone( other.env ) ), argName( maybeClone( other.get_argName() ) ), extension( other.extension ) {
    3838}
    3939
    4040Expression::~Expression() {
    4141        delete env;
     42        delete argName; // xxx -- there's a problem in cloning ConstantExpr I still don't know how to fix
    4243        delete result;
    4344}
    4445
    45 void Expression::print( std::ostream &os, Indenter indent ) const {
     46void Expression::print( std::ostream &os, int indent ) const {
    4647        if ( env ) {
    47                 os << std::endl << indent << "... with environment:" << std::endl;
    48                 env->print( os, indent+1 );
     48                os << std::string( indent, ' ' ) << "with environment:" << std::endl;
     49                env->print( os, indent+2 );
    4950        } // if
    5051
     52        if ( argName ) {
     53                os << std::string( indent, ' ' ) << "with designator:";
     54                argName->print( os, indent+2 );
     55        } // if
     56
    5157        if ( extension ) {
    52                 os << std::endl << indent << "... with extension:";
     58                os << std::string( indent, ' ' ) << "with extension:";
    5359        } // if
    5460}
    5561
    56 ConstantExpr::ConstantExpr( Constant _c ) : Expression(), constant( _c ) {
     62ConstantExpr::ConstantExpr( Constant _c, Expression *_aname ) : Expression( _aname ), constant( _c ) {
    5763        set_result( constant.get_type()->clone() );
    5864}
    … …  
    6369ConstantExpr::~ConstantExpr() {}
    6470
    65 void ConstantExpr::print( std::ostream &os, Indenter indent ) const {
     71void ConstantExpr::print( std::ostream &os, int indent ) const {
    6672        os << "constant expression " ;
    6773        constant.print( os );
    … …  
    6975}
    7076
    71 VariableExpr::VariableExpr( DeclarationWithType *_var ) : Expression(), var( _var ) {
     77VariableExpr::VariableExpr( DeclarationWithType *_var, Expression *_aname ) : Expression( _aname ), var( _var ) {
    7278        assert( var );
    7379        assert( var->get_type() );
    … …  
    9096}
    9197
    92 void VariableExpr::print( std::ostream &os, Indenter indent ) const {
     98void VariableExpr::print( std::ostream &os, int indent ) const {
    9399        os << "Variable Expression: ";
    94         var->printShort(os, indent);
    95         Expression::print( os, indent );
    96 }
    97 
    98 SizeofExpr::SizeofExpr( Expression *expr_ ) :
    99                 Expression(), expr(expr_), type(0), isType(false) {
     100
     101        Declaration *decl = get_var();
     102        if ( decl != 0) decl->printShort(os, indent + 2);
     103        os << std::endl;
     104        Expression::print( os, indent );
     105}
     106
     107SizeofExpr::SizeofExpr( Expression *expr_, Expression *_aname ) :
     108                Expression( _aname ), expr(expr_), type(0), isType(false) {
    100109        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
    101110}
    102111
    103 SizeofExpr::SizeofExpr( Type *type_ ) :
    104                 Expression(), expr(0), type(type_), isType(true) {
     112SizeofExpr::SizeofExpr( Type *type_, Expression *_aname ) :
     113                Expression( _aname ), expr(0), type(type_), isType(true) {
    105114        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
    106115}
    … …  
    115124}
    116125
    117 void SizeofExpr::print( std::ostream &os, Indenter indent) const {
     126void SizeofExpr::print( std::ostream &os, int indent) const {
    118127        os << "Sizeof Expression on: ";
    119         if (isType) type->print(os, indent+1);
    120         else expr->print(os, indent+1);
    121         Expression::print( os, indent );
    122 }
    123 
    124 AlignofExpr::AlignofExpr( Expression *expr_ ) :
    125                 Expression(), expr(expr_), type(0), isType(false) {
     128
     129        if (isType)
     130                type->print(os, indent + 2);
     131        else
     132                expr->print(os, indent + 2);
     133
     134        os << std::endl;
     135        Expression::print( os, indent );
     136}
     137
     138AlignofExpr::AlignofExpr( Expression *expr_, Expression *_aname ) :
     139                Expression( _aname ), expr(expr_), type(0), isType(false) {
    126140        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
    127141}
    128142
    129 AlignofExpr::AlignofExpr( Type *type_ ) :
    130                 Expression(), expr(0), type(type_), isType(true) {
     143AlignofExpr::AlignofExpr( Type *type_, Expression *_aname ) :
     144                Expression( _aname ), expr(0), type(type_), isType(true) {
    131145        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
    132146}
    … …  
    141155}
    142156
    143 void AlignofExpr::print( std::ostream &os, Indenter indent) const {
     157void AlignofExpr::print( std::ostream &os, int indent) const {
    144158        os << "Alignof Expression on: ";
    145         if (isType) type->print(os, indent+1);
    146         else expr->print(os, indent+1);
    147         Expression::print( os, indent );
    148 }
    149 
    150 UntypedOffsetofExpr::UntypedOffsetofExpr( Type *type, const std::string &member ) :
    151                 Expression(), type(type), member(member) {
    152         assert( type );
     159
     160        if (isType)
     161                type->print(os, indent + 2);
     162        else
     163                expr->print(os, indent + 2);
     164
     165        os << std::endl;
     166        Expression::print( os, indent );
     167}
     168
     169UntypedOffsetofExpr::UntypedOffsetofExpr( Type *type_, const std::string &member_, Expression *_aname ) :
     170                Expression( _aname ), type(type_), member(member_) {
    153171        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
    154172}
    … …  
    161179}
    162180
    163 void UntypedOffsetofExpr::print( std::ostream &os, Indenter indent) const {
    164         os << "Untyped Offsetof Expression on member " << member << " of ";
    165         type->print(os, indent+1);
    166         Expression::print( os, indent );
    167 }
    168 
    169 OffsetofExpr::OffsetofExpr( Type *type, DeclarationWithType *member ) :
    170                 Expression(), type(type), member(member) {
    171         assert( member );
    172         assert( type );
     181void UntypedOffsetofExpr::print( std::ostream &os, int indent) const {
     182        os << std::string( indent, ' ' ) << "Untyped Offsetof Expression on member " << member << " of ";
     183
     184        if ( type ) {
     185                type->print(os, indent + 2);
     186        } else {
     187                os << "<NULL>";
     188        }
     189
     190        os << std::endl;
     191        Expression::print( os, indent );
     192}
     193
     194OffsetofExpr::OffsetofExpr( Type *type_, DeclarationWithType *member_, Expression *_aname ) :
     195                Expression( _aname ), type(type_), member(member_) {
    173196        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
    174197}
    … …  
    181204}
    182205
    183 void OffsetofExpr::print( std::ostream &os, Indenter indent) const {
    184         os << "Offsetof Expression on member " << member->name << " of ";
    185         type->print(os, indent+1);
    186         Expression::print( os, indent );
    187 }
    188 
    189 OffsetPackExpr::OffsetPackExpr( StructInstType *type ) : Expression(), type( type ) {
    190         assert( type );
     206void OffsetofExpr::print( std::ostream &os, int indent) const {
     207        os << std::string( indent, ' ' ) << "Offsetof Expression on member ";
     208
     209        if ( member ) {
     210                os << member->get_name();
     211        } else {
     212                os << "<NULL>";
     213        }
     214
     215        os << " of ";
     216
     217        if ( type ) {
     218                type->print(os, indent + 2);
     219        } else {
     220                os << "<NULL>";
     221        }
     222
     223        os << std::endl;
     224        Expression::print( os, indent );
     225}
     226
     227OffsetPackExpr::OffsetPackExpr( StructInstType *type_, Expression *aname_ ) : Expression( aname_ ), type( type_ ) {
    191228        set_result( new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0, false, false ) );
    192229}
    … …  
    196233OffsetPackExpr::~OffsetPackExpr() { delete type; }
    197234
    198 void OffsetPackExpr::print( std::ostream &os, Indenter indent ) const {
    199         os << "Offset pack expression on ";
    200         type->print(os, indent+1);
    201         Expression::print( os, indent );
    202 }
    203 
    204 AttrExpr::AttrExpr( Expression *attr, Expression *expr_ ) :
    205                 Expression(), attr( attr ), expr(expr_), type(0), isType(false) {
    206 }
    207 
    208 AttrExpr::AttrExpr( Expression *attr, Type *type_ ) :
    209                 Expression(), attr( attr ), expr(0), type(type_), isType(true) {
     235void OffsetPackExpr::print( std::ostream &os, int indent ) const {
     236        os << std::string( indent, ' ' ) << "Offset pack expression on ";
     237
     238        if ( type ) {
     239                type->print(os, indent + 2);
     240        } else {
     241                os << "<NULL>";
     242        }
     243
     244        os << std::endl;
     245        Expression::print( os, indent );
     246}
     247
     248AttrExpr::AttrExpr( Expression *attr, Expression *expr_, Expression *_aname ) :
     249                Expression( _aname ), attr( attr ), expr(expr_), type(0), isType(false) {
     250}
     251
     252AttrExpr::AttrExpr( Expression *attr, Type *type_, Expression *_aname ) :
     253                Expression( _aname ), attr( attr ), expr(0), type(type_), isType(true) {
    210254}
    211255
    … …  
    220264}
    221265
    222 void AttrExpr::print( std::ostream &os, Indenter indent) const {
     266void AttrExpr::print( std::ostream &os, int indent) const {
    223267        os << "Attr ";
    224         attr->print( os, indent+1);
     268        attr->print( os, indent + 2 );
    225269        if ( isType || expr ) {
    226270                os << "applied to: ";
    227                 if (isType) type->print(os, indent+1);
    228                 else expr->print(os, indent+1);
     271
     272                if (isType)
     273                        type->print(os, indent + 2);
     274                else
     275                        expr->print(os, indent + 2);
    229276        } // if
    230         Expression::print( os, indent );
    231 }
    232 
    233 CastExpr::CastExpr( Expression *arg_, Type *toType ) : Expression(), arg(arg_) {
     277
     278        os << std::endl;
     279        Expression::print( os, indent );
     280}
     281
     282CastExpr::CastExpr( Expression *arg_, Type *toType, Expression *_aname ) : Expression( _aname ), arg(arg_) {
    234283        set_result(toType);
    235284}
    236285
    237 CastExpr::CastExpr( Expression *arg_ ) : Expression(), arg(arg_) {
     286CastExpr::CastExpr( Expression *arg_, Expression *_aname ) : Expression( _aname ), arg(arg_) {
    238287        set_result( new VoidType( Type::Qualifiers() ) );
    239288}
    … …  
    246295}
    247296
    248 void CastExpr::print( std::ostream &os, Indenter indent ) const {
    249         os << "Cast of:" << std::endl << indent+1;
    250         arg->print(os, indent+1);
    251         os << std::endl << indent << "... to:";
     297void CastExpr::print( std::ostream &os, int indent ) const {
     298        os << "Cast of:" << std::endl << std::string( indent+2, ' ' );
     299        arg->print(os, indent+2);
     300        os << std::endl << std::string( indent, ' ' ) << "to:" << std::endl;
     301        os << std::string( indent+2, ' ' );
    252302        if ( result->isVoid() ) {
    253                 os << " nothing";
     303                os << "nothing";
    254304        } else {
    255                 os << std::endl << indent+1;
    256                 result->print( os, indent+1 );
     305                result->print( os, indent+2 );
    257306        } // if
     307        os << std::endl;
    258308        Expression::print( os, indent );
    259309}
    … …  
    270320}
    271321
    272 void VirtualCastExpr::print( std::ostream &os, Indenter indent ) const {
    273         os << "Virtual Cast of:" << std::endl << indent+1;
    274         arg->print(os, indent+1);
    275         os << std::endl << indent << "... to:";
     322void VirtualCastExpr::print( std::ostream &os, int indent ) const {
     323        os << "Virtual Cast of:" << std::endl << std::string( indent+2, ' ' );
     324        arg->print(os, indent+2);
     325        os << std::endl << std::string( indent, ' ' ) << "to:" << std::endl;
     326        os << std::string( indent+2, ' ' );
    276327        if ( ! result ) {
    277                 os << " unknown";
     328                os << "unknown";
    278329        } else {
    279                 os << std::endl << indent+1;
    280                 result->print( os, indent+1 );
     330                result->print( os, indent+2 );
    281331        } // if
    282         Expression::print( os, indent );
    283 }
    284 
    285 UntypedMemberExpr::UntypedMemberExpr( Expression * member, Expression *aggregate ) :
    286                 Expression(), member(member), aggregate(aggregate) {
    287         assert( aggregate );
    288 }
     332        os << std::endl;
     333        Expression::print( os, indent );
     334}
     335
     336UntypedMemberExpr::UntypedMemberExpr( Expression * _member, Expression *_aggregate, Expression *_aname ) :
     337                Expression( _aname ), member(_member), aggregate(_aggregate) {}
    289338
    290339UntypedMemberExpr::UntypedMemberExpr( const UntypedMemberExpr &other ) :
    … …  
    297346}
    298347
    299 void UntypedMemberExpr::print( std::ostream &os, Indenter indent ) const {
    300         os << "Untyped Member Expression, with field: " << std::endl << indent+1;
    301         member->print(os, indent+1 );
    302         os << indent << "... from aggregate: " << std::endl << indent+1;
    303         aggregate->print(os, indent+1);
     348void UntypedMemberExpr::print( std::ostream &os, int indent ) const {
     349        os << "Untyped Member Expression, with field: " << std::endl;
     350        os << std::string( indent+2, ' ' );
     351        get_member()->print(os, indent+4);
     352        os << std::string( indent+2, ' ' );
     353
     354        Expression *agg = get_aggregate();
     355        os << "from aggregate: " << std::endl;
     356        if (agg != 0) {
     357                os << std::string( indent + 4, ' ' );
     358                agg->print(os, indent + 4);
     359        }
     360        os << std::string( indent+2, ' ' );
    304361        Expression::print( os, indent );
    305362}
    … …  
    320377
    321378
    322 MemberExpr::MemberExpr( DeclarationWithType *member, Expression *aggregate ) :
    323                 Expression(), member(member), aggregate(aggregate) {
    324         assert( member );
    325         assert( aggregate );
     379MemberExpr::MemberExpr( DeclarationWithType *_member, Expression *_aggregate, Expression *_aname ) :
     380                Expression( _aname ), member(_member), aggregate(_aggregate) {
    326381
    327382        TypeSubstitution sub( makeSub( aggregate->get_result() ) );
    … …  
    341396}
    342397
    343 void MemberExpr::print( std::ostream &os, Indenter indent ) const {
     398void MemberExpr::print( std::ostream &os, int indent ) const {
    344399        os << "Member Expression, with field: " << std::endl;
    345         os << indent+1;
    346         member->print( os, indent+1 );
    347         os << std::endl << indent << "... from aggregate: " << std::endl << indent+1;
    348         aggregate->print(os, indent + 1);
    349         Expression::print( os, indent );
    350 }
    351 
    352 UntypedExpr::UntypedExpr( Expression *function, const std::list<Expression *> &args ) :
    353                 Expression(), function(function), args(args) {}
     400
     401        assert( member );
     402        os << std::string( indent + 2, ' ' );
     403        member->print( os, indent + 2 );
     404        os << std::endl;
     405
     406        Expression *agg = get_aggregate();
     407        os << std::string( indent, ' ' ) << "from aggregate: " << std::endl;
     408        if (agg != 0) {
     409                os << std::string( indent + 2, ' ' );
     410                agg->print(os, indent + 2);
     411        }
     412        os << std::string( indent+2, ' ' );
     413        Expression::print( os, indent );
     414}
     415
     416UntypedExpr::UntypedExpr( Expression *_function, const std::list<Expression *> &_args, Expression *_aname ) :
     417                Expression( _aname ), function(_function), args(_args) {}
    354418
    355419UntypedExpr::UntypedExpr( const UntypedExpr &other ) :
    … …  
    392456
    393457
    394 void UntypedExpr::print( std::ostream &os, Indenter indent ) const {
     458void UntypedExpr::print( std::ostream &os, int indent ) const {
    395459        os << "Applying untyped: " << std::endl;
    396         os << indent+1;
    397         function->print(os, indent+1);
    398         os << std::endl << indent << "...to: " << std::endl;
    399         printAll(args, os, indent+1);
    400         Expression::print( os, indent );
    401 }
    402 
    403 NameExpr::NameExpr( std::string name ) : Expression(), name(name) {
    404         assertf(name != "0", "Zero is not a valid name");
    405         assertf(name != "1", "One is not a valid name");
     460        os << std::string( indent+2, ' ' );
     461        function->print(os, indent + 2);
     462        os << std::string( indent, ' ' ) << "...to: " << std::endl;
     463        printAll(args, os, indent + 2);
     464        Expression::print( os, indent );
     465}
     466
     467void UntypedExpr::printArgs( std::ostream &os, int indent ) const {
     468        std::list<Expression *>::const_iterator i;
     469        for (i = args.begin(); i != args.end(); i++) {
     470                os << std::string(indent, ' ' );
     471                (*i)->print(os, indent);
     472        }
     473}
     474
     475NameExpr::NameExpr( std::string _name, Expression *_aname ) : Expression( _aname ), name(_name) {
     476        assertf(_name != "0", "Zero is not a valid name\n");
     477        assertf(_name != "1", "One is not a valid name\n");
    406478}
    407479
    … …  
    411483NameExpr::~NameExpr() {}
    412484
    413 void NameExpr::print( std::ostream &os, Indenter indent ) const {
    414         os << "Name: " << get_name();
    415         Expression::print( os, indent );
    416 }
    417 
    418 LogicalExpr::LogicalExpr( Expression *arg1_, Expression *arg2_, bool andp ) :
    419                 Expression(), arg1(arg1_), arg2(arg2_), isAnd(andp) {
     485void NameExpr::print( std::ostream &os, int indent ) const {
     486        os << "Name: " << get_name() << std::endl;
     487        Expression::print( os, indent );
     488}
     489
     490LogicalExpr::LogicalExpr( Expression *arg1_, Expression *arg2_, bool andp, Expression *_aname ) :
     491                Expression( _aname ), arg1(arg1_), arg2(arg2_), isAnd(andp) {
    420492        set_result( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
    421493}
    … …  
    430502}
    431503
    432 void LogicalExpr::print( std::ostream &os, Indenter indent )const {
    433         os << "Short-circuited operation (" << (isAnd ? "and" : "or") << ") on: ";
     504void LogicalExpr::print( std::ostream &os, int indent )const {
     505        os << "Short-circuited operation (" << (isAnd?"and":"or") << ") on: ";
    434506        arg1->print(os);
    435507        os << " and ";
    436508        arg2->print(os);
    437         Expression::print( os, indent );
    438 }
    439 
    440 ConditionalExpr::ConditionalExpr( Expression * arg1, Expression * arg2, Expression * arg3 ) :
    441                 Expression(), arg1(arg1), arg2(arg2), arg3(arg3) {}
     509        os << std::endl;
     510        Expression::print( os, indent );
     511}
     512
     513ConditionalExpr::ConditionalExpr( Expression *arg1_, Expression *arg2_, Expression *arg3_, Expression *_aname ) :
     514                Expression( _aname ), arg1(arg1_), arg2(arg2_), arg3(arg3_) {}
    442515
    443516ConditionalExpr::ConditionalExpr( const ConditionalExpr &other ) :
    … …  
    451524}
    452525
    453 void ConditionalExpr::print( std::ostream &os, Indenter indent ) const {
    454         os << "Conditional expression on: " << std::endl << indent+1;
    455         arg1->print( os, indent+1 );
    456         os << indent << "First alternative:" << std::endl << indent+1;
    457         arg2->print( os, indent+1 );
    458         os << indent << "Second alternative:" << std::endl << indent+1;
    459         arg3->print( os, indent+1 );
     526void ConditionalExpr::print( std::ostream &os, int indent ) const {
     527        os << "Conditional expression on: " << std::endl;
     528        os << std::string( indent+2, ' ' );
     529        arg1->print( os, indent+2 );
     530        os << std::string( indent, ' ' ) << "First alternative:" << std::endl;
     531        os << std::string( indent+2, ' ' );
     532        arg2->print( os, indent+2 );
     533        os << std::string( indent, ' ' ) << "Second alternative:" << std::endl;
     534        os << std::string( indent+2, ' ' );
     535        arg3->print( os, indent+2 );
     536        os << std::endl;
    460537        Expression::print( os, indent );
    461538}
    … …  
    464541
    465542
    466 void AsmExpr::print( std::ostream &os, Indenter indent ) const {
     543void AsmExpr::print( std::ostream &os, int indent ) const {
    467544        os << "Asm Expression: " << std::endl;
    468         if ( inout ) inout->print( os, indent+1 );
    469         if ( constraint ) constraint->print( os, indent+1 );
    470         if ( operand ) operand->print( os, indent+1 );
     545        if ( inout ) inout->print( os, indent + 2 );
     546        if ( constraint ) constraint->print( os, indent + 2 );
     547        if ( operand ) operand->print( os, indent + 2 );
    471548}
    472549
    … …  
    474551ImplicitCopyCtorExpr::ImplicitCopyCtorExpr( ApplicationExpr * callExpr ) : callExpr( callExpr ) {
    475552        assert( callExpr );
    476         assert( callExpr->result );
     553        assert( callExpr->has_result() );
    477554        set_result( callExpr->get_result()->clone() );
    478555}
    … …  
    492569}
    493570
    494 void ImplicitCopyCtorExpr::print( std::ostream &os, Indenter indent ) const {
    495         os <<  "Implicit Copy Constructor Expression: " << std::endl << indent+1;
    496         callExpr->print( os, indent+1 );
    497         os << std::endl << indent << "... with temporaries:" << std::endl;
    498         printAll( tempDecls, os, indent+1 );
    499         os << std::endl << indent << "... with return temporaries:" << std::endl;
    500         printAll( returnDecls, os, indent+1 );
     571void ImplicitCopyCtorExpr::print( std::ostream &os, int indent ) const {
     572        os <<  "Implicit Copy Constructor Expression: " << std::endl;
     573        assert( callExpr );
     574        os << std::string( indent+2, ' ' );
     575        callExpr->print( os, indent + 2 );
     576        os << std::endl << std::string( indent, ' ' ) << "with temporaries:" << std::endl;
     577        printAll(tempDecls, os, indent+2);
     578        os << std::endl << std::string( indent, ' ' ) << "with return temporaries:" << std::endl;
     579        printAll(returnDecls, os, indent+2);
    501580        Expression::print( os, indent );
    502581}
    … …  
    508587        Expression * arg = InitTweak::getCallArg( callExpr, 0 );
    509588        assert( arg );
    510         set_result( maybeClone( arg->result ) );
     589        set_result( maybeClone( arg->get_result() ) );
    511590}
    512591
    … …  
    518597}
    519598
    520 void ConstructorExpr::print( std::ostream &os, Indenter indent ) const {
    521         os <<  "Constructor Expression: " << std::endl << indent+1;
     599void ConstructorExpr::print( std::ostream &os, int indent ) const {
     600        os <<  "Constructor Expression: " << std::endl;
     601        assert( callExpr );
     602        os << std::string( indent+2, ' ' );
    522603        callExpr->print( os, indent + 2 );
    523604        Expression::print( os, indent );
    … …  
    537618}
    538619
    539 void CompoundLiteralExpr::print( std::ostream &os, Indenter indent ) const {
    540         os << "Compound Literal Expression: " << std::endl << indent+1;
    541         result->print( os, indent+1 );
    542         os << indent+1;
    543         initializer->print( os, indent+1 );
     620void CompoundLiteralExpr::print( std::ostream &os, int indent ) const {
     621        os << "Compound Literal Expression: " << std::endl;
     622        os << std::string( indent+2, ' ' );
     623        get_result()->print( os, indent + 2 );
     624        os << std::string( indent+2, ' ' );
     625        initializer->print( os, indent + 2 );
    544626        Expression::print( os, indent );
    545627}
    … …  
    547629RangeExpr::RangeExpr( Expression *low, Expression *high ) : low( low ), high( high ) {}
    548630RangeExpr::RangeExpr( const RangeExpr &other ) : Expression( other ), low( other.low->clone() ), high( other.high->clone() ) {}
    549 void RangeExpr::print( std::ostream &os, Indenter indent ) const {
     631void RangeExpr::print( std::ostream &os, int indent ) const {
    550632        os << "Range Expression: ";
    551633        low->print( os, indent );
    … …  
    577659        deleteAll( returnDecls );
    578660}
    579 void StmtExpr::print( std::ostream &os, Indenter indent ) const {
    580         os << "Statement Expression: " << std::endl << indent+1;
    581         statements->print( os, indent+1 );
     661void StmtExpr::print( std::ostream &os, int indent ) const {
     662        os << "Statement Expression: " << std::endl << std::string( indent, ' ' );
     663        statements->print( os, indent+2 );
    582664        if ( ! returnDecls.empty() ) {
    583                 os << indent+1 << "... with returnDecls: ";
    584                 printAll( returnDecls, os, indent+1 );
     665                os << std::string( indent+2, ' ' ) << "with returnDecls: ";
     666                printAll( returnDecls, os, indent+2 );
    585667        }
    586668        if ( ! dtors.empty() ) {
    587                 os << indent+1 << "... with dtors: ";
    588                 printAll( dtors, os, indent+1 );
     669                os << std::string( indent+2, ' ' ) << "with dtors: ";
     670                printAll( dtors, os, indent+2 );
    589671        }
    590672        Expression::print( os, indent );
    … …  
    608690        delete var;
    609691}
    610 void UniqueExpr::print( std::ostream &os, Indenter indent ) const {
    611         os << "Unique Expression with id:" << id << std::endl << indent+1;
    612         expr->print( os, indent+1 );
    613         if ( object ) {
    614                 os << indent << "... with decl: ";
    615                 get_object()->printShort( os, indent+1 );
     692void UniqueExpr::print( std::ostream &os, int indent ) const {
     693        os << "Unique Expression with id:" << id << std::endl << std::string( indent+2, ' ' );
     694        get_expr()->print( os, indent+2 );
     695        if ( get_object() ) {
     696                os << std::string( indent+2, ' ' ) << "with decl: ";
     697                get_object()->printShort( os, indent+2 );
    616698        }
    617699        Expression::print( os, indent );
    … …  
    631713}
    632714
    633 void UntypedInitExpr::print( std::ostream & os, Indenter indent ) const {
    634         os << "Untyped Init Expression" << std::endl << indent+1;
    635         expr->print( os, indent+1 );
     715void UntypedInitExpr::print( std::ostream & os, int indent ) const {
     716        os << "Untyped Init Expression" << std::endl << std::string( indent+2, ' ' );
     717        expr->print( os, indent+2 );
    636718        if ( ! initAlts.empty() ) {
    637719                for ( const InitAlternative & alt : initAlts ) {
    638                         os << indent+1 <<  "InitAlternative: ";
    639                         alt.type->print( os, indent+1 );
    640                         alt.designation->print( os, indent+1 );
     720                        os << std::string( indent+2, ' ' ) <<  "InitAlternative: ";
     721                        alt.type->print( os, indent+2 );
     722                        alt.designation->print( os, indent+2 );
    641723                }
    642724        }
    … …  
    652734}
    653735
    654 void InitExpr::print( std::ostream & os, Indenter indent ) const {
    655         os << "Init Expression" << std::endl << indent+1;
    656         expr->print( os, indent+1 );
    657         os << indent+1 << "... with designation: ";
    658         designation->print( os, indent+1 );
     736void InitExpr::print( std::ostream & os, int indent ) const {
     737        os << "Init Expression" << std::endl << std::string( indent+2, ' ' );
     738        expr->print( os, indent+2 );
     739        os << std::string( indent+2, ' ' ) << "with designation: ";
     740        designation->print( os, indent+2 );
    659741}
    660742

  • src/SynTree/Expression.h

    r7821d6c re1ff775  
    3636        Type * result;
    3737        TypeSubstitution * env;
     38        Expression * argName; // if expression is used as an argument, it can be "designated" by this name
    3839        bool extension = false;
    3940
    40         Expression();
     41        Expression( Expression * _aname = nullptr );
    4142        Expression( const Expression & other );
    4243        virtual ~Expression();
    … …  
    4546        const Type * get_result() const { return result; }
    4647        void set_result( Type * newValue ) { result = newValue; }
     48        bool has_result() const { return result != nullptr; }
    4749
    4850        TypeSubstitution * get_env() const { return env; }
    4951        void set_env( TypeSubstitution * newValue ) { env = newValue; }
     52        Expression * get_argName() const { return argName; }
     53        void set_argName( Expression * name ) { argName = name; }
    5054        bool get_extension() const { return extension; }
    5155        Expression * set_extension( bool exten ) { extension = exten; return this; }
    … …  
    5458        virtual void accept( Visitor & v ) override = 0;
    5559        virtual Expression * acceptMutator( Mutator & m ) override = 0;
    56         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     60        virtual void print( std::ostream & os, int indent = 0 ) const override;
    5761};
    5862
    … …  
    97101        virtual void accept( Visitor & v ) { v.visit( this ); }
    98102        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    99         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     103        virtual void print( std::ostream & os, int indent = 0 ) const;
    100104};
    101105
    … …  
    108112        std::list<Expression*> args;
    109113
    110         UntypedExpr( Expression * function, const std::list<Expression *> & args = std::list< Expression * >() );
     114        UntypedExpr( Expression * function, const std::list<Expression *> & args = std::list< Expression * >(), Expression *_aname = nullptr );
    111115        UntypedExpr( const UntypedExpr & other );
    112116        virtual ~UntypedExpr();
    … …  
    115119        void set_function( Expression * newValue ) { function = newValue; }
    116120
     121        void set_args( std::list<Expression *> & listArgs ) { args = listArgs; }
    117122        std::list<Expression*>::iterator begin_args() { return args.begin(); }
    118123        std::list<Expression*>::iterator end_args() { return args.end(); }
    … …  
    125130        virtual void accept( Visitor & v ) { v.visit( this ); }
    126131        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    127         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     132        virtual void print( std::ostream & os, int indent = 0 ) const;
     133        virtual void printArgs(std::ostream & os, int indent = 0) const;
    128134};
    129135
    … …  
    133139        std::string name;
    134140
    135         NameExpr( std::string name );
     141        NameExpr( std::string name, Expression *_aname = nullptr );
    136142        NameExpr( const NameExpr & other );
    137143        virtual ~NameExpr();
    … …  
    143149        virtual void accept( Visitor & v ) { v.visit( this ); }
    144150        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    145         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     151        virtual void print( std::ostream & os, int indent = 0 ) const;
    146152};
    147153
    … …  
    154160        Expression * arg;
    155161
    156         AddressExpr( Expression * arg );
     162        AddressExpr( Expression * arg, Expression *_aname = nullptr );
    157163        AddressExpr( const AddressExpr & other );
    158164        virtual ~AddressExpr();
    … …  
    164170        virtual void accept( Visitor & v ) { v.visit( this ); }
    165171        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    166         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     172        virtual void print( std::ostream & os, int indent = 0 ) const;
    167173};
    168174
    … …  
    180186        virtual void accept( Visitor & v ) { v.visit( this ); }
    181187        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    182         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     188        virtual void print( std::ostream & os, int indent = 0 ) const;
    183189};
    184190
    … …  
    188194        Expression * arg;
    189195
    190         CastExpr( Expression * arg );
    191         CastExpr( Expression * arg, Type * toType );
     196        CastExpr( Expression * arg, Expression *_aname = nullptr );
     197        CastExpr( Expression * arg, Type * toType, Expression *_aname = nullptr );
    192198        CastExpr( const CastExpr & other );
    193199        virtual ~CastExpr();
    … …  
    199205        virtual void accept( Visitor & v ) { v.visit( this ); }
    200206        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    201         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     207        virtual void print( std::ostream & os, int indent = 0 ) const;
    202208};
    203209
    … …  
    217223        virtual void accept( Visitor & v ) { v.visit( this ); }
    218224        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    219         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     225        virtual void print( std::ostream & os, int indent = 0 ) const;
    220226};
    221227
    … …  
    226232        Expression * aggregate;
    227233
    228         UntypedMemberExpr( Expression * member, Expression * aggregate );
     234        UntypedMemberExpr( Expression * member, Expression * aggregate, Expression *_aname = nullptr );
    229235        UntypedMemberExpr( const UntypedMemberExpr & other );
    230236        virtual ~UntypedMemberExpr();
    … …  
    238244        virtual void accept( Visitor & v ) { v.visit( this ); }
    239245        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    240         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     246        virtual void print( std::ostream & os, int indent = 0 ) const;
    241247};
    242248
    … …  
    248254        Expression * aggregate;
    249255
    250         MemberExpr( DeclarationWithType * member, Expression * aggregate );
     256        MemberExpr( DeclarationWithType * member, Expression * aggregate, Expression *_aname = nullptr );
    251257        MemberExpr( const MemberExpr & other );
    252258        virtual ~MemberExpr();
    … …  
    260266        virtual void accept( Visitor & v ) { v.visit( this ); }
    261267        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    262         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     268        virtual void print( std::ostream & os, int indent = 0 ) const;
    263269};
    264270
    … …  
    269275        DeclarationWithType * var;
    270276
    271         VariableExpr( DeclarationWithType * var );
     277        VariableExpr( DeclarationWithType * var, Expression *_aname = nullptr );
    272278        VariableExpr( const VariableExpr & other );
    273279        virtual ~VariableExpr();
    … …  
    281287        virtual void accept( Visitor & v ) { v.visit( this ); }
    282288        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    283         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     289        virtual void print( std::ostream & os, int indent = 0 ) const;
    284290};
    285291
    … …  
    289295        Constant constant;
    290296
    291         ConstantExpr( Constant constant );
     297        ConstantExpr( Constant constant, Expression *_aname = nullptr );
    292298        ConstantExpr( const ConstantExpr & other );
    293299        virtual ~ConstantExpr();
    … …  
    299305        virtual void accept( Visitor & v ) { v.visit( this ); }
    300306        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    301         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     307        virtual void print( std::ostream & os, int indent = 0 ) const;
    302308};
    303309
    … …  
    309315        bool isType;
    310316
    311         SizeofExpr( Expression * expr );
     317        SizeofExpr( Expression * expr, Expression *_aname = nullptr );
    312318        SizeofExpr( const SizeofExpr & other );
    313         SizeofExpr( Type * type );
     319        SizeofExpr( Type * type, Expression *_aname = nullptr );
    314320        virtual ~SizeofExpr();
    315321
    … …  
    324330        virtual void accept( Visitor & v ) { v.visit( this ); }
    325331        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    326         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     332        virtual void print( std::ostream & os, int indent = 0 ) const;
    327333};
    328334
    … …  
    334340        bool isType;
    335341
    336         AlignofExpr( Expression * expr );
     342        AlignofExpr( Expression * expr, Expression *_aname = nullptr );
    337343        AlignofExpr( const AlignofExpr & other );
    338         AlignofExpr( Type * type );
     344        AlignofExpr( Type * type, Expression *_aname = nullptr );
    339345        virtual ~AlignofExpr();
    340346
    … …  
    349355        virtual void accept( Visitor & v ) { v.visit( this ); }
    350356        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    351         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     357        virtual void print( std::ostream & os, int indent = 0 ) const;
    352358};
    353359
    … …  
    358364        std::string member;
    359365
    360         UntypedOffsetofExpr( Type * type, const std::string & member );
     366        UntypedOffsetofExpr( Type * type, const std::string & member, Expression *_aname = nullptr );
    361367        UntypedOffsetofExpr( const UntypedOffsetofExpr & other );
    362368        virtual ~UntypedOffsetofExpr();
    … …  
    370376        virtual void accept( Visitor & v ) { v.visit( this ); }
    371377        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    372         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     378        virtual void print( std::ostream & os, int indent = 0 ) const;
    373379};
    374380
    … …  
    379385        DeclarationWithType * member;
    380386
    381         OffsetofExpr( Type * type, DeclarationWithType * member );
     387        OffsetofExpr( Type * type, DeclarationWithType * member, Expression *_aname = nullptr );
    382388        OffsetofExpr( const OffsetofExpr & other );
    383389        virtual ~OffsetofExpr();
    … …  
    391397        virtual void accept( Visitor & v ) { v.visit( this ); }
    392398        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    393         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     399        virtual void print( std::ostream & os, int indent = 0 ) const;
    394400};
    395401
    … …  
    399405        StructInstType * type;
    400406
    401         OffsetPackExpr( StructInstType * type );
     407        OffsetPackExpr( StructInstType * type_, Expression * aname_ = 0 );
    402408        OffsetPackExpr( const OffsetPackExpr & other );
    403409        virtual ~OffsetPackExpr();
    … …  
    409415        virtual void accept( Visitor & v ) { v.visit( this ); }
    410416        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    411         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     417        virtual void print( std::ostream & os, int indent = 0 ) const;
    412418};
    413419
    … …  
    420426        bool isType;
    421427
    422         AttrExpr(Expression * attr, Expression * expr );
     428        AttrExpr(Expression * attr, Expression * expr, Expression *_aname = nullptr );
    423429        AttrExpr( const AttrExpr & other );
    424         AttrExpr( Expression * attr, Type * type );
     430        AttrExpr( Expression * attr, Type * type, Expression *_aname = nullptr );
    425431        virtual ~AttrExpr();
    426432
    … …  
    437443        virtual void accept( Visitor & v ) { v.visit( this ); }
    438444        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    439         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     445        virtual void print( std::ostream & os, int indent = 0 ) const;
    440446};
    441447
    … …  
    446452        Expression * arg2;
    447453
    448         LogicalExpr( Expression * arg1, Expression * arg2, bool andp = true );
     454        LogicalExpr( Expression * arg1, Expression * arg2, bool andp = true, Expression *_aname = nullptr );
    449455        LogicalExpr( const LogicalExpr & other );
    450456        virtual ~LogicalExpr();
    … …  
    459465        virtual void accept( Visitor & v ) { v.visit( this ); }
    460466        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    461         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     467        virtual void print( std::ostream & os, int indent = 0 ) const;
    462468
    463469  private:
    … …  
    472478        Expression * arg3;
    473479
    474         ConditionalExpr( Expression * arg1, Expression * arg2, Expression * arg3 );
     480        ConditionalExpr( Expression * arg1, Expression * arg2, Expression * arg3, Expression *_aname = nullptr );
    475481        ConditionalExpr( const ConditionalExpr & other );
    476482        virtual ~ConditionalExpr();
    … …  
    486492        virtual void accept( Visitor & v ) { v.visit( this ); }
    487493        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    488         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     494        virtual void print( std::ostream & os, int indent = 0 ) const;
    489495};
    490496
    … …  
    495501        Expression * arg2;
    496502
    497         CommaExpr( Expression * arg1, Expression * arg2 );
     503        CommaExpr( Expression * arg1, Expression * arg2, Expression *_aname = nullptr );
    498504        CommaExpr( const CommaExpr & other );
    499505        virtual ~CommaExpr();
    … …  
    507513        virtual void accept( Visitor & v ) { v.visit( this ); }
    508514        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    509         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     515        virtual void print( std::ostream & os, int indent = 0 ) const;
    510516};
    511517
    … …  
    525531        virtual void accept( Visitor & v ) { v.visit( this ); }
    526532        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    527         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     533        virtual void print( std::ostream & os, int indent = 0 ) const;
    528534};
    529535
    … …  
    551557        virtual void accept( Visitor & v ) { v.visit( this ); }
    552558        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    553         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     559        virtual void print( std::ostream & os, int indent = 0 ) const;
    554560
    555561        // https://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/Machine-Constraints.html#Machine-Constraints
    … …  
    579585        virtual void accept( Visitor & v ) { v.visit( this ); }
    580586        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    581         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     587        virtual void print( std::ostream & os, int indent = 0 ) const;
    582588};
    583589
    … …  
    597603        virtual void accept( Visitor & v ) { v.visit( this ); }
    598604        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    599         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     605        virtual void print( std::ostream & os, int indent = 0 ) const;
    600606};
    601607
    … …  
    615621        virtual void accept( Visitor & v ) { v.visit( this ); }
    616622        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    617         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     623        virtual void print( std::ostream & os, int indent = 0 ) const;
    618624};
    619625
    … …  
    634640        virtual void accept( Visitor & v ) { v.visit( this ); }
    635641        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    636         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     642        virtual void print( std::ostream & os, int indent = 0 ) const;
    637643};
    638644
    … …  
    642648        std::list<Expression*> exprs;
    643649
    644         UntypedTupleExpr( const std::list< Expression * > & exprs );
     650        UntypedTupleExpr( const std::list< Expression * > & exprs, Expression *_aname = nullptr );
    645651        UntypedTupleExpr( const UntypedTupleExpr & other );
    646652        virtual ~UntypedTupleExpr();
    … …  
    651657        virtual void accept( Visitor & v ) { v.visit( this ); }
    652658        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    653         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     659        virtual void print( std::ostream & os, int indent = 0 ) const;
    654660};
    655661
    … …  
    659665        std::list<Expression*> exprs;
    660666
    661         TupleExpr( const std::list< Expression * > & exprs );
     667        TupleExpr( const std::list< Expression * > & exprs, Expression *_aname = nullptr );
    662668        TupleExpr( const TupleExpr & other );
    663669        virtual ~TupleExpr();
    … …  
    668674        virtual void accept( Visitor & v ) { v.visit( this ); }
    669675        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    670         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     676        virtual void print( std::ostream & os, int indent = 0 ) const;
    671677};
    672678
    … …  
    689695        virtual void accept( Visitor & v ) { v.visit( this ); }
    690696        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    691         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     697        virtual void print( std::ostream & os, int indent = 0 ) const;
    692698};
    693699
    … …  
    697703        StmtExpr * stmtExpr = nullptr;
    698704
    699         TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls );
     705        TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls, Expression * _aname = nullptr );
    700706        TupleAssignExpr( const TupleAssignExpr & other );
    701707        virtual ~TupleAssignExpr();
    … …  
    707713        virtual void accept( Visitor & v ) { v.visit( this ); }
    708714        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    709         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     715        virtual void print( std::ostream & os, int indent = 0 ) const;
    710716};
    711717
    … …  
    730736        virtual void accept( Visitor & v ) { v.visit( this ); }
    731737        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    732         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     738        virtual void print( std::ostream & os, int indent = 0 ) const;
    733739};
    734740
    … …  
    757763        virtual void accept( Visitor & v ) { v.visit( this ); }
    758764        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    759         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     765        virtual void print( std::ostream & os, int indent = 0 ) const;
    760766
    761767private:
    … …  
    791797        virtual void accept( Visitor & v ) { v.visit( this ); }
    792798        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    793         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     799        virtual void print( std::ostream & os, int indent = 0 ) const;
    794800};
    795801
    … …  
    812818        virtual void accept( Visitor & v ) { v.visit( this ); }
    813819        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    814         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     820        virtual void print( std::ostream & os, int indent = 0 ) const;
    815821};
    816822

  • src/SynTree/FunctionDecl.cc

    r7821d6c re1ff775  
    6363}
    6464
    65 void FunctionDecl::print( std::ostream &os, Indenter indent ) const {
     65void FunctionDecl::print( std::ostream &os, int indent ) const {
    6666        using std::endl;
    6767        using std::string;
    6868
    69         if ( name != "" ) {
    70                 os << name << ": ";
     69        if ( get_name() != "" ) {
     70                os << get_name() << ": ";
    7171        } // if
    72         if ( linkage != LinkageSpec::Cforall ) {
    73                 os << LinkageSpec::linkageName( linkage ) << " ";
     72        if ( get_linkage() != LinkageSpec::Cforall ) {
     73                os << LinkageSpec::linkageName( get_linkage() ) << " ";
    7474        } // if
    7575
    76         printAll( attributes, os, indent );
     76        printAll( get_attributes(), os, indent );
    7777
    7878        get_storageClasses().print( os );
    7979        get_funcSpec().print( os );
    8080
    81         if ( type ) {
    82                 type->print( os, indent );
     81        if ( get_type() ) {
     82                get_type()->print( os, indent );
    8383        } else {
    8484                os << "untyped entity ";
    … …  
    8686
    8787        if ( statements ) {
    88                 os << indent << "... with body " << endl << indent+1;
    89                 statements->print( os, indent+1 );
     88                os << string( indent + 2, ' ' ) << "with body " << endl;
     89                os << string( indent + 4, ' ' );
     90                statements->print( os, indent + 4 );
    9091        } // if
    9192}
    9293
    93 void FunctionDecl::printShort( std::ostream &os, Indenter indent ) const {
     94void FunctionDecl::printShort( std::ostream &os, int indent ) const {
    9495        using std::endl;
    9596        using std::string;
    9697
    97         if ( name != "" ) {
    98                 os << name << ": ";
     98        if ( get_name() != "" ) {
     99                os << get_name() << ": ";
    99100        } // if
     101
     102        // xxx - should printShort print attributes?
    100103
    101104        get_storageClasses().print( os );
    102105        get_funcSpec().print( os );
    103106
    104         if ( type ) {
    105                 type->print( os, indent );
     107        if ( get_type() ) {
     108                get_type()->print( os, indent );
    106109        } else {
    107110                os << "untyped entity ";

  • src/SynTree/FunctionType.cc

    r7821d6c re1ff775  
    5151}
    5252
    53 void FunctionType::print( std::ostream &os, Indenter indent ) const {
     53void FunctionType::print( std::ostream &os, int indent ) const {
    5454        using std::string;
    5555        using std::endl;
    … …  
    5858        os << "function" << endl;
    5959        if ( ! parameters.empty() ) {
    60                 os << indent << "... with parameters" << endl;
    61                 printAll( parameters, os, indent+1 );
     60                os << string( indent + 2, ' ' ) << "with parameters" << endl;
     61                printAll( parameters, os, indent + 4 );
    6262                if ( isVarArgs ) {
    63                         os << indent+1 << "and a variable number of other arguments" << endl;
     63                        os << string( indent + 4, ' ' ) << "and a variable number of other arguments" << endl;
    6464                } // if
    6565        } else if ( isVarArgs ) {
    66                 os << indent+1 << "accepting unspecified arguments" << endl;
     66                os << string( indent + 4, ' ' ) << "accepting unspecified arguments" << endl;
    6767        } // if
    68         os << indent << "... returning ";
     68        os << string( indent + 2, ' ' ) << "returning ";
    6969        if ( returnVals.empty() ) {
    70                 os << "nothing " << endl;
     70                os << endl << string( indent + 4, ' ' ) << "nothing " << endl;
    7171        } else {
    7272                os << endl;
    73                 printAll( returnVals, os, indent+1 );
     73                printAll( returnVals, os, indent + 4 );
    7474        } // if
    7575}

  • src/SynTree/Initializer.cc

    r7821d6c re1ff775  
    3838}
    3939
    40 void Designation::print( std::ostream &os, Indenter indent ) const {
     40void Designation::print( std::ostream &os, int indent ) const {
    4141        if ( ! designators.empty() ) {
    42                 os << "... designated by: " << std::endl;
    43                 for ( const Expression * d : designators ) {
    44                         os << indent+1;
    45                         d->print(os, indent+1 );
    46                         os << std::endl;
     42                os << std::string(indent + 2, ' ' ) << "designated by: " << std::endl;
     43                for ( std::list < Expression * >::const_iterator i = designators.begin(); i != designators.end(); i++ ) {
     44                        os << std::string(indent + 4, ' ' );
     45                        ( *i )->print(os, indent + 4 );
    4746                }
     47                os << std::endl;
    4848        } // if
    4949}
    … …  
    6464}
    6565
    66 void SingleInit::print( std::ostream &os, Indenter indent ) const {
    67         os << "Simple Initializer: ";
    68         value->print( os, indent );
     66void SingleInit::print( std::ostream &os, int indent ) const {
     67        os << std::string(indent, ' ' ) << "Simple Initializer: " << std::endl;
     68        os << std::string(indent+4, ' ' );
     69        value->print( os, indent+4 );
    6970}
    7071
    … …  
    9293}
    9394
    94 void ListInit::print( std::ostream &os, Indenter indent ) const {
    95         os << "Compound initializer: " << std::endl;
    96         for ( auto p : group_iterate( designations, initializers ) ) {
    97                 const Designation * d = std::get<0>(p);
    98                 const Initializer * init = std::get<1>(p);
    99                 os << indent+1;
    100                 init->print( os, indent+1 );
     95void ListInit::print( std::ostream &os, int indent ) const {
     96        os << std::string(indent, ' ') << "Compound initializer:  " << std::endl;
     97        for ( Designation * d : designations ) {
     98                d->print( os, indent + 2 );
     99        }
     100
     101        for ( const Initializer * init : initializers ) {
     102                init->print( os, indent + 2 );
    101103                os << std::endl;
    102                 if ( ! d->designators.empty() ) {
    103                         os << indent+1;
    104                         d->print( os, indent+1 );
    105                 }
    106104        }
    107105}
    … …  
    118116}
    119117
    120 void ConstructorInit::print( std::ostream &os, Indenter indent ) const {
    121         os << "Constructor initializer: " << std::endl;
     118void ConstructorInit::print( std::ostream &os, int indent ) const {
     119        os << std::endl << std::string(indent, ' ') << "Constructor initializer: " << std::endl;
    122120        if ( ctor ) {
    123                 os << indent << "... initially constructed with ";
    124                 ctor->print( os, indent+1 );
     121                os << std::string(indent+2, ' ');
     122                os << "initially constructed with ";
     123                ctor->print( os, indent+4 );
    125124        } // if
    126125
    127126        if ( dtor ) {
    128                 os << indent << "... destructed with ";
    129                 dtor->print( os, indent+1 );
     127                os << std::string(indent+2, ' ');
     128                os << "destructed with ";
     129                dtor->print( os, indent+4 );
    130130        }
    131131
    132132        if ( init ) {
    133                 os << indent << "... with fallback C-style initializer: ";
    134                 init->print( os, indent+1 );
     133                os << std::string(indent+2, ' ');
     134                os << "with fallback C-style initializer: ";
     135                init->print( os, indent+4 );
    135136        }
    136137}

  • src/SynTree/Initializer.h

    r7821d6c re1ff775  
    4040        virtual void accept( Visitor &v ) override { v.visit( this ); }
    4141        virtual Designation * acceptMutator( Mutator &m ) override { return m.mutate( this ); }
    42         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     42        virtual void print( std::ostream &os, int indent = 0 ) const override;
    4343};
    4444
    … …  
    5757        virtual void accept( Visitor &v ) override = 0;
    5858        virtual Initializer *acceptMutator( Mutator &m ) override = 0;
    59         virtual void print( std::ostream &os, Indenter indent = {} ) const override = 0;
     59        virtual void print( std::ostream &os, int indent = 0 ) const override = 0;
    6060  private:
    6161        bool maybeConstructed;
    … …  
    7878        virtual void accept( Visitor &v ) override { v.visit( this ); }
    7979        virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    80         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     80        virtual void print( std::ostream &os, int indent = 0 ) const override;
    8181};
    8282
    … …  
    106106        virtual void accept( Visitor &v ) override { v.visit( this ); }
    107107        virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    108         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     108        virtual void print( std::ostream &os, int indent = 0 ) const override;
    109109};
    110110
    … …  
    135135        virtual void accept( Visitor &v ) override { v.visit( this ); }
    136136        virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    137         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     137        virtual void print( std::ostream &os, int indent = 0 ) const override;
    138138
    139139  private:

  • src/SynTree/NamedTypeDecl.cc

    r7821d6c re1ff775  
    3838}
    3939
    40 void NamedTypeDecl::print( std::ostream &os, Indenter indent ) const {
     40void NamedTypeDecl::print( std::ostream &os, int indent ) const {
    4141        using namespace std;
    4242
    43         if ( name != "" ) os << name << ": ";
    44 
    45         if ( linkage != LinkageSpec::Cforall ) {
    46                 os << LinkageSpec::linkageName( linkage ) << " ";
     43        if ( get_name() != "" ) {
     44                os << get_name() << ": ";
     45        } // if
     46        if ( get_linkage() != LinkageSpec::Cforall ) {
     47                os << LinkageSpec::linkageName( get_linkage() ) << " ";
    4748        } // if
    4849        get_storageClasses().print( os );
    … …  
    5051        if ( base ) {
    5152                os << " for ";
    52                 base->print( os, indent+1 );
     53                base->print( os, indent );
    5354        } // if
    5455        if ( ! parameters.empty() ) {
    55                 os << endl << indent << "... with parameters" << endl;
    56                 printAll( parameters, os, indent+1 );
     56                os << endl << string( indent, ' ' ) << "with parameters" << endl;
     57                printAll( parameters, os, indent+2 );
    5758        } // if
    5859        if ( ! assertions.empty() ) {
    59                 os << endl << indent << "... with assertions" << endl;
    60                 printAll( assertions, os, indent+1 );
     60                os << endl << string( indent, ' ' ) << "with assertions" << endl;
     61                printAll( assertions, os, indent+2 );
    6162        } // if
    6263}
    6364
    64 void NamedTypeDecl::printShort( std::ostream &os, Indenter indent ) const {
     65void NamedTypeDecl::printShort( std::ostream &os, int indent ) const {
    6566        using namespace std;
    6667
    67         if ( name != "" ) os << name << ": ";
     68        if ( get_name() != "" ) {
     69                os << get_name() << ": ";
     70        } // if
    6871        get_storageClasses().print( os );
    6972        os << typeString();
    7073        if ( base ) {
    7174                os << " for ";
    72                 base->print( os, indent+1 );
     75                base->print( os, indent );
    7376        } // if
    7477        if ( ! parameters.empty() ) {
    75                 os << endl << indent << "... with parameters" << endl;
    76                 printAll( parameters, os, indent+1 );
     78                os << endl << string( indent, ' ' ) << "with parameters" << endl;
     79                printAll( parameters, os, indent+2 );
    7780        } // if
    7881}

  • src/SynTree/ObjectDecl.cc

    r7821d6c re1ff775  
    4444}
    4545
    46 void ObjectDecl::print( std::ostream &os, Indenter indent ) const {
    47         if ( name != "" ) os << name << ": ";
     46void ObjectDecl::print( std::ostream &os, int indent ) const {
     47        if ( get_name() != "" ) {
     48                os << get_name() << ": ";
     49        } // if
    4850
    49         if ( linkage != LinkageSpec::Cforall ) {
    50                 os << LinkageSpec::linkageName( linkage ) << " ";
     51        if ( get_linkage() != LinkageSpec::Cforall ) {
     52                os << LinkageSpec::linkageName( get_linkage() ) << " ";
    5153        } // if
     54
     55        printAll( get_attributes(), os, indent );
    5256
    5357        get_storageClasses().print( os );
    5458
    55         if ( type ) {
    56                 type->print( os, indent );
     59        if ( get_type() ) {
     60                get_type()->print( os, indent );
    5761        } else {
    5862                os << " untyped entity ";
    … …  
    6064
    6165        if ( init ) {
    62                 os << " with initializer (" << (init->get_maybeConstructed() ? "maybe constructed" : "not constructed") << ")" << std::endl << indent+1;
    63                 init->print( os, indent+1 );
    64                 os << std::endl;
     66                os << " with initializer " << std::endl;
     67                init->print( os, indent+2 );
     68                os << std::endl << std::string(indent+2, ' ');
     69                os << "maybeConstructed? " << init->get_maybeConstructed();
    6570        } // if
    6671
    67         if ( ! attributes.empty() ) {
    68                 os << std::endl << indent << "... with attributes: " << std::endl;
    69                 printAll( attributes, os, indent+1 );
    70         }
    71 
    7272        if ( bitfieldWidth ) {
    73                 os << indent << " with bitfield width ";
     73                os << std::string(indent, ' ');
     74                os << " with bitfield width ";
    7475                bitfieldWidth->print( os );
    7576        } // if
    7677}
    7778
    78 void ObjectDecl::printShort( std::ostream &os, Indenter indent ) const {
     79void ObjectDecl::printShort( std::ostream &os, int indent ) const {
    7980#if 0
    8081        if ( get_mangleName() != "") {
    … …  
    8283        } else
    8384#endif
    84         if ( name != "" ) os << name << ": ";
     85        if ( get_name() != "" ) {
     86                os << get_name() << ": ";
     87        } // if
     88
     89        // xxx - should printShort print attributes?
    8590
    8691        get_storageClasses().print( os );
    8792
    88         if ( type ) {
    89                 type->print( os, indent );
     93        if ( get_type() ) {
     94                get_type()->print( os, indent );
    9095        } else {
    9196                os << "untyped entity ";

  • src/SynTree/PointerType.cc

    r7821d6c re1ff775  
    4141}
    4242
    43 void PointerType::print( std::ostream &os, Indenter indent ) const {
     43void PointerType::print( std::ostream &os, int indent ) const {
    4444        Type::print( os, indent );
    4545        if ( ! is_array() ) {

  • src/SynTree/ReferenceToType.cc

    r7821d6c re1ff775  
    1414//
    1515
     16#include <stddef.h>          // for NULL
    1617#include <cassert>           // for assert
    1718#include <list>              // for list, _List_const_iterator, list<>::cons...
    … …  
    3738}
    3839
    39 void ReferenceToType::print( std::ostream &os, Indenter indent ) const {
     40void ReferenceToType::print( std::ostream &os, int indent ) const {
    4041        using std::endl;
    4142
    … …  
    4344        os << "instance of " << typeString() << " " << name << " ";
    4445        if ( ! parameters.empty() ) {
    45                 os << endl << indent << "... with parameters" << endl;
    46                 printAll( parameters, os, indent+1 );
     46                os << endl << std::string( indent, ' ' ) << "with parameters" << endl;
     47                printAll( parameters, os, indent+2 );
    4748        } // if
    4849}
    … …  
    6465
    6566std::list<TypeDecl*>* StructInstType::get_baseParameters() {
    66         if ( ! baseStruct ) return nullptr;
     67        if ( ! baseStruct ) return NULL;
    6768        return &baseStruct->get_parameters();
    6869}
    … …  
    7576}
    7677
    77 void StructInstType::print( std::ostream &os, Indenter indent ) const {
     78void StructInstType::print( std::ostream &os, int indent ) const {
    7879        using std::endl;
    7980
    80         if ( baseStruct == nullptr ) ReferenceToType::print( os, indent );
     81        if ( baseStruct == NULL ) ReferenceToType::print( os, indent );
    8182        else {
    8283                Type::print( os, indent );
    8384                os << "instance of " << typeString() << " " << name << " with body " << baseStruct->has_body() << " ";
    8485                if ( ! parameters.empty() ) {
    85                         os << endl << indent << "... with parameters" << endl;
    86                         printAll( parameters, os, indent+1 );
     86                        os << endl << std::string( indent, ' ' ) << "with parameters" << endl;
     87                        printAll( parameters, os, indent+2 );
    8788                } // if
    8889        } // if
    … …  
    9697
    9798std::list< TypeDecl * > * UnionInstType::get_baseParameters() {
    98         if ( ! baseUnion ) return nullptr;
     99        if ( ! baseUnion ) return NULL;
    99100        return &baseUnion->get_parameters();
    100101}
    … …  
    107108}
    108109
    109 void UnionInstType::print( std::ostream &os, Indenter indent ) const {
     110void UnionInstType::print( std::ostream &os, int indent ) const {
    110111        using std::endl;
    111112
    112         if ( baseUnion == nullptr ) ReferenceToType::print( os, indent );
     113        if ( baseUnion == NULL ) ReferenceToType::print( os, indent );
    113114        else {
    114115                Type::print( os, indent );
    115116                os << "instance of " << typeString() << " " << name << " with body " << baseUnion->has_body() << " ";
    116117                if ( ! parameters.empty() ) {
    117                         os << endl << indent << "... with parameters" << endl;
    118                         printAll( parameters, os, indent+1 );
     118                        os << endl << std::string( indent, ' ' ) << "with parameters" << endl;
     119                        printAll( parameters, os, indent+2 );
    119120                } // if
    120121        } // if
    … …  
    165166bool TypeInstType::isComplete() const { return baseType->isComplete(); }
    166167
    167 void TypeInstType::print( std::ostream &os, Indenter indent ) const {
     168void TypeInstType::print( std::ostream &os, int indent ) const {
    168169        using std::endl;
    169170
    … …  
    171172        os << "instance of " << typeString() << " " << get_name() << " (" << ( isFtype ? "" : "not" ) << " function type) ";
    172173        if ( ! parameters.empty() ) {
    173                 os << endl << indent << "... with parameters" << endl;
    174                 printAll( parameters, os, indent+1 );
     174                os << endl << std::string( indent, ' ' ) << "with parameters" << endl;
     175                printAll( parameters, os, indent+2 );
    175176        } // if
    176177}

  • src/SynTree/ReferenceType.cc

    r7821d6c re1ff775  
    3535}
    3636
    37 void ReferenceType::print( std::ostream &os, Indenter indent ) const {
     37void ReferenceType::print( std::ostream &os, int indent ) const {
    3838        Type::print( os, indent );
    3939        os << "reference to ";

  • src/SynTree/Statement.cc

    r7821d6c re1ff775  
    3434Statement::Statement( std::list<Label> labels ) : labels( labels ) {}
    3535
    36 void Statement::print( std::ostream & os, Indenter ) const {
    37         if ( ! labels.empty() ) {
    38                 os << "Labels: {";
    39                 for ( const Label & l : labels ) {
    40                         os << l << ",";
    41                 }
    42                 os << "}" << endl;
    43         }
    44 }
     36void Statement::print( __attribute__((unused)) std::ostream &, __attribute__((unused)) int indent ) const {}
    4537
    4638Statement::~Statement() {}
    … …  
    5446}
    5547
    56 void ExprStmt::print( std::ostream &os, Indenter indent ) const {
    57         os << "Expression Statement:" << endl << indent+1;
    58         expr->print( os, indent+1 );
     48void ExprStmt::print( std::ostream &os, int indent ) const {
     49        os << "Expression Statement:" << endl << std::string( indent + 2, ' ' );
     50        expr->print( os, indent + 2 );
    5951}
    6052
    … …  
    7567}
    7668
    77 void AsmStmt::print( std::ostream &os, Indenter indent ) const {
     69void AsmStmt::print( std::ostream &os, int indent ) const {
    7870        os << "Assembler Statement:" << endl;
    79         os << indent+1 << "instruction: " << endl << indent;
    80         instruction->print( os, indent+1 );
     71        os << std::string( indent, ' ' ) << "instruction: " << endl << std::string( indent, ' ' );
     72        instruction->print( os, indent + 2 );
    8173        if ( ! output.empty() ) {
    82                 os << endl << indent+1 << "output: " << endl;
    83                 printAll( output, os, indent+1 );
     74                os << endl << std::string( indent, ' ' ) << "output: " << endl;
     75                printAll( output, os, indent + 2 );
    8476        } // if
    8577        if ( ! input.empty() ) {
    86                 os << indent+1 << "input: " << endl;
    87                 printAll( input, os, indent+1 );
     78                os << std::string( indent, ' ' ) << "input: " << endl << std::string( indent, ' ' );
     79                printAll( input, os, indent + 2 );
    8880        } // if
    8981        if ( ! clobber.empty() ) {
    90                 os << indent+1 << "clobber: " << endl;
    91                 printAll( clobber, os, indent+1 );
     82                os << std::string( indent, ' ' ) << "clobber: " << endl;
     83                printAll( clobber, os, indent + 2 );
    9284        } // if
    9385}
    … …  
    111103}
    112104
    113 void BranchStmt::print( std::ostream &os, Indenter indent ) const {
    114         os << "Branch (" << brType[type] << ")" << endl ;
    115         if ( target != "" ) os << indent+1 << "with target: " << target << endl;
    116         if ( originalTarget != "" ) os << indent+1 << "with original target: " << originalTarget << endl;
    117         if ( computedTarget != nullptr ) os << indent+1 << "with computed target: " << computedTarget << endl;
     105void BranchStmt::print( std::ostream &os, int indent ) const {
     106        os << string( indent, ' ' ) << "Branch (" << brType[type] << ")" << endl ;
     107        if ( target != "" ) os << string( indent+2, ' ' ) << "with target: " << target << endl;
     108        if ( originalTarget != "" ) os << string( indent+2, ' ' ) << "with original target: " << originalTarget << endl;
     109        if ( computedTarget != nullptr ) os << string( indent+2, ' ' ) << "with computed target: " << computedTarget << endl;
    118110}
    119111
    … …  
    126118}
    127119
    128 void ReturnStmt::print( std::ostream &os, Indenter indent ) const {
    129         os << "Return Statement, returning: ";
    130         if ( expr != nullptr ) {
    131                 os << endl << indent+1;
    132                 expr->print( os, indent+1 );
     120void ReturnStmt::print( std::ostream &os, int indent ) const {
     121        os <<  "Return Statement, returning: ";
     122        if ( expr != 0 ) {
     123                os << endl << string( indent+2, ' ' );
     124                expr->print( os, indent + 2 );
    133125        }
    134126        os << endl;
    … …  
    150142}
    151143
    152 void IfStmt::print( std::ostream &os, Indenter indent ) const {
    153         os << "If on condition: " << endl;
    154         os << indent+1;
    155         condition->print( os, indent+1 );
     144void IfStmt::print( std::ostream &os, int indent ) const {
     145        os << "If on condition: " << endl ;
     146        os << string( indent+4, ' ' );
     147        condition->print( os, indent + 4 );
    156148
    157149        if ( !initialization.empty() ) {
    158                 os << indent << "... with initialization: \n";
    159                 for ( const Statement * stmt : initialization ) {
    160                         os << indent+1;
    161                         stmt->print( os, indent+1 );
     150                os << string( indent + 2, ' ' ) << "initialization: \n";
     151                for ( std::list<Statement *>::const_iterator it = initialization.begin(); it != initialization.end(); ++it ) {
     152                        os << string( indent + 4, ' ' );
     153                        (*it)->print( os, indent + 4 );
    162154                }
    163155                os << endl;
    164156        }
    165157
    166         os << indent << "... then: " << endl;
    167 
    168         os << indent+1;
    169         thenPart->print( os, indent+1 );
     158        os << string( indent+2, ' ' ) << "... then: " << endl;
     159
     160        os << string( indent+4, ' ' );
     161        thenPart->print( os, indent + 4 );
    170162
    171163        if ( elsePart != 0 ) {
    172                 os << indent << "... else: " << endl;
    173                 os << indent+1;
    174                 elsePart->print( os, indent+1 );
     164                os << string( indent+2, ' ' ) << "... else: " << endl;
     165                os << string( indent+4, ' ' );
     166                elsePart->print( os, indent + 4 );
    175167        } // if
    176168}
    … …  
    191183}
    192184
    193 void SwitchStmt::print( std::ostream &os, Indenter indent ) const {
     185void SwitchStmt::print( std::ostream &os, int indent ) const {
    194186        os << "Switch on condition: ";
    195187        condition->print( os );
    196188        os << endl;
    197189
    198         for ( const Statement * stmt : statements ) {
    199                 stmt->print( os, indent+1 );
    200         }
     190        // statements
     191        std::list<Statement *>::const_iterator i;
     192        for ( i = statements.begin(); i != statements.end(); i++)
     193                (*i)->print( os, indent + 4 );
     194
     195        //for_each( statements.begin(), statements.end(), mem_fun( bind1st(&Statement::print ), os ));
    201196}
    202197
    203198CaseStmt::CaseStmt( std::list<Label> labels, Expression *condition, const std::list<Statement *> &statements, bool deflt ) throw ( SemanticError ) :
    204199        Statement( labels ), condition( condition ), stmts( statements ), _isDefault( deflt ) {
    205         if ( isDefault() && condition != 0 ) throw SemanticError("default case with condition: ", condition);
     200        if ( isDefault() && condition != 0 )
     201                throw SemanticError("default with conditions");
    206202}
    207203
    … …  
    220216}
    221217
    222 void CaseStmt::print( std::ostream &os, Indenter indent ) const {
    223         if ( isDefault() ) os << "Default ";
     218void CaseStmt::print( std::ostream &os, int indent ) const {
     219        os << string( indent, ' ' );
     220
     221        if ( isDefault() )
     222                os << "Default ";
    224223        else {
    225224                os << "Case ";
    226                 condition->print( os, indent );
     225                condition->print( os );
    227226        } // if
     227
    228228        os << endl;
    229229
    230         for ( Statement * stmt : stmts ) {
    231                 stmt->print( os, indent+1 );
    232         }
     230        std::list<Statement *>::const_iterator i;
     231        for ( i = stmts.begin(); i != stmts.end(); i++)
     232                (*i )->print( os, indent + 4 );
    233233}
    234234
    … …  
    246246}
    247247
    248 void WhileStmt::print( std::ostream &os, Indenter indent ) const {
     248void WhileStmt::print( std::ostream &os, int indent ) const {
    249249        os << "While on condition: " << endl ;
    250         condition->print( os, indent+1 );
    251 
    252         os << indent << "... with body: " << endl;
    253 
    254         if ( body != 0 ) body->print( os, indent+1 );
     250        condition->print( os, indent + 4 );
     251
     252        os << string( indent, ' ' ) << ".... with body: " << endl;
     253
     254        if ( body != 0 ) body->print( os, indent + 4 );
    255255}
    256256
    … …  
    272272}
    273273
    274 void ForStmt::print( std::ostream &os, Indenter indent ) const {
    275         Statement::print( os, indent ); // print labels
    276 
    277         os << "For Statement" << endl;
    278 
    279         if ( ! initialization.empty() ) {
    280                 os << indent << "... initialization: \n";
    281                 for ( Statement * stmt : initialization ) {
    282                         os << indent+1;
    283                         stmt->print( os, indent+1 );
    284                 }
    285         }
    286 
    287         if ( condition != nullptr ) {
    288                 os << indent << "... condition: \n" << indent+1;
    289                 condition->print( os, indent+1 );
    290         }
    291 
    292         if ( increment != nullptr ) {
    293                 os << "\n" << indent << "... increment: \n" << indent+1;
    294                 increment->print( os, indent+1 );
    295         }
    296 
     274void ForStmt::print( std::ostream &os, int indent ) const {
     275        os << "Labels: {";
     276        for ( std::list<Label>::const_iterator it = get_labels().begin(); it != get_labels().end(); ++it) {
     277                os << *it << ",";
     278        }
     279        os << "}" << endl;
     280
     281        os << string( indent, ' ' ) << "For Statement" << endl ;
     282
     283        os << string( indent + 2, ' ' ) << "initialization: \n";
     284        for ( std::list<Statement *>::const_iterator it = initialization.begin(); it != initialization.end(); ++it ) {
     285                os << string( indent + 4, ' ' );
     286                (*it)->print( os, indent + 4 );
     287        }
     288
     289        os << "\n" << string( indent + 2, ' ' ) << "condition: \n";
     290        if ( condition != 0 ) {
     291                os << string( indent + 4, ' ' );
     292                condition->print( os, indent + 4 );
     293        }
     294
     295        os << "\n" << string( indent + 2, ' ' ) << "increment: \n";
     296        if ( increment != 0 ) {
     297                os << string( indent + 4, ' ' );
     298                increment->print( os, indent + 4 );
     299        }
     300
     301        os << "\n" << string( indent + 2, ' ' ) << "statement block: \n";
    297302        if ( body != 0 ) {
    298                 os << "\n" << indent << "... with body: \n" << indent+1;
    299                 body->print( os, indent+1 );
    300         }
     303                os << string( indent + 4, ' ' );
     304                body->print( os, indent + 4 );
     305        }
     306
    301307        os << endl;
    302308}
    … …  
    316322}
    317323
    318 void ThrowStmt::print( std::ostream &os, Indenter indent) const {
    319         if ( target ) os << "Non-Local ";
     324void ThrowStmt::print( std::ostream &os, int indent) const {
     325        if ( target ) {
     326                os << "Non-Local ";
     327        }
    320328        os << "Throw Statement, raising: ";
    321         expr->print(os, indent+1);
     329        expr->print(os, indent + 4);
    322330        if ( target ) {
    323                 os << "... at: ";
    324                 target->print(os, indent+1);
     331                os << "At: ";
     332                target->print(os, indent + 4);
    325333        }
    326334}
    … …  
    340348}
    341349
    342 void TryStmt::print( std::ostream &os, Indenter indent ) const {
     350void TryStmt::print( std::ostream &os, int indent ) const {
    343351        os << "Try Statement" << endl;
    344         os << indent << "... with block:" << endl << indent+1;
    345         block->print( os, indent+1 );
     352        os << string( indent + 2, ' ' ) << "with block:" << endl;
     353        os << string( indent + 4, ' ' );
     354        block->print( os, indent + 4 );
    346355
    347356        // handlers
    348         os << indent << "... and handlers:" << endl;
    349         for ( const CatchStmt * stmt : handlers ) {
    350                 os << indent+1;
    351                 stmt->print( os, indent+1 );
     357        os << string( indent + 2, ' ' ) << "and handlers:" << endl;
     358        for ( std::list<CatchStmt *>::const_iterator i = handlers.begin(); i != handlers.end(); i++) {
     359                os << string( indent + 4, ' ' );
     360                (*i )->print( os, indent + 4 );
    352361        }
    353362
    354363        // finally block
    355364        if ( finallyBlock != 0 ) {
    356                 os << indent << "... and finally:" << endl << indent+1;
    357                 finallyBlock->print( os, indent+1 );
     365                os << string( indent + 2, ' ' ) << "and finally:" << endl;
     366                finallyBlock->print( os, indent + 4 );
    358367        } // if
    359368}
    … …  
    361370CatchStmt::CatchStmt( std::list<Label> labels, Kind kind, Declaration *decl, Expression *cond, Statement *body ) :
    362371        Statement( labels ), kind ( kind ), decl ( decl ), cond ( cond ), body( body ) {
    363                 assertf( decl, "Catch clause must have a declaration." );
    364372}
    365373
    … …  
    373381}
    374382
    375 void CatchStmt::print( std::ostream &os, Indenter indent ) const {
     383void CatchStmt::print( std::ostream &os, int indent ) const {
    376384        os << "Catch " << ((Terminate == kind) ? "Terminate" : "Resume") << " Statement" << endl;
    377385
    378         os << indent << "... catching: ";
    379         decl->printShort( os, indent+1 );
    380         os << endl;
     386        os << string( indent + 2, ' ' ) << "... catching: ";
     387        if ( decl ) {
     388                decl->printShort( os, indent + 4 );
     389                os << endl;
     390        }
     391        else
     392                os << string( indent + 4 , ' ' ) << ">>> Error:  this catch clause must have a declaration <<<" << endl;
    381393
    382394        if ( cond ) {
    383                 os << indent << "... with conditional:" << endl << indent+1;
    384                 cond->print( os, indent+1 );
    385         }
    386 
    387         os << indent << "... with block:" << endl;
    388         os << indent+1;
    389         body->print( os, indent+1 );
     395                os << string( indent + 2, ' ' ) << "with conditional:" << endl;
     396                os << string( indent + 4, ' ' );
     397                cond->print( os, indent + 4 );
     398        }
     399        else
     400                os << string( indent + 2, ' ' ) << "with no conditional" << endl;
     401
     402        os << string( indent + 2, ' ' ) << "with block:" << endl;
     403        os << string( indent + 4, ' ' );
     404        body->print( os, indent + 4 );
    390405}
    391406
    … …  
    402417}
    403418
    404 void FinallyStmt::print( std::ostream &os, Indenter indent ) const {
     419void FinallyStmt::print( std::ostream &os, int indent ) const {
    405420        os << "Finally Statement" << endl;
    406         os << indent << "... with block:" << endl << indent+1;
    407         block->print( os, indent+1 );
     421        os << string( indent + 2, ' ' ) << "with block:" << endl;
     422        os << string( indent + 4, ' ' );
     423        block->print( os, indent + 4 );
    408424}
    409425
    … …  
    449465}
    450466
    451 void WaitForStmt::print( std::ostream &os, Indenter indent ) const {
     467void WaitForStmt::print( std::ostream &os, int indent ) const {
    452468        os << "Waitfor Statement" << endl;
    453         os << indent << "... with block:" << endl << indent+1;
     469        os << string( indent + 2, ' ' ) << "with block:" << endl;
     470        os << string( indent + 4, ' ' );
    454471        // block->print( os, indent + 4 );
    455472}
    … …  
    458475NullStmt::NullStmt() : Statement( std::list<Label>() ) {}
    459476
    460 void NullStmt::print( std::ostream &os, Indenter ) const {
    461         os << "Null Statement" << endl;
     477void NullStmt::print( std::ostream &os, __attribute__((unused)) int indent ) const {
     478        os << "Null Statement" << endl ;
    462479}
    463480
    … …  
    473490}
    474491
    475 void ImplicitCtorDtorStmt::print( std::ostream &os, Indenter indent ) const {
     492void ImplicitCtorDtorStmt::print( std::ostream &os, int indent ) const {
    476493        os << "Implicit Ctor Dtor Statement" << endl;
    477         os << indent << "... with Ctor/Dtor: ";
    478         callStmt->print( os, indent+1);
     494        os << string( indent + 2, ' ' ) << "with Ctor/Dtor: ";
     495        callStmt->print( os, indent + 2);
    479496        os << endl;
    480497}

  • src/SynTree/Statement.h

    r7821d6c re1ff775  
    4646        virtual void accept( Visitor &v ) override = 0;
    4747        virtual Statement *acceptMutator( Mutator &m ) override = 0;
    48         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     48        virtual void print( std::ostream &os, int indent = 0 ) const override;
    4949};
    5050
    … …  
    6565        virtual void accept( Visitor &v ) override { v.visit( this ); }
    6666        virtual CompoundStmt *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    67         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     67        virtual void print( std::ostream &os, int indent = 0 ) const override;
    6868};
    6969
    … …  
    7676        virtual void accept( Visitor &v ) override { v.visit( this ); }
    7777        virtual NullStmt *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    78         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     78        virtual void print( std::ostream &os, int indent = 0 ) const override;
    7979};
    8080
    … …  
    9393        virtual void accept( Visitor &v ) override { v.visit( this ); }
    9494        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    95         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     95        virtual void print( std::ostream &os, int indent = 0 ) const override;
    9696};
    9797
    … …  
    124124        virtual void accept( Visitor & v ) { v.visit( this ); }
    125125        virtual Statement * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    126         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     126        virtual void print( std::ostream & os, int indent = 0 ) const;
    127127};
    128128
    … …  
    150150        virtual void accept( Visitor &v ) override { v.visit( this ); }
    151151        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    152         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     152        virtual void print( std::ostream &os, int indent = 0 ) const override;
    153153};
    154154
    … …  
    171171
    172172        virtual SwitchStmt *clone() const override { return new SwitchStmt( *this ); }
    173         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     173        virtual void print( std::ostream &os, int indent = 0 ) const override;
    174174
    175175};
    … …  
    199199
    200200        virtual CaseStmt *clone() const override { return new CaseStmt( *this ); }
    201         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     201        virtual void print( std::ostream &os, int indent = 0 ) const override;
    202202  private:
    203203        bool _isDefault;
    … …  
    225225        virtual void accept( Visitor &v ) override { v.visit( this ); }
    226226        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    227         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     227        virtual void print( std::ostream &os, int indent = 0 ) const override;
    228228};
    229229
    … …  
    251251        virtual void accept( Visitor &v ) override { v.visit( this ); }
    252252        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    253         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     253        virtual void print( std::ostream &os, int indent = 0 ) const override;
    254254};
    255255
    … …  
    280280        virtual void accept( Visitor &v ) override { v.visit( this ); }
    281281        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    282         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     282        virtual void print( std::ostream &os, int indent = 0 ) const override;
    283283  private:
    284284        static const char *brType[];
    … …  
    299299        virtual void accept( Visitor &v ) override { v.visit( this ); }
    300300        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    301         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     301        virtual void print( std::ostream &os, int indent = 0 ) const override;
    302302};
    303303
    … …  
    323323        virtual void accept( Visitor &v ) override { v.visit( this ); }
    324324        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    325         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     325        virtual void print( std::ostream &os, int indent = 0 ) const override;
    326326};
    327327
    … …  
    346346        virtual void accept( Visitor &v ) override { v.visit( this ); }
    347347        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    348         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     348        virtual void print( std::ostream &os, int indent = 0 ) const override;
    349349};
    350350
    … …  
    374374        virtual void accept( Visitor &v ) override { v.visit( this ); }
    375375        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    376         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     376        virtual void print( std::ostream &os, int indent = 0 ) const override;
    377377};
    378378
    … …  
    391391        virtual void accept( Visitor &v ) override { v.visit( this ); }
    392392        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    393         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     393        virtual void print( std::ostream &os, int indent = 0 ) const override;
    394394};
    395395
    … …  
    428428        virtual void accept( Visitor &v ) override { v.visit( this ); }
    429429        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    430         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     430        virtual void print( std::ostream &os, int indent = 0 ) const override;
    431431
    432432};
    … …  
    448448        virtual void accept( Visitor &v ) override { v.visit( this ); }
    449449        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    450         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     450        virtual void print( std::ostream &os, int indent = 0 ) const override;
    451451};
    452452
    … …  
    470470        virtual void accept( Visitor &v ) override { v.visit( this ); }
    471471        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    472         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     472        virtual void print( std::ostream &os, int indent = 0 ) const override;
    473473};
    474474

  • src/SynTree/TupleExpr.cc

    r7821d6c re1ff775  
    2828#include "Type.h"               // for TupleType, Type
    2929
    30 UntypedTupleExpr::UntypedTupleExpr( const std::list< Expression * > & exprs ) : Expression(), exprs( exprs ) {
     30UntypedTupleExpr::UntypedTupleExpr( const std::list< Expression * > & exprs, Expression *_aname ) : Expression( _aname ), exprs( exprs ) {
    3131}
    3232
    … …  
    3939}
    4040
    41 void UntypedTupleExpr::print( std::ostream &os, Indenter indent ) const {
     41void UntypedTupleExpr::print( std::ostream &os, int indent ) const {
    4242        os << "Untyped Tuple:" << std::endl;
    43         printAll( exprs, os, indent+1 );
     43        printAll( exprs, os, indent+2 );
    4444        Expression::print( os, indent );
    4545}
    4646
    47 TupleExpr::TupleExpr( const std::list< Expression * > & exprs ) : Expression(), exprs( exprs ) {
     47TupleExpr::TupleExpr( const std::list< Expression * > & exprs, Expression *_aname ) : Expression( _aname ), exprs( exprs ) {
    4848        set_result( Tuples::makeTupleType( exprs ) );
    4949}
    … …  
    5757}
    5858
    59 void TupleExpr::print( std::ostream &os, Indenter indent ) const {
     59void TupleExpr::print( std::ostream &os, int indent ) const {
    6060        os << "Tuple:" << std::endl;
    61         printAll( exprs, os, indent+1 );
     61        printAll( exprs, os, indent+2 );
    6262        Expression::print( os, indent );
    6363}
    … …  
    7878}
    7979
    80 void TupleIndexExpr::print( std::ostream &os, Indenter indent ) const {
     80void TupleIndexExpr::print( std::ostream &os, int indent ) const {
    8181        os << "Tuple Index Expression, with tuple:" << std::endl;
    82         os << indent+1;
    83         tuple->print( os, indent+1 );
    84         os << indent+1 << "with index: " << index << std::endl;
     82        os << std::string( indent+2, ' ' );
     83        tuple->print( os, indent+2 );
     84        os << std::string( indent+2, ' ' ) << "with index: " << index << std::endl;
    8585        Expression::print( os, indent );
    8686}
    8787
    88 TupleAssignExpr::TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls ) : Expression() {
     88TupleAssignExpr::TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls, Expression * _aname ) : Expression( _aname ) {
    8989        // convert internally into a StmtExpr which contains the declarations and produces the tuple of the assignments
    9090        set_result( Tuples::makeTupleType( assigns ) );
    … …  
    109109}
    110110
    111 void TupleAssignExpr::print( std::ostream &os, Indenter indent ) const {
     111void TupleAssignExpr::print( std::ostream &os, int indent ) const {
    112112        os << "Tuple Assignment Expression, with stmt expr:" << std::endl;
    113         os << indent+1;
    114         stmtExpr->print( os, indent+1 );
     113        os << std::string( indent+2, ' ' );
     114        stmtExpr->print( os, indent+4 );
    115115        Expression::print( os, indent );
    116116}

  • src/SynTree/TupleType.cc

    r7821d6c re1ff775  
    4848}
    4949
    50 void TupleType::print( std::ostream &os, Indenter indent ) const {
     50void TupleType::print( std::ostream &os, int indent ) const {
    5151        Type::print( os, indent );
    5252        os << "tuple of types" << std::endl;
    53         printAll( types, os, indent+1 );
     53        printAll( types, os, indent+2 );
    5454}
    5555

  • src/SynTree/Type.cc

    r7821d6c re1ff775  
    7575        Type * type;
    7676        ReferenceType * ref;
    77         for ( type = this; (ref = dynamic_cast<ReferenceType *>( type )); type = ref->base );
     77        for ( type = this; (ref = dynamic_cast<ReferenceType *>( type )); type = ref->get_base() );
    7878        return type;
    7979}
    … …  
    8181int Type::referenceDepth() const { return 0; }
    8282
    83 void Type::print( std::ostream &os, Indenter indent ) const {
     83void Type::print( std::ostream &os, int indent ) const {
    8484        if ( ! forall.empty() ) {
    8585                os << "forall" << std::endl;
    86                 printAll( forall, os, indent+1 );
    87                 os << ++indent;
     86                printAll( forall, os, indent + 4 );
     87                os << std::string( indent+2, ' ' );
    8888        } // if
    8989
    9090        if ( ! attributes.empty() ) {
    91                 os << "with attributes" << endl;
    92                 printAll( attributes, os, indent+1 );
     91                os << endl << string( indent+2, ' ' ) << "with attributes" << endl;
     92                printAll( attributes, os, indent+4 );
    9393        } // if
    9494

  • src/SynTree/Type.h

    r7821d6c re1ff775  
    181181        virtual void accept( Visitor & v ) = 0;
    182182        virtual Type *acceptMutator( Mutator & m ) = 0;
    183         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     183        virtual void print( std::ostream & os, int indent = 0 ) const;
    184184};
    185185
    … …  
    198198        virtual void accept( Visitor & v ) override { v.visit( this ); }
    199199        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    200         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     200        virtual void print( std::ostream & os, int indent = 0 ) const override;
    201201};
    202202
    … …  
    240240        virtual void accept( Visitor & v ) override { v.visit( this ); }
    241241        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    242         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     242        virtual void print( std::ostream & os, int indent = 0 ) const override;
    243243
    244244        bool isInteger() const;
    … …  
    275275        virtual void accept( Visitor & v ) override { v.visit( this ); }
    276276        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    277         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     277        virtual void print( std::ostream & os, int indent = 0 ) const override;
    278278};
    279279
    … …  
    303303        virtual void accept( Visitor & v ) override { v.visit( this ); }
    304304        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    305         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     305        virtual void print( std::ostream & os, int indent = 0 ) const override;
    306306};
    307307
    … …  
    327327        virtual void accept( Visitor & v ) override { v.visit( this ); }
    328328        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    329         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     329        virtual void print( std::ostream & os, int indent = 0 ) const override;
    330330};
    331331
    … …  
    354354        virtual void accept( Visitor & v ) override { v.visit( this ); }
    355355        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    356         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     356        virtual void print( std::ostream & os, int indent = 0 ) const override;
    357357};
    358358
    … …  
    376376        virtual void accept( Visitor & v ) override = 0;
    377377        virtual Type *acceptMutator( Mutator & m ) override = 0;
    378         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     378        virtual void print( std::ostream & os, int indent = 0 ) const override;
    379379
    380380        virtual void lookup( __attribute__((unused)) const std::string & name, __attribute__((unused)) std::list< Declaration* > & foundDecls ) const {}
    … …  
    410410        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    411411
    412         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     412        virtual void print( std::ostream & os, int indent = 0 ) const override;
    413413  private:
    414414        virtual std::string typeString() const override;
    … …  
    442442        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    443443
    444         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     444        virtual void print( std::ostream & os, int indent = 0 ) const override;
    445445  private:
    446446        virtual std::string typeString() const override;
    … …  
    514514        virtual void accept( Visitor & v ) override { v.visit( this ); }
    515515        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    516         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     516        virtual void print( std::ostream & os, int indent = 0 ) const override;
    517517  private:
    518518        virtual std::string typeString() const override;
    … …  
    551551        virtual void accept( Visitor & v ) override { v.visit( this ); }
    552552        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    553         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     553        virtual void print( std::ostream & os, int indent = 0 ) const override;
    554554};
    555555
    … …  
    570570        virtual void accept( Visitor & v ) override { v.visit( this ); }
    571571        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    572         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     572        virtual void print( std::ostream & os, int indent = 0 ) const override;
    573573};
    574574
    … …  
    599599        virtual void accept( Visitor & v ) override { v.visit( this ); }
    600600        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    601         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     601        virtual void print( std::ostream & os, int indent = 0 ) const override;
    602602};
    603603
    … …  
    613613        virtual void accept( Visitor & v ) override { v.visit( this ); }
    614614        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    615         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     615        virtual void print( std::ostream & os, int indent = 0 ) const override;
    616616};
    617617
    … …  
    625625        virtual void accept( Visitor & v ) override { v.visit( this ); }
    626626        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    627         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     627        virtual void print( std::ostream & os, int indent = 0 ) const override;
    628628};
    629629
    … …  
    637637        virtual void accept( Visitor & v ) override { v.visit( this ); }
    638638        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    639         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     639        virtual void print( std::ostream & os, int indent = 0 ) const override;
    640640};
    641641

  • src/SynTree/TypeDecl.cc

    r7821d6c re1ff775  
    4141}
    4242
    43 void TypeDecl::print( std::ostream &os, Indenter indent ) const {
     43void TypeDecl::print( std::ostream &os, int indent ) const {
    4444  NamedTypeDecl::print( os, indent );
    4545  if ( init ) {
    46     os << std::endl << indent << "with type initializer: ";
    47     init->print( os, indent + 1 );
     46    os << std::endl << std::string( indent, ' ' ) << "with type initializer: ";
     47    init->print( os, indent + 2 );
    4848  }
    4949}

  • src/SynTree/TypeExpr.cc

    r7821d6c re1ff775  
    3030}
    3131
    32 void TypeExpr::print( std::ostream &os, Indenter indent ) const {
     32void TypeExpr::print( std::ostream &os, int indent ) const {
    3333        if ( type ) type->print( os, indent );
    3434        Expression::print( os, indent );

  • src/SynTree/TypeSubstitution.cc

    r7821d6c re1ff775  
    243243}
    244244
    245 void TypeSubstitution::print( std::ostream &os, Indenter indent ) const {
    246         os << indent << "Types:" << std::endl;
     245void TypeSubstitution::print( std::ostream &os, int indent ) const {
     246        os << std::string( indent, ' ' ) << "Types:" << std::endl;
    247247        for ( TypeEnvType::const_iterator i = typeEnv.begin(); i != typeEnv.end(); ++i ) {
    248                 os << indent+1 << i->first << " -> ";
    249                 i->second->print( os, indent+2 );
     248                os << std::string( indent+2, ' ' ) << i->first << " -> ";
     249                i->second->print( os, indent+4 );
    250250                os << std::endl;
    251251        } // for
    252         os << indent << "Non-types:" << std::endl;
     252        os << std::string( indent, ' ' ) << "Non-types:" << std::endl;
    253253        for ( VarEnvType::const_iterator i = varEnv.begin(); i != varEnv.end(); ++i ) {
    254                 os << indent+1 << i->first << " -> ";
    255                 i->second->print( os, indent+2 );
     254                os << std::string( indent+2, ' ' ) << i->first << " -> ";
     255                i->second->print( os, indent+4 );
    256256                os << std::endl;
    257257        } // for

  • src/SynTree/TypeSubstitution.h

    r7821d6c re1ff775  
    6161        TypeSubstitution * acceptMutator( Mutator & mutator );
    6262
    63         void print( std::ostream &os, Indenter indent = {} ) const;
     63        void print( std::ostream &os, int indent = 0 ) const;
    6464        TypeSubstitution *clone() const { return new TypeSubstitution( *this ); }
    6565  private:

  • src/SynTree/TypeofType.cc

    r7821d6c re1ff775  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // TypeofType.cc --
     7// TypeofType.cc -- 
    88//
    99// Author           : Richard C. Bilson
    … …  
    3333}
    3434
    35 void TypeofType::print( std::ostream &os, Indenter indent ) const {
     35void TypeofType::print( std::ostream &os, int indent ) const {
    3636        Type::print( os, indent );
    3737        os << "type-of expression ";

  • src/SynTree/VarArgsType.cc

    r7821d6c re1ff775  
    2525VarArgsType::VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes ) : Type( tq, attributes ) {}
    2626
    27 void VarArgsType::print( std::ostream &os, Indenter indent ) const {
     27void VarArgsType::print( std::ostream &os, int indent ) const {
    2828        Type::print( os, indent );
    2929        os << "builtin var args pack";

  • src/SynTree/VoidType.cc

    r7821d6c re1ff775  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // VoidType.cc --
     7// VoidType.cc -- 
    88//
    99// Author           : Richard C. Bilson
    … …  
    2424}
    2525
    26 void VoidType::print( std::ostream &os, Indenter indent ) const {
     26void VoidType::print( std::ostream &os, int indent ) const {
    2727        Type::print( os, indent );
    2828        os << "void ";

  • src/SynTree/ZeroOneType.cc

    r7821d6c re1ff775  
    2525ZeroType::ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes ) : Type( tq, attributes ) {}
    2626
    27 void ZeroType::print( std::ostream &os, Indenter ) const {
     27void ZeroType::print( std::ostream &os, __attribute__((unused)) int indent ) const {
    2828        os << "zero_t";
    2929}
    … …  
    3333OneType::OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes ) : Type( tq, attributes ) {}
    3434
    35 void OneType::print( std::ostream &os, Indenter ) const {
     35void OneType::print( std::ostream &os, __attribute__((unused)) int indent ) const {
    3636        os << "one_t";
    3737}

  • src/Tuples/TupleAssignment.cc

    r7821d6c re1ff775  
    8484        bool isTuple( Expression *expr ) {
    8585                if ( ! expr ) return false;
    86                 assert( expr->result );
     86                assert( expr->has_result() );
    8787                return dynamic_cast< TupleType * >( expr->get_result()->stripReferences() );
    8888        }
    … …  
    238238
    239239        ObjectDecl * TupleAssignSpotter::Matcher::newObject( UniqueName & namer, Expression * expr ) {
    240                 assert( expr->result && ! expr->get_result()->isVoid() );
     240                assert( expr->has_result() && ! expr->get_result()->isVoid() );
    241241                ObjectDecl * ret = new ObjectDecl( namer.newName(), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, expr->get_result()->clone(), new SingleInit( expr->clone() ) );
    242242                // if expression type is a reference, don't need to construct anything, a simple initializer is sufficient.

  • src/tests/.expect/castError.txt

    r7821d6c re1ff775  
    1 castError.c:7:1 error: Cannot choose between 3 alternatives for expression
    2 Cast of:
     1castError.c:7:1 error: Cannot choose between 3 alternatives for expression Cast of:
    32  Name: f
    4 ... to:
    5   charAlternatives are:
    6 Cost ( 1, 0, 0, 0 ): Cast of:
    7      Variable Expression: f: function
    8        accepting unspecified arguments
    9      ... returning nothing
    103
    11    ... to:
    12      char
    13  (types:
    14    char
    15  )
    16  Environment:
    17 
    18 Cost ( 1, 0, 0, 0 ): Cast of:
    19      Variable Expression: f: signed int
    20    ... to:
    21      char
    22  (types:
    23    char
    24  )
    25  Environment:
    26 
    27 Cost ( 1, 0, 0, 0 ): Cast of:
    28      Variable Expression: f: double
    29    ... to:
    30      char
    31  (types:
    32    char
    33  )
    34  Environment:
     4to:
     5  char
     6Alternatives are:        Cost ( 1, 0, 0, 0 ): Cast of:
     7          Variable Expression: f: function
     8                accepting unspecified arguments
     9              returning
     10                nothing
    3511
    3612
     13        to:
     14          char
     15(types:
     16            char
     17)
     18        Environment:
     19
     20        Cost ( 1, 0, 0, 0 ): Cast of:
     21          Variable Expression: f: signed int
     22
     23        to:
     24          char
     25(types:
     26            char
     27)
     28        Environment:
     29
     30        Cost ( 1, 0, 0, 0 ): Cast of:
     31          Variable Expression: f: double
     32
     33        to:
     34          char
     35(types:
     36            char
     37)
     38        Environment:
     39
     40

  • src/tests/.expect/scopeErrors.txt

    r7821d6c re1ff775  
    11scopeErrors.c:2:1 error: duplicate object definition for thisIsAnError: signed int
    22scopeErrors.c:20:1 error: duplicate function definition for butThisIsAnError: function
    3 ... with parameters
    4   double
    5 ... returning
    6   _retval_butThisIsAnError: double
    7   ... with attributes:
    8     Attribute with name: unused
     3  with parameters
     4    double
     5  returning
     6    _retval_butThisIsAnError:       Attribute with name: unused
     7double
     8  with body
     9    CompoundStmt
    910
    10 ... with body
    11   CompoundStmt
    12 
Note: See TracChangeset for help on using the changeset viewer.