Changeset 50377a4


Ignore:
Timestamp:
Oct 2, 2017, 4:39:42 PM (7 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
Children:
bf4b4cf
Parents:
a8555c5
Message:

Refactor tree print code to use Indenter

Location:
src
Files:
50 edited

Legend:

Unmodified
Added
Removed

  • src/CodeGen/CodeGenerator.cc

    ra8555c5 r50377a4  
    10881088} // namespace CodeGen
    10891089
     1090
     1091unsigned Indenter::tabsize = 2;
     1092
    10901093std::ostream & operator<<( std::ostream & out, const BaseSyntaxNode * node ) {
    10911094        if ( node ) {

  • src/Common/Indenter.h

    ra8555c5 r50377a4  
    1818
    1919struct Indenter {
    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;
     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;
    2325
    2426        Indenter & operator+=(int nlevels) { indent += amt*nlevels; return *this; }
    … …  
    3032};
    3133
    32 inline std::ostream & operator<<( std::ostream & out, Indenter & indent ) {
     34inline std::ostream & operator<<( std::ostream & out, const Indenter & indent ) {
    3335        return out << std::string(indent.indent, ' ');
    3436}

  • src/Common/utility.h

    ra8555c5 r50377a4  
    2828#include <cassert>
    2929
     30#include "Common/Indenter.h"
     31
    3032template< typename T >
    3133static inline T * maybeClone( const T *orig ) {
    … …  
    7577
    7678template< typename Container >
    77 void printAll( const Container &container, std::ostream &os, int indent = 0 ) {
     79void printAll( const Container &container, std::ostream &os, Indenter indent = {} ) {
    7880        for ( typename Container::const_iterator i = container.begin(); i != container.end(); ++i ) {
    7981                if ( *i ) {
    80                         os << std::string( indent,  ' ' );
    81                         (*i)->print( os, indent + 2 );
     82                        os << indent;
     83                        (*i)->print( os, indent );
    8284                        // need an endl after each element because it's not easy to know when each individual item should end
    8385                        os << std::endl;
    … …  
    351353template< typename T1, typename T2 >
    352354struct group_iterate_t {
     355private:
     356        std::tuple<T1, T2> args;
     357public:
    353358        group_iterate_t( bool skipBoundsCheck, const T1 & v1, const T2 & v2 ) : args(v1, v2) {
    354359                assertf(skipBoundsCheck || v1.size() == v2.size(), "group iteration requires containers of the same size: <%zd, %zd>.", v1.size(), v2.size());
    355360        };
    356361
     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
    357366        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;
    363367                typedef std::tuple<T1Iter, T2Iter> IterTuple;
    364368                IterTuple it;
    … …  
    370374                value_type operator*() const { return std::tie( *std::get<0>(it), *std::get<1>(it) ); }
    371375        };
     376
    372377        iterator begin() { return iterator( std::get<0>(args).begin(), std::get<1>(args).begin() ); }
    373378        iterator end() { return iterator( std::get<0>(args).end(), std::get<1>(args).end() ); }
    374 
    375 private:
    376         std::tuple<T1, T2> args;
    377379};
    378380

  • src/InitTweak/FixInit.cc

    ra8555c5 r50377a4  
    552552                                Expression * retExpr = new CommaExpr( assign, new VariableExpr( returnDecl ) );
    553553                                // move env from callExpr to retExpr
    554                                 retExpr->set_env( callExpr->get_env() );
    555                                 callExpr->set_env( nullptr );
     554                                std::swap( retExpr->env, callExpr->env );
    556555                                return retExpr;
    557556                        } else {

  • src/ResolvExpr/Alternative.cc

    ra8555c5 r50377a4  
    6666        }
    6767
    68         void Alternative::print( std::ostream &os, int indent ) const {
    69                 os << std::string( indent, ' ' ) << "Cost " << cost << ": ";
     68        void Alternative::print( std::ostream &os, Indenter indent ) const {
     69                os << "Cost " << cost << ": ";
    7070                if ( expr ) {
    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;
     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;
    7676                } else {
    7777                        os << "Null expression!" << std::endl;
    7878                } // if
    79                 os << std::string( indent, ' ' ) << "Environment: ";
    80                 env.print( os, indent+2 );
     79                os << indent << "Environment: ";
     80                env.print( os, indent+1 );
    8181                os << std::endl;
    8282        }

  • src/ResolvExpr/Alternative.h

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

  • src/ResolvExpr/AlternativeFinder.cc

    ra8555c5 r50377a4  
    7575
    7676        namespace {
    77                 void printAlts( const AltList &list, std::ostream &os, int indent = 0 ) {
     77                void printAlts( const AltList &list, std::ostream &os, unsigned int indentAmt = 0 ) {
     78                        Indenter indent = { Indenter::tabsize, indentAmt };
    7879                        for ( AltList::const_iterator i = list.begin(); i != list.end(); ++i ) {
    7980                                i->print( os, indent );
    … …  
    195196                                AltList winners;
    196197                                findMinCost( alternatives.begin(), alternatives.end(), back_inserter( winners ) );
    197                                 stream << "Cannot choose between " << winners.size() << " alternatives for expression ";
     198                                stream << "Cannot choose between " << winners.size() << " alternatives for expression\n";
    198199                                expr->print( stream );
    199                                 stream << "Alternatives are:";
    200                                 printAlts( winners, stream, 8 );
     200                                stream << "Alternatives are:\n";
     201                                printAlts( winners, stream, 1 );
    201202                                throw SemanticError( stream.str() );
    202203                        }
    … …  
    728729                PRINT(
    729730                        std::cerr << "known function ops:" << std::endl;
    730                         printAlts( funcOpFinder.alternatives, std::cerr, 8 );
     731                        printAlts( funcOpFinder.alternatives, std::cerr, 1 );
    731732                )
    732733

  • src/ResolvExpr/TypeEnvironment.cc

    ra8555c5 r50377a4  
    6868        }
    6969
    70         void EqvClass::print( std::ostream &os, int indent ) const {
    71                 os << std::string( indent, ' ' ) << "( ";
     70        void EqvClass::print( std::ostream &os, Indenter indent ) const {
     71                os << "( ";
    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 );
     76                        type->print( os, indent+1 );
    7777                } // if
    7878                if ( ! allowWidening ) {
    … …  
    144144        }
    145145
    146         void TypeEnvironment::print( std::ostream &os, int indent ) const {
     146        void TypeEnvironment::print( std::ostream &os, Indenter 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

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

  • src/SynTree/AddressExpr.cc

    ra8555c5 r50377a4  
    6262}
    6363
    64 void AddressExpr::print( std::ostream &os, int indent ) const {
     64void AddressExpr::print( std::ostream &os, Indenter indent ) const {
    6565        os << "Address of:" << std::endl;
    6666        if ( arg ) {
    67                 os << std::string( indent+2, ' ' );
    68                 arg->print( os, indent+2 );
     67                os << indent+1;
     68                arg->print( os, indent+1 );
    6969        } // if
    7070}
    … …  
    7777LabelAddressExpr::~LabelAddressExpr() {}
    7878
    79 void LabelAddressExpr::print( std::ostream & os, int indent ) const {
    80         os << "Address of label:" << std::endl << std::string( indent+2, ' ' ) << arg;
     79void LabelAddressExpr::print( std::ostream & os, Indenter ) const {
     80        os << "Address of label:" << arg;
    8181}
    8282

  • src/SynTree/AggregateDecl.cc

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

  • src/SynTree/ApplicationExpr.cc

    ra8555c5 r50377a4  
    6868}
    6969
    70 void printInferParams( const InferredParams & inferParams, std::ostream &os, int indent, int level ) {
     70void printInferParams( const InferredParams & inferParams, std::ostream &os, Indenter indent, int level ) {
    7171        if ( ! inferParams.empty() ) {
    72                 os << std::string(indent, ' ') << "with inferred parameters " << level << ":" << std::endl;
     72                os << indent << "with inferred parameters " << level << ":" << std::endl;
    7373                for ( InferredParams::const_iterator i = inferParams.begin(); i != inferParams.end(); ++i ) {
    74                         os << std::string(indent+2, ' ');
    75                         Declaration::declFromId( i->second.decl )->printShort( os, indent+2 );
     74                        os << indent+1;
     75                        Declaration::declFromId( i->second.decl )->printShort( os, indent+1 );
    7676                        os << std::endl;
    77                         printInferParams( *i->second.inferParams, os, indent+2, level+1 );
     77                        printInferParams( *i->second.inferParams, os, indent+1, level+1 );
    7878                } // for
    7979        } // if
    8080}
    8181
    82 void ApplicationExpr::print( std::ostream &os, int indent ) const {
    83         os << "Application of" << std::endl << std::string(indent+2, ' ');
    84         function->print( os, indent+2 );
     82void 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;
    8586        if ( ! args.empty() ) {
    86                 os << std::string( indent, ' ' ) << "to arguments" << std::endl;
    87                 printAll( args, os, indent+2 );
     87                os << indent << "... to arguments" << std::endl;
     88                printAll( args, os, indent+1 );
    8889        } // if
    89         printInferParams( inferParams, os, indent+2, 0 );
     90        printInferParams( inferParams, os, indent+1, 0 );
    9091        Expression::print( os, indent );
    9192}

  • src/SynTree/ArrayType.cc

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

  • src/SynTree/AttrType.cc

    ra8555c5 r50377a4  
    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, int indent ) const {
     44void AttrType::print( std::ostream &os, Indenter indent ) const {
    4545        Type::print( os, indent );
    4646        os << "attribute " << name << " applied to ";

  • src/SynTree/Attribute.cc

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

  • src/SynTree/Attribute.h

    ra8555c5 r50377a4  
    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, int indent = 0 ) const override;
     48        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    4949};
    5050

  • src/SynTree/BaseSyntaxNode.h

    ra8555c5 r50377a4  
    1717
    1818#include "Common/CodeLocation.h"
     19#include "Common/Indenter.h"
    1920class Visitor;
    2021class Mutator;
    … …  
    2930        virtual void accept( Visitor & v ) = 0;
    3031        virtual BaseSyntaxNode * acceptMutator( Mutator & m ) = 0;
    31         virtual void print( std::ostream & os, int indent = 0 ) const = 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  }
    3239};
    3340

  • src/SynTree/BasicType.cc

    ra8555c5 r50377a4  
    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, int indent ) const {
     26void BasicType::print( std::ostream &os, Indenter indent ) const {
    2727        Type::print( os, indent );
    2828        os << BasicType::typeNames[ kind ];

  • src/SynTree/CommaExpr.cc

    ra8555c5 r50377a4  
    3939}
    4040
    41 void CommaExpr::print( std::ostream &os, int indent ) const {
     41void CommaExpr::print( std::ostream &os, Indenter indent ) const {
    4242        os << "Comma Expression:" << std::endl;
    43         os << std::string( indent+2, ' ' );
    44         arg1->print( os, indent+2 );
     43        os << (indent+1);
     44        arg1->print( os, indent+1 );
    4545        os << std::endl;
    46         os << std::string( indent+2, ' ' );
    47         arg2->print( os, indent+2 );
     46        os << (indent+1);
     47        arg2->print( os, indent+1 );
    4848        Expression::print( os, indent );
    4949}

  • src/SynTree/CompoundStmt.cc

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

  • src/SynTree/DeclStmt.cc

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

  • src/SynTree/Declaration.cc

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

  • src/SynTree/Declaration.h

    ra8555c5 r50377a4  
    6464        virtual void accept( Visitor &v ) override = 0;
    6565        virtual Declaration *acceptMutator( Mutator &m ) override = 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;
     66        virtual void print( std::ostream &os, Indenter indent = {} ) const override = 0;
     67        virtual void printShort( std::ostream &os, Indenter indent = {} ) 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, int indent = 0 ) const override;
    145         virtual void printShort( std::ostream &os, int indent = 0 ) const override;
     144        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     145        virtual void printShort( std::ostream &os, Indenter indent = {} ) 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, int indent = 0 ) const override;
    173         virtual void printShort( std::ostream &os, int indent = 0 ) const override;
     172        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     173        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
    174174};
    175175
    … …  
    193193
    194194        virtual NamedTypeDecl *clone() const override = 0;
    195         virtual void print( std::ostream &os, int indent = 0 ) const override;
    196         virtual void printShort( std::ostream &os, int indent = 0 ) const override;
     195        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     196        virtual void printShort( std::ostream &os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     237        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
    238238
    239239  private:
    … …  
    276276        AggregateDecl * set_body( bool body ) { AggregateDecl::body = body; return this; }
    277277
    278         virtual void print( std::ostream &os, int indent = 0 ) const override;
    279         virtual void printShort( std::ostream &os, int indent = 0 ) const override;
     278        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     279        virtual void printShort( std::ostream &os, Indenter indent = {} ) 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, int indent = 0 ) const override;
    358         virtual void printShort( std::ostream &os, int indent = 0 ) const override;
     357        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     358        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
    359359};
    360360

  • src/SynTree/Expression.cc

    ra8555c5 r50377a4  
    4444}
    4545
    46 void Expression::print( std::ostream &os, int indent ) const {
     46void Expression::print( std::ostream &os, Indenter indent ) const {
    4747        if ( env ) {
    48                 os << std::string( indent, ' ' ) << "with environment:" << std::endl;
    49                 env->print( os, indent+2 );
     48                os << std::endl << indent << "... with environment:" << std::endl;
     49                env->print( os, indent+1 );
    5050        } // if
    5151
    52         if ( argName ) {
    53                 os << std::string( indent, ' ' ) << "with designator:";
    54                 argName->print( os, indent+2 );
    55         } // if
    56 
    5752        if ( extension ) {
    58                 os << std::string( indent, ' ' ) << "with extension:";
     53                os << std::endl << indent << "... with extension:";
    5954        } // if
    6055}
    … …  
    6964ConstantExpr::~ConstantExpr() {}
    7065
    71 void ConstantExpr::print( std::ostream &os, int indent ) const {
     66void ConstantExpr::print( std::ostream &os, Indenter indent ) const {
    7267        os << "constant expression " ;
    7368        constant.print( os );
    … …  
    9691}
    9792
    98 void VariableExpr::print( std::ostream &os, int indent ) const {
     93void VariableExpr::print( std::ostream &os, Indenter indent ) const {
    9994        os << "Variable Expression: ";
    100 
    101         Declaration *decl = get_var();
    102         if ( decl != 0) decl->printShort(os, indent + 2);
    103         os << std::endl;
     95        var->printShort(os, indent);
    10496        Expression::print( os, indent );
    10597}
    … …  
    124116}
    125117
    126 void SizeofExpr::print( std::ostream &os, int indent) const {
     118void SizeofExpr::print( std::ostream &os, Indenter indent) const {
    127119        os << "Sizeof Expression on: ";
    128 
    129         if (isType)
    130                 type->print(os, indent + 2);
    131         else
    132                 expr->print(os, indent + 2);
    133 
    134         os << std::endl;
     120        if (isType) type->print(os, indent+1);
     121        else expr->print(os, indent+1);
    135122        Expression::print( os, indent );
    136123}
    … …  
    155142}
    156143
    157 void AlignofExpr::print( std::ostream &os, int indent) const {
     144void AlignofExpr::print( std::ostream &os, Indenter indent) const {
    158145        os << "Alignof Expression on: ";
    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 
    169 UntypedOffsetofExpr::UntypedOffsetofExpr( Type *type_, const std::string &member_, Expression *_aname ) :
    170                 Expression( _aname ), type(type_), member(member_) {
     146        if (isType) type->print(os, indent+1);
     147        else expr->print(os, indent+1);
     148        Expression::print( os, indent );
     149}
     150
     151UntypedOffsetofExpr::UntypedOffsetofExpr( Type *type, const std::string &member, Expression *_aname ) :
     152                Expression( _aname ), type(type), member(member) {
     153        assert( type );
    171154        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
    172155}
    … …  
    179162}
    180163
    181 void 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 
    194 OffsetofExpr::OffsetofExpr( Type *type_, DeclarationWithType *member_, Expression *_aname ) :
    195                 Expression( _aname ), type(type_), member(member_) {
     164void UntypedOffsetofExpr::print( std::ostream &os, Indenter indent) const {
     165        os << "Untyped Offsetof Expression on member " << member << " of ";
     166        type->print(os, indent+1);
     167        Expression::print( os, indent );
     168}
     169
     170OffsetofExpr::OffsetofExpr( Type *type, DeclarationWithType *member, Expression *_aname ) :
     171                Expression( _aname ), type(type), member(member) {
     172        assert( member );
     173        assert( type );
    196174        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
    197175}
    … …  
    204182}
    205183
    206 void 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 
    227 OffsetPackExpr::OffsetPackExpr( StructInstType *type_, Expression *aname_ ) : Expression( aname_ ), type( type_ ) {
     184void OffsetofExpr::print( std::ostream &os, Indenter indent) const {
     185        os << "Offsetof Expression on member " << member->name << " of ";
     186        type->print(os, indent+1);
     187        Expression::print( os, indent );
     188}
     189
     190OffsetPackExpr::OffsetPackExpr( StructInstType *type, Expression *aname_ ) : Expression( aname_ ), type( type ) {
     191        assert( type );
    228192        set_result( new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0, false, false ) );
    229193}
    … …  
    233197OffsetPackExpr::~OffsetPackExpr() { delete type; }
    234198
    235 void 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;
     199void OffsetPackExpr::print( std::ostream &os, Indenter indent ) const {
     200        os << "Offset pack expression on ";
     201        type->print(os, indent+1);
    245202        Expression::print( os, indent );
    246203}
    … …  
    264221}
    265222
    266 void AttrExpr::print( std::ostream &os, int indent) const {
     223void AttrExpr::print( std::ostream &os, Indenter indent) const {
    267224        os << "Attr ";
    268         attr->print( os, indent + 2 );
     225        attr->print( os, indent+1);
    269226        if ( isType || expr ) {
    270227                os << "applied to: ";
    271 
    272                 if (isType)
    273                         type->print(os, indent + 2);
    274                 else
    275                         expr->print(os, indent + 2);
     228                if (isType) type->print(os, indent+1);
     229                else expr->print(os, indent+1);
    276230        } // if
    277 
    278         os << std::endl;
    279231        Expression::print( os, indent );
    280232}
    … …  
    295247}
    296248
    297 void 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, ' ' );
     249void CastExpr::print( std::ostream &os, Indenter indent ) const {
     250        os << "Cast of:" << std::endl << indent+1;
     251        arg->print(os, indent+1);
     252        os << std::endl << indent << "... to:";
    302253        if ( result->isVoid() ) {
    303                 os << "nothing";
     254                os << " nothing";
    304255        } else {
    305                 result->print( os, indent+2 );
     256                os << std::endl << indent+1;
     257                result->print( os, indent+1 );
    306258        } // if
    307         os << std::endl;
    308259        Expression::print( os, indent );
    309260}
    … …  
    320271}
    321272
    322 void 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, ' ' );
     273void VirtualCastExpr::print( std::ostream &os, Indenter indent ) const {
     274        os << "Virtual Cast of:" << std::endl << indent+1;
     275        arg->print(os, indent+1);
     276        os << std::endl << indent << "... to:";
    327277        if ( ! result ) {
    328                 os << "unknown";
     278                os << " unknown";
    329279        } else {
    330                 result->print( os, indent+2 );
     280                os << std::endl << indent+1;
     281                result->print( os, indent+1 );
    331282        } // if
    332         os << std::endl;
    333         Expression::print( os, indent );
    334 }
    335 
    336 UntypedMemberExpr::UntypedMemberExpr( Expression * _member, Expression *_aggregate, Expression *_aname ) :
    337                 Expression( _aname ), member(_member), aggregate(_aggregate) {}
     283        Expression::print( os, indent );
     284}
     285
     286UntypedMemberExpr::UntypedMemberExpr( Expression * member, Expression *aggregate, Expression *_aname ) :
     287                Expression( _aname ), member(member), aggregate(aggregate) {
     288        assert( aggregate );
     289}
    338290
    339291UntypedMemberExpr::UntypedMemberExpr( const UntypedMemberExpr &other ) :
    … …  
    346298}
    347299
    348 void 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, ' ' );
     300void UntypedMemberExpr::print( std::ostream &os, Indenter indent ) const {
     301        os << "Untyped Member Expression, with field: " << std::endl << indent+1;
     302        member->print(os, indent+1 );
     303        os << indent << "... from aggregate: " << std::endl << indent+1;
     304        aggregate->print(os, indent+1);
    361305        Expression::print( os, indent );
    362306}
    … …  
    377321
    378322
    379 MemberExpr::MemberExpr( DeclarationWithType *_member, Expression *_aggregate, Expression *_aname ) :
    380                 Expression( _aname ), member(_member), aggregate(_aggregate) {
     323MemberExpr::MemberExpr( DeclarationWithType *member, Expression *aggregate, Expression *_aname ) :
     324                Expression( _aname ), member(member), aggregate(aggregate) {
     325        assert( member );
     326        assert( aggregate );
    381327
    382328        TypeSubstitution sub( makeSub( aggregate->get_result() ) );
    … …  
    396342}
    397343
    398 void MemberExpr::print( std::ostream &os, int indent ) const {
     344void MemberExpr::print( std::ostream &os, Indenter indent ) const {
    399345        os << "Member Expression, with field: " << std::endl;
    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, ' ' );
     346        os << indent+1;
     347        member->print( os, indent+1 );
     348        os << std::endl << indent << "... from aggregate: " << std::endl << indent+1;
     349        aggregate->print(os, indent + 1);
    413350        Expression::print( os, indent );
    414351}
    … …  
    456393
    457394
    458 void UntypedExpr::print( std::ostream &os, int indent ) const {
     395void UntypedExpr::print( std::ostream &os, Indenter indent ) const {
    459396        os << "Applying untyped: " << std::endl;
    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 
    467 void 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 
    475 NameExpr::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");
     397        os << indent+1;
     398        function->print(os, indent+1);
     399        os << std::endl << indent << "...to: " << std::endl;
     400        printAll(args, os, indent+1);
     401        Expression::print( os, indent );
     402}
     403
     404NameExpr::NameExpr( std::string name, Expression *_aname ) : Expression( _aname ), name(name) {
     405        assertf(name != "0", "Zero is not a valid name");
     406        assertf(name != "1", "One is not a valid name");
    478407}
    479408
    … …  
    483412NameExpr::~NameExpr() {}
    484413
    485 void NameExpr::print( std::ostream &os, int indent ) const {
    486         os << "Name: " << get_name() << std::endl;
     414void NameExpr::print( std::ostream &os, Indenter indent ) const {
     415        os << "Name: " << get_name();
    487416        Expression::print( os, indent );
    488417}
    … …  
    502431}
    503432
    504 void LogicalExpr::print( std::ostream &os, int indent )const {
    505         os << "Short-circuited operation (" << (isAnd?"and":"or") << ") on: ";
     433void LogicalExpr::print( std::ostream &os, Indenter indent )const {
     434        os << "Short-circuited operation (" << (isAnd ? "and" : "or") << ") on: ";
    506435        arg1->print(os);
    507436        os << " and ";
    508437        arg2->print(os);
    509         os << std::endl;
    510         Expression::print( os, indent );
    511 }
    512 
    513 ConditionalExpr::ConditionalExpr( Expression *arg1_, Expression *arg2_, Expression *arg3_, Expression *_aname ) :
    514                 Expression( _aname ), arg1(arg1_), arg2(arg2_), arg3(arg3_) {}
     438        Expression::print( os, indent );
     439}
     440
     441ConditionalExpr::ConditionalExpr( Expression * arg1, Expression * arg2, Expression * arg3, Expression *_aname ) :
     442                Expression( _aname ), arg1(arg1), arg2(arg2), arg3(arg3) {}
    515443
    516444ConditionalExpr::ConditionalExpr( const ConditionalExpr &other ) :
    … …  
    524452}
    525453
    526 void 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;
     454void ConditionalExpr::print( std::ostream &os, Indenter indent ) const {
     455        os << "Conditional expression on: " << std::endl << indent+1;
     456        arg1->print( os, indent+1 );
     457        os << indent << "First alternative:" << std::endl << indent+1;
     458        arg2->print( os, indent+1 );
     459        os << indent << "Second alternative:" << std::endl << indent+1;
     460        arg3->print( os, indent+1 );
    537461        Expression::print( os, indent );
    538462}
    … …  
    541465
    542466
    543 void AsmExpr::print( std::ostream &os, int indent ) const {
     467void AsmExpr::print( std::ostream &os, Indenter indent ) const {
    544468        os << "Asm Expression: " << std::endl;
    545         if ( inout ) inout->print( os, indent + 2 );
    546         if ( constraint ) constraint->print( os, indent + 2 );
    547         if ( operand ) operand->print( os, indent + 2 );
     469        if ( inout ) inout->print( os, indent+1 );
     470        if ( constraint ) constraint->print( os, indent+1 );
     471        if ( operand ) operand->print( os, indent+1 );
    548472}
    549473
    … …  
    551475ImplicitCopyCtorExpr::ImplicitCopyCtorExpr( ApplicationExpr * callExpr ) : callExpr( callExpr ) {
    552476        assert( callExpr );
    553         assert( callExpr->has_result() );
     477        assert( callExpr->result );
    554478        set_result( callExpr->get_result()->clone() );
    555479}
    … …  
    569493}
    570494
    571 void 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);
     495void ImplicitCopyCtorExpr::print( std::ostream &os, Indenter indent ) const {
     496        os <<  "Implicit Copy Constructor Expression: " << std::endl << indent+1;
     497        callExpr->print( os, indent+1 );
     498        os << std::endl << indent << "... with temporaries:" << std::endl;
     499        printAll( tempDecls, os, indent+1 );
     500        os << std::endl << indent << "... with return temporaries:" << std::endl;
     501        printAll( returnDecls, os, indent+1 );
    580502        Expression::print( os, indent );
    581503}
    … …  
    587509        Expression * arg = InitTweak::getCallArg( callExpr, 0 );
    588510        assert( arg );
    589         set_result( maybeClone( arg->get_result() ) );
     511        set_result( maybeClone( arg->result ) );
    590512}
    591513
    … …  
    597519}
    598520
    599 void ConstructorExpr::print( std::ostream &os, int indent ) const {
    600         os <<  "Constructor Expression: " << std::endl;
    601         assert( callExpr );
    602         os << std::string( indent+2, ' ' );
     521void ConstructorExpr::print( std::ostream &os, Indenter indent ) const {
     522        os <<  "Constructor Expression: " << std::endl << indent+1;
    603523        callExpr->print( os, indent + 2 );
    604524        Expression::print( os, indent );
    … …  
    618538}
    619539
    620 void 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 );
     540void CompoundLiteralExpr::print( std::ostream &os, Indenter indent ) const {
     541        os << "Compound Literal Expression: " << std::endl << indent+1;
     542        result->print( os, indent+1 );
     543        os << indent+1;
     544        initializer->print( os, indent+1 );
    626545        Expression::print( os, indent );
    627546}
    … …  
    629548RangeExpr::RangeExpr( Expression *low, Expression *high ) : low( low ), high( high ) {}
    630549RangeExpr::RangeExpr( const RangeExpr &other ) : Expression( other ), low( other.low->clone() ), high( other.high->clone() ) {}
    631 void RangeExpr::print( std::ostream &os, int indent ) const {
     550void RangeExpr::print( std::ostream &os, Indenter indent ) const {
    632551        os << "Range Expression: ";
    633552        low->print( os, indent );
    … …  
    659578        deleteAll( returnDecls );
    660579}
    661 void StmtExpr::print( std::ostream &os, int indent ) const {
    662         os << "Statement Expression: " << std::endl << std::string( indent, ' ' );
    663         statements->print( os, indent+2 );
     580void StmtExpr::print( std::ostream &os, Indenter indent ) const {
     581        os << "Statement Expression: " << std::endl << indent+1;
     582        statements->print( os, indent+1 );
    664583        if ( ! returnDecls.empty() ) {
    665                 os << std::string( indent+2, ' ' ) << "with returnDecls: ";
    666                 printAll( returnDecls, os, indent+2 );
     584                os << indent+1 << "... with returnDecls: ";
     585                printAll( returnDecls, os, indent+1 );
    667586        }
    668587        if ( ! dtors.empty() ) {
    669                 os << std::string( indent+2, ' ' ) << "with dtors: ";
    670                 printAll( dtors, os, indent+2 );
     588                os << indent+1 << "... with dtors: ";
     589                printAll( dtors, os, indent+1 );
    671590        }
    672591        Expression::print( os, indent );
    … …  
    690609        delete var;
    691610}
    692 void 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 );
     611void UniqueExpr::print( std::ostream &os, Indenter indent ) const {
     612        os << "Unique Expression with id:" << id << std::endl << indent+1;
     613        expr->print( os, indent+1 );
     614        if ( object ) {
     615                os << indent << "... with decl: ";
     616                get_object()->printShort( os, indent+1 );
    698617        }
    699618        Expression::print( os, indent );
    … …  
    713632}
    714633
    715 void 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 );
     634void UntypedInitExpr::print( std::ostream & os, Indenter indent ) const {
     635        os << "Untyped Init Expression" << std::endl << indent+1;
     636        expr->print( os, indent+1 );
    718637        if ( ! initAlts.empty() ) {
    719638                for ( const InitAlternative & alt : initAlts ) {
    720                         os << std::string( indent+2, ' ' ) <<  "InitAlternative: ";
    721                         alt.type->print( os, indent+2 );
    722                         alt.designation->print( os, indent+2 );
     639                        os << indent+1 <<  "InitAlternative: ";
     640                        alt.type->print( os, indent+1 );
     641                        alt.designation->print( os, indent+1 );
    723642                }
    724643        }
    … …  
    734653}
    735654
    736 void 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 );
     655void InitExpr::print( std::ostream & os, Indenter indent ) const {
     656        os << "Init Expression" << std::endl << indent+1;
     657        expr->print( os, indent+1 );
     658        os << indent+1 << "... with designation: ";
     659        designation->print( os, indent+1 );
    741660}
    742661

  • src/SynTree/Expression.h

    ra8555c5 r50377a4  
    5858        virtual void accept( Visitor & v ) override = 0;
    5959        virtual Expression * acceptMutator( Mutator & m ) override = 0;
    60         virtual void print( std::ostream & os, int indent = 0 ) const override;
     60        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    6161};
    6262
    … …  
    101101        virtual void accept( Visitor & v ) { v.visit( this ); }
    102102        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    103         virtual void print( std::ostream & os, int indent = 0 ) const;
     103        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    104104};
    105105
    … …  
    119119        void set_function( Expression * newValue ) { function = newValue; }
    120120
    121         void set_args( std::list<Expression *> & listArgs ) { args = listArgs; }
    122121        std::list<Expression*>::iterator begin_args() { return args.begin(); }
    123122        std::list<Expression*>::iterator end_args() { return args.end(); }
    … …  
    130129        virtual void accept( Visitor & v ) { v.visit( this ); }
    131130        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    132         virtual void print( std::ostream & os, int indent = 0 ) const;
    133         virtual void printArgs(std::ostream & os, int indent = 0) const;
     131        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    134132};
    135133
    … …  
    149147        virtual void accept( Visitor & v ) { v.visit( this ); }
    150148        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    151         virtual void print( std::ostream & os, int indent = 0 ) const;
     149        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    152150};
    153151
    … …  
    170168        virtual void accept( Visitor & v ) { v.visit( this ); }
    171169        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    172         virtual void print( std::ostream & os, int indent = 0 ) const;
     170        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    173171};
    174172
    … …  
    186184        virtual void accept( Visitor & v ) { v.visit( this ); }
    187185        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    188         virtual void print( std::ostream & os, int indent = 0 ) const;
     186        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    189187};
    190188
    … …  
    205203        virtual void accept( Visitor & v ) { v.visit( this ); }
    206204        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    207         virtual void print( std::ostream & os, int indent = 0 ) const;
     205        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    208206};
    209207
    … …  
    223221        virtual void accept( Visitor & v ) { v.visit( this ); }
    224222        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    225         virtual void print( std::ostream & os, int indent = 0 ) const;
     223        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    226224};
    227225
    … …  
    244242        virtual void accept( Visitor & v ) { v.visit( this ); }
    245243        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    246         virtual void print( std::ostream & os, int indent = 0 ) const;
     244        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    247245};
    248246
    … …  
    266264        virtual void accept( Visitor & v ) { v.visit( this ); }
    267265        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    268         virtual void print( std::ostream & os, int indent = 0 ) const;
     266        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    269267};
    270268
    … …  
    287285        virtual void accept( Visitor & v ) { v.visit( this ); }
    288286        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    289         virtual void print( std::ostream & os, int indent = 0 ) const;
     287        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    290288};
    291289
    … …  
    305303        virtual void accept( Visitor & v ) { v.visit( this ); }
    306304        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    307         virtual void print( std::ostream & os, int indent = 0 ) const;
     305        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    308306};
    309307
    … …  
    330328        virtual void accept( Visitor & v ) { v.visit( this ); }
    331329        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    332         virtual void print( std::ostream & os, int indent = 0 ) const;
     330        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    333331};
    334332
    … …  
    355353        virtual void accept( Visitor & v ) { v.visit( this ); }
    356354        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    357         virtual void print( std::ostream & os, int indent = 0 ) const;
     355        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    358356};
    359357
    … …  
    376374        virtual void accept( Visitor & v ) { v.visit( this ); }
    377375        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    378         virtual void print( std::ostream & os, int indent = 0 ) const;
     376        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    379377};
    380378
    … …  
    397395        virtual void accept( Visitor & v ) { v.visit( this ); }
    398396        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    399         virtual void print( std::ostream & os, int indent = 0 ) const;
     397        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    400398};
    401399
    … …  
    415413        virtual void accept( Visitor & v ) { v.visit( this ); }
    416414        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    417         virtual void print( std::ostream & os, int indent = 0 ) const;
     415        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    418416};
    419417
    … …  
    443441        virtual void accept( Visitor & v ) { v.visit( this ); }
    444442        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    445         virtual void print( std::ostream & os, int indent = 0 ) const;
     443        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    446444};
    447445
    … …  
    465463        virtual void accept( Visitor & v ) { v.visit( this ); }
    466464        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    467         virtual void print( std::ostream & os, int indent = 0 ) const;
     465        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    468466
    469467  private:
    … …  
    492490        virtual void accept( Visitor & v ) { v.visit( this ); }
    493491        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    494         virtual void print( std::ostream & os, int indent = 0 ) const;
     492        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    495493};
    496494
    … …  
    513511        virtual void accept( Visitor & v ) { v.visit( this ); }
    514512        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    515         virtual void print( std::ostream & os, int indent = 0 ) const;
     513        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    516514};
    517515
    … …  
    531529        virtual void accept( Visitor & v ) { v.visit( this ); }
    532530        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    533         virtual void print( std::ostream & os, int indent = 0 ) const;
     531        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    534532};
    535533
    … …  
    557555        virtual void accept( Visitor & v ) { v.visit( this ); }
    558556        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    559         virtual void print( std::ostream & os, int indent = 0 ) const;
     557        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    560558
    561559        // https://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/Machine-Constraints.html#Machine-Constraints
    … …  
    585583        virtual void accept( Visitor & v ) { v.visit( this ); }
    586584        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    587         virtual void print( std::ostream & os, int indent = 0 ) const;
     585        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    588586};
    589587
    … …  
    603601        virtual void accept( Visitor & v ) { v.visit( this ); }
    604602        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    605         virtual void print( std::ostream & os, int indent = 0 ) const;
     603        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    606604};
    607605
    … …  
    621619        virtual void accept( Visitor & v ) { v.visit( this ); }
    622620        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    623         virtual void print( std::ostream & os, int indent = 0 ) const;
     621        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    624622};
    625623
    … …  
    640638        virtual void accept( Visitor & v ) { v.visit( this ); }
    641639        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    642         virtual void print( std::ostream & os, int indent = 0 ) const;
     640        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    643641};
    644642
    … …  
    657655        virtual void accept( Visitor & v ) { v.visit( this ); }
    658656        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    659         virtual void print( std::ostream & os, int indent = 0 ) const;
     657        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    660658};
    661659
    … …  
    674672        virtual void accept( Visitor & v ) { v.visit( this ); }
    675673        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    676         virtual void print( std::ostream & os, int indent = 0 ) const;
     674        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    677675};
    678676
    … …  
    695693        virtual void accept( Visitor & v ) { v.visit( this ); }
    696694        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    697         virtual void print( std::ostream & os, int indent = 0 ) const;
     695        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    698696};
    699697
    … …  
    713711        virtual void accept( Visitor & v ) { v.visit( this ); }
    714712        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    715         virtual void print( std::ostream & os, int indent = 0 ) const;
     713        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    716714};
    717715
    … …  
    736734        virtual void accept( Visitor & v ) { v.visit( this ); }
    737735        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    738         virtual void print( std::ostream & os, int indent = 0 ) const;
     736        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    739737};
    740738
    … …  
    763761        virtual void accept( Visitor & v ) { v.visit( this ); }
    764762        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    765         virtual void print( std::ostream & os, int indent = 0 ) const;
     763        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    766764
    767765private:
    … …  
    797795        virtual void accept( Visitor & v ) { v.visit( this ); }
    798796        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    799         virtual void print( std::ostream & os, int indent = 0 ) const;
     797        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    800798};
    801799
    … …  
    818816        virtual void accept( Visitor & v ) { v.visit( this ); }
    819817        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    820         virtual void print( std::ostream & os, int indent = 0 ) const;
     818        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    821819};
    822820

  • src/SynTree/FunctionDecl.cc

    ra8555c5 r50377a4  
    6363}
    6464
    65 void FunctionDecl::print( std::ostream &os, int indent ) const {
     65void FunctionDecl::print( std::ostream &os, Indenter indent ) const {
    6666        using std::endl;
    6767        using std::string;
    6868
    69         if ( get_name() != "" ) {
    70                 os << get_name() << ": ";
     69        if ( name != "" ) {
     70                os << name << ": ";
    7171        } // if
    72         if ( get_linkage() != LinkageSpec::Cforall ) {
    73                 os << LinkageSpec::linkageName( get_linkage() ) << " ";
     72        if ( linkage != LinkageSpec::Cforall ) {
     73                os << LinkageSpec::linkageName( linkage ) << " ";
    7474        } // if
    7575
    76         printAll( get_attributes(), os, indent );
     76        printAll( attributes, os, indent );
    7777
    7878        get_storageClasses().print( os );
    7979        get_funcSpec().print( os );
    8080
    81         if ( get_type() ) {
    82                 get_type()->print( os, indent );
     81        if ( type ) {
     82                type->print( os, indent );
    8383        } else {
    8484                os << "untyped entity ";
    … …  
    8686
    8787        if ( statements ) {
    88                 os << string( indent + 2, ' ' ) << "with body " << endl;
    89                 os << string( indent + 4, ' ' );
    90                 statements->print( os, indent + 4 );
     88                os << indent << "... with body " << endl << indent+1;
     89                statements->print( os, indent+1 );
    9190        } // if
    9291}
    9392
    94 void FunctionDecl::printShort( std::ostream &os, int indent ) const {
     93void FunctionDecl::printShort( std::ostream &os, Indenter indent ) const {
    9594        using std::endl;
    9695        using std::string;
    9796
    98         if ( get_name() != "" ) {
    99                 os << get_name() << ": ";
     97        if ( name != "" ) {
     98                os << name << ": ";
    10099        } // if
    101 
    102         // xxx - should printShort print attributes?
    103100
    104101        get_storageClasses().print( os );
    105102        get_funcSpec().print( os );
    106103
    107         if ( get_type() ) {
    108                 get_type()->print( os, indent );
     104        if ( type ) {
     105                type->print( os, indent );
    109106        } else {
    110107                os << "untyped entity ";

  • src/SynTree/FunctionType.cc

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

  • src/SynTree/Initializer.cc

    ra8555c5 r50377a4  
    3838}
    3939
    40 void Designation::print( std::ostream &os, int indent ) const {
     40void Designation::print( std::ostream &os, Indenter indent ) const {
    4141        if ( ! designators.empty() ) {
    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 );
     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;
    4647                }
    47                 os << std::endl;
    4848        } // if
    4949}
    … …  
    6464}
    6565
    66 void 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 );
     66void SingleInit::print( std::ostream &os, Indenter indent ) const {
     67        os << "Simple Initializer: ";
     68        value->print( os, indent );
    7069}
    7170
    … …  
    9392}
    9493
    95 void 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 );
     94void 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 );
    103101                os << std::endl;
     102                if ( ! d->designators.empty() ) {
     103                        os << indent+1;
     104                        d->print( os, indent+1 );
     105                }
    104106        }
    105107}
    … …  
    116118}
    117119
    118 void ConstructorInit::print( std::ostream &os, int indent ) const {
    119         os << std::endl << std::string(indent, ' ') << "Constructor initializer: " << std::endl;
     120void ConstructorInit::print( std::ostream &os, Indenter indent ) const {
     121        os << "Constructor initializer: " << std::endl;
    120122        if ( ctor ) {
    121                 os << std::string(indent+2, ' ');
    122                 os << "initially constructed with ";
    123                 ctor->print( os, indent+4 );
     123                os << indent << "... initially constructed with ";
     124                ctor->print( os, indent+1 );
    124125        } // if
    125126
    126127        if ( dtor ) {
    127                 os << std::string(indent+2, ' ');
    128                 os << "destructed with ";
    129                 dtor->print( os, indent+4 );
     128                os << indent << "... destructed with ";
     129                dtor->print( os, indent+1 );
    130130        }
    131131
    132132        if ( init ) {
    133                 os << std::string(indent+2, ' ');
    134                 os << "with fallback C-style initializer: ";
    135                 init->print( os, indent+4 );
     133                os << indent << "... with fallback C-style initializer: ";
     134                init->print( os, indent+1 );
    136135        }
    137136}

  • src/SynTree/Initializer.h

    ra8555c5 r50377a4  
    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, int indent = 0 ) const override;
     42        virtual void print( std::ostream &os, Indenter indent = {} ) 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, int indent = 0 ) const override = 0;
     59        virtual void print( std::ostream &os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     80        virtual void print( std::ostream &os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     108        virtual void print( std::ostream &os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     137        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
    138138
    139139  private:

  • src/SynTree/NamedTypeDecl.cc

    ra8555c5 r50377a4  
    3838}
    3939
    40 void NamedTypeDecl::print( std::ostream &os, int indent ) const {
     40void NamedTypeDecl::print( std::ostream &os, Indenter indent ) const {
    4141        using namespace std;
    4242
    43         if ( get_name() != "" ) {
    44                 os << get_name() << ": ";
    45         } // if
    46         if ( get_linkage() != LinkageSpec::Cforall ) {
    47                 os << LinkageSpec::linkageName( get_linkage() ) << " ";
     43        if ( name != "" ) os << name << ": ";
     44
     45        if ( linkage != LinkageSpec::Cforall ) {
     46                os << LinkageSpec::linkageName( linkage ) << " ";
    4847        } // if
    4948        get_storageClasses().print( os );
    … …  
    5150        if ( base ) {
    5251                os << " for ";
    53                 base->print( os, indent );
     52                base->print( os, indent+1 );
    5453        } // if
    5554        if ( ! parameters.empty() ) {
    56                 os << endl << string( indent, ' ' ) << "with parameters" << endl;
    57                 printAll( parameters, os, indent+2 );
     55                os << endl << indent << "... with parameters" << endl;
     56                printAll( parameters, os, indent+1 );
    5857        } // if
    5958        if ( ! assertions.empty() ) {
    60                 os << endl << string( indent, ' ' ) << "with assertions" << endl;
    61                 printAll( assertions, os, indent+2 );
     59                os << endl << indent << "... with assertions" << endl;
     60                printAll( assertions, os, indent+1 );
    6261        } // if
    6362}
    6463
    65 void NamedTypeDecl::printShort( std::ostream &os, int indent ) const {
     64void NamedTypeDecl::printShort( std::ostream &os, Indenter indent ) const {
    6665        using namespace std;
    6766
    68         if ( get_name() != "" ) {
    69                 os << get_name() << ": ";
    70         } // if
     67        if ( name != "" ) os << name << ": ";
    7168        get_storageClasses().print( os );
    7269        os << typeString();
    7370        if ( base ) {
    7471                os << " for ";
    75                 base->print( os, indent );
     72                base->print( os, indent+1 );
    7673        } // if
    7774        if ( ! parameters.empty() ) {
    78                 os << endl << string( indent, ' ' ) << "with parameters" << endl;
    79                 printAll( parameters, os, indent+2 );
     75                os << endl << indent << "... with parameters" << endl;
     76                printAll( parameters, os, indent+1 );
    8077        } // if
    8178}

  • src/SynTree/ObjectDecl.cc

    ra8555c5 r50377a4  
    4444}
    4545
    46 void ObjectDecl::print( std::ostream &os, int indent ) const {
    47         if ( get_name() != "" ) {
    48                 os << get_name() << ": ";
     46void ObjectDecl::print( std::ostream &os, Indenter indent ) const {
     47        if ( name != "" ) os << name << ": ";
     48
     49        if ( linkage != LinkageSpec::Cforall ) {
     50                os << LinkageSpec::linkageName( linkage ) << " ";
    4951        } // if
    50 
    51         if ( get_linkage() != LinkageSpec::Cforall ) {
    52                 os << LinkageSpec::linkageName( get_linkage() ) << " ";
    53         } // if
    54 
    55         printAll( get_attributes(), os, indent );
    5652
    5753        get_storageClasses().print( os );
    5854
    59         if ( get_type() ) {
    60                 get_type()->print( os, indent );
     55        if ( type ) {
     56                type->print( os, indent );
    6157        } else {
    6258                os << " untyped entity ";
    … …  
    6460
    6561        if ( init ) {
    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();
     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;
    7065        } // if
    7166
     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 << std::string(indent, ' ');
    74                 os << " with bitfield width ";
     73                os << indent << " with bitfield width ";
    7574                bitfieldWidth->print( os );
    7675        } // if
    7776}
    7877
    79 void ObjectDecl::printShort( std::ostream &os, int indent ) const {
     78void ObjectDecl::printShort( std::ostream &os, Indenter indent ) const {
    8079#if 0
    8180        if ( get_mangleName() != "") {
    … …  
    8382        } else
    8483#endif
    85         if ( get_name() != "" ) {
    86                 os << get_name() << ": ";
    87         } // if
    88 
    89         // xxx - should printShort print attributes?
     84        if ( name != "" ) os << name << ": ";
    9085
    9186        get_storageClasses().print( os );
    9287
    93         if ( get_type() ) {
    94                 get_type()->print( os, indent );
     88        if ( type ) {
     89                type->print( os, indent );
    9590        } else {
    9691                os << "untyped entity ";

  • src/SynTree/PointerType.cc

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

  • src/SynTree/ReferenceToType.cc

    ra8555c5 r50377a4  
    1414//
    1515
    16 #include <stddef.h>          // for NULL
    1716#include <cassert>           // for assert
    1817#include <list>              // for list, _List_const_iterator, list<>::cons...
    … …  
    3837}
    3938
    40 void ReferenceToType::print( std::ostream &os, int indent ) const {
     39void ReferenceToType::print( std::ostream &os, Indenter indent ) const {
    4140        using std::endl;
    4241
    … …  
    4443        os << "instance of " << typeString() << " " << name << " ";
    4544        if ( ! parameters.empty() ) {
    46                 os << endl << std::string( indent, ' ' ) << "with parameters" << endl;
    47                 printAll( parameters, os, indent+2 );
     45                os << endl << indent << "... with parameters" << endl;
     46                printAll( parameters, os, indent+1 );
    4847        } // if
    4948}
    … …  
    6564
    6665std::list<TypeDecl*>* StructInstType::get_baseParameters() {
    67         if ( ! baseStruct ) return NULL;
     66        if ( ! baseStruct ) return nullptr;
    6867        return &baseStruct->get_parameters();
    6968}
    … …  
    7675}
    7776
    78 void StructInstType::print( std::ostream &os, int indent ) const {
     77void StructInstType::print( std::ostream &os, Indenter indent ) const {
    7978        using std::endl;
    8079
    81         if ( baseStruct == NULL ) ReferenceToType::print( os, indent );
     80        if ( baseStruct == nullptr ) ReferenceToType::print( os, indent );
    8281        else {
    8382                Type::print( os, indent );
    8483                os << "instance of " << typeString() << " " << name << " with body " << baseStruct->has_body() << " ";
    8584                if ( ! parameters.empty() ) {
    86                         os << endl << std::string( indent, ' ' ) << "with parameters" << endl;
    87                         printAll( parameters, os, indent+2 );
     85                        os << endl << indent << "... with parameters" << endl;
     86                        printAll( parameters, os, indent+1 );
    8887                } // if
    8988        } // if
    … …  
    9796
    9897std::list< TypeDecl * > * UnionInstType::get_baseParameters() {
    99         if ( ! baseUnion ) return NULL;
     98        if ( ! baseUnion ) return nullptr;
    10099        return &baseUnion->get_parameters();
    101100}
    … …  
    108107}
    109108
    110 void UnionInstType::print( std::ostream &os, int indent ) const {
     109void UnionInstType::print( std::ostream &os, Indenter indent ) const {
    111110        using std::endl;
    112111
    113         if ( baseUnion == NULL ) ReferenceToType::print( os, indent );
     112        if ( baseUnion == nullptr ) ReferenceToType::print( os, indent );
    114113        else {
    115114                Type::print( os, indent );
    116115                os << "instance of " << typeString() << " " << name << " with body " << baseUnion->has_body() << " ";
    117116                if ( ! parameters.empty() ) {
    118                         os << endl << std::string( indent, ' ' ) << "with parameters" << endl;
    119                         printAll( parameters, os, indent+2 );
     117                        os << endl << indent << "... with parameters" << endl;
     118                        printAll( parameters, os, indent+1 );
    120119                } // if
    121120        } // if
    … …  
    166165bool TypeInstType::isComplete() const { return baseType->isComplete(); }
    167166
    168 void TypeInstType::print( std::ostream &os, int indent ) const {
     167void TypeInstType::print( std::ostream &os, Indenter indent ) const {
    169168        using std::endl;
    170169
    … …  
    172171        os << "instance of " << typeString() << " " << get_name() << " (" << ( isFtype ? "" : "not" ) << " function type) ";
    173172        if ( ! parameters.empty() ) {
    174                 os << endl << std::string( indent, ' ' ) << "with parameters" << endl;
    175                 printAll( parameters, os, indent+2 );
     173                os << endl << indent << "... with parameters" << endl;
     174                printAll( parameters, os, indent+1 );
    176175        } // if
    177176}

  • src/SynTree/ReferenceType.cc

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

  • src/SynTree/Statement.cc

    ra8555c5 r50377a4  
    3434Statement::Statement( std::list<Label> labels ) : labels( labels ) {}
    3535
    36 void Statement::print( __attribute__((unused)) std::ostream &, __attribute__((unused)) int indent ) const {}
     36void 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}
    3745
    3846Statement::~Statement() {}
    … …  
    4654}
    4755
    48 void ExprStmt::print( std::ostream &os, int indent ) const {
    49         os << "Expression Statement:" << endl << std::string( indent + 2, ' ' );
    50         expr->print( os, indent + 2 );
     56void ExprStmt::print( std::ostream &os, Indenter indent ) const {
     57        os << "Expression Statement:" << endl << indent+1;
     58        expr->print( os, indent+1 );
    5159}
    5260
    … …  
    6775}
    6876
    69 void AsmStmt::print( std::ostream &os, int indent ) const {
     77void AsmStmt::print( std::ostream &os, Indenter indent ) const {
    7078        os << "Assembler Statement:" << endl;
    71         os << std::string( indent, ' ' ) << "instruction: " << endl << std::string( indent, ' ' );
    72         instruction->print( os, indent + 2 );
     79        os << indent+1 << "instruction: " << endl << indent;
     80        instruction->print( os, indent+1 );
    7381        if ( ! output.empty() ) {
    74                 os << endl << std::string( indent, ' ' ) << "output: " << endl;
    75                 printAll( output, os, indent + 2 );
     82                os << endl << indent+1 << "output: " << endl;
     83                printAll( output, os, indent+1 );
    7684        } // if
    7785        if ( ! input.empty() ) {
    78                 os << std::string( indent, ' ' ) << "input: " << endl << std::string( indent, ' ' );
    79                 printAll( input, os, indent + 2 );
     86                os << indent+1 << "input: " << endl;
     87                printAll( input, os, indent+1 );
    8088        } // if
    8189        if ( ! clobber.empty() ) {
    82                 os << std::string( indent, ' ' ) << "clobber: " << endl;
    83                 printAll( clobber, os, indent + 2 );
     90                os << indent+1 << "clobber: " << endl;
     91                printAll( clobber, os, indent+1 );
    8492        } // if
    8593}
    … …  
    103111}
    104112
    105 void 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;
     113void 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;
    110118}
    111119
    … …  
    118126}
    119127
    120 void 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 );
     128void 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 );
    125133        }
    126134        os << endl;
    … …  
    142150}
    143151
    144 void 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 );
     152void IfStmt::print( std::ostream &os, Indenter indent ) const {
     153        os << "If on condition: " << endl;
     154        os << indent+1;
     155        condition->print( os, indent+1 );
    148156
    149157        if ( !initialization.empty() ) {
    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 );
     158                os << indent << "... with initialization: \n";
     159                for ( const Statement * stmt : initialization ) {
     160                        os << indent+1;
     161                        stmt->print( os, indent+1 );
    154162                }
    155163                os << endl;
    156164        }
    157165
    158         os << string( indent+2, ' ' ) << "... then: " << endl;
    159 
    160         os << string( indent+4, ' ' );
    161         thenPart->print( os, indent + 4 );
     166        os << indent << "... then: " << endl;
     167
     168        os << indent+1;
     169        thenPart->print( os, indent+1 );
    162170
    163171        if ( elsePart != 0 ) {
    164                 os << string( indent+2, ' ' ) << "... else: " << endl;
    165                 os << string( indent+4, ' ' );
    166                 elsePart->print( os, indent + 4 );
     172                os << indent << "... else: " << endl;
     173                os << indent+1;
     174                elsePart->print( os, indent+1 );
    167175        } // if
    168176}
    … …  
    183191}
    184192
    185 void SwitchStmt::print( std::ostream &os, int indent ) const {
     193void SwitchStmt::print( std::ostream &os, Indenter indent ) const {
    186194        os << "Switch on condition: ";
    187195        condition->print( os );
    188196        os << endl;
    189197
    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 ));
     198        for ( const Statement * stmt : statements ) {
     199                stmt->print( os, indent+1 );
     200        }
    196201}
    197202
    198203CaseStmt::CaseStmt( std::list<Label> labels, Expression *condition, const std::list<Statement *> &statements, bool deflt ) throw ( SemanticError ) :
    199204        Statement( labels ), condition( condition ), stmts( statements ), _isDefault( deflt ) {
    200         if ( isDefault() && condition != 0 )
    201                 throw SemanticError("default with conditions");
     205        if ( isDefault() && condition != 0 ) throw SemanticError("default case with condition: ", condition);
    202206}
    203207
    … …  
    216220}
    217221
    218 void CaseStmt::print( std::ostream &os, int indent ) const {
    219         os << string( indent, ' ' );
    220 
    221         if ( isDefault() )
    222                 os << "Default ";
     222void CaseStmt::print( std::ostream &os, Indenter indent ) const {
     223        if ( isDefault() ) os << "Default ";
    223224        else {
    224225                os << "Case ";
    225                 condition->print( os );
    226         } // if
    227 
    228         os << endl;
    229 
    230         std::list<Statement *>::const_iterator i;
    231         for ( i = stmts.begin(); i != stmts.end(); i++)
    232                 (*i )->print( os, indent + 4 );
     226                condition->print( os, indent );
     227        } // if
     228        os << endl;
     229
     230        for ( Statement * stmt : stmts ) {
     231                stmt->print( os, indent+1 );
     232        }
    233233}
    234234
    … …  
    246246}
    247247
    248 void WhileStmt::print( std::ostream &os, int indent ) const {
     248void WhileStmt::print( std::ostream &os, Indenter indent ) const {
    249249        os << "While on condition: " << endl ;
    250         condition->print( os, indent + 4 );
    251 
    252         os << string( indent, ' ' ) << ".... with body: " << endl;
    253 
    254         if ( body != 0 ) body->print( os, indent + 4 );
     250        condition->print( os, indent+1 );
     251
     252        os << indent << "... with body: " << endl;
     253
     254        if ( body != 0 ) body->print( os, indent+1 );
    255255}
    256256
    … …  
    272272}
    273273
    274 void 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";
     274void 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
    302297        if ( body != 0 ) {
    303                 os << string( indent + 4, ' ' );
    304                 body->print( os, indent + 4 );
    305         }
    306 
     298                os << "\n" << indent << "... with body: \n" << indent+1;
     299                body->print( os, indent+1 );
     300        }
    307301        os << endl;
    308302}
    … …  
    322316}
    323317
    324 void ThrowStmt::print( std::ostream &os, int indent) const {
     318void ThrowStmt::print( std::ostream &os, Indenter indent) const {
     319        if ( target ) os << "Non-Local ";
     320        os << "Throw Statement, raising: ";
     321        expr->print(os, indent+1);
    325322        if ( target ) {
    326                 os << "Non-Local ";
    327         }
    328         os << "Throw Statement, raising: ";
    329         expr->print(os, indent + 4);
    330         if ( target ) {
    331                 os << "At: ";
    332                 target->print(os, indent + 4);
     323                os << "... at: ";
     324                target->print(os, indent+1);
    333325        }
    334326}
    … …  
    348340}
    349341
    350 void TryStmt::print( std::ostream &os, int indent ) const {
     342void TryStmt::print( std::ostream &os, Indenter indent ) const {
    351343        os << "Try Statement" << endl;
    352         os << string( indent + 2, ' ' ) << "with block:" << endl;
    353         os << string( indent + 4, ' ' );
    354         block->print( os, indent + 4 );
     344        os << indent << "... with block:" << endl << indent+1;
     345        block->print( os, indent+1 );
    355346
    356347        // handlers
    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 );
     348        os << indent << "... and handlers:" << endl;
     349        for ( const CatchStmt * stmt : handlers ) {
     350                os << indent+1;
     351                stmt->print( os, indent+1 );
    361352        }
    362353
    363354        // finally block
    364355        if ( finallyBlock != 0 ) {
    365                 os << string( indent + 2, ' ' ) << "and finally:" << endl;
    366                 finallyBlock->print( os, indent + 4 );
     356                os << indent << "... and finally:" << endl << indent+1;
     357                finallyBlock->print( os, indent+1 );
    367358        } // if
    368359}
    … …  
    370361CatchStmt::CatchStmt( std::list<Label> labels, Kind kind, Declaration *decl, Expression *cond, Statement *body ) :
    371362        Statement( labels ), kind ( kind ), decl ( decl ), cond ( cond ), body( body ) {
     363                assertf( decl, "Catch clause must have a declaration." );
    372364}
    373365
    … …  
    381373}
    382374
    383 void CatchStmt::print( std::ostream &os, int indent ) const {
     375void CatchStmt::print( std::ostream &os, Indenter indent ) const {
    384376        os << "Catch " << ((Terminate == kind) ? "Terminate" : "Resume") << " Statement" << endl;
    385377
    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;
     378        os << indent << "... catching: ";
     379        decl->printShort( os, indent+1 );
     380        os << endl;
    393381
    394382        if ( cond ) {
    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 );
     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 );
    405390}
    406391
    … …  
    417402}
    418403
    419 void FinallyStmt::print( std::ostream &os, int indent ) const {
     404void FinallyStmt::print( std::ostream &os, Indenter indent ) const {
    420405        os << "Finally Statement" << endl;
    421         os << string( indent + 2, ' ' ) << "with block:" << endl;
    422         os << string( indent + 4, ' ' );
    423         block->print( os, indent + 4 );
     406        os << indent << "... with block:" << endl << indent+1;
     407        block->print( os, indent+1 );
    424408}
    425409
    … …  
    465449}
    466450
    467 void WaitForStmt::print( std::ostream &os, int indent ) const {
     451void WaitForStmt::print( std::ostream &os, Indenter indent ) const {
    468452        os << "Waitfor Statement" << endl;
    469         os << string( indent + 2, ' ' ) << "with block:" << endl;
    470         os << string( indent + 4, ' ' );
     453        os << indent << "... with block:" << endl << indent+1;
    471454        // block->print( os, indent + 4 );
    472455}
    … …  
    475458NullStmt::NullStmt() : Statement( std::list<Label>() ) {}
    476459
    477 void NullStmt::print( std::ostream &os, __attribute__((unused)) int indent ) const {
    478         os << "Null Statement" << endl ;
     460void NullStmt::print( std::ostream &os, Indenter ) const {
     461        os << "Null Statement" << endl;
    479462}
    480463
    … …  
    490473}
    491474
    492 void ImplicitCtorDtorStmt::print( std::ostream &os, int indent ) const {
     475void ImplicitCtorDtorStmt::print( std::ostream &os, Indenter indent ) const {
    493476        os << "Implicit Ctor Dtor Statement" << endl;
    494         os << string( indent + 2, ' ' ) << "with Ctor/Dtor: ";
    495         callStmt->print( os, indent + 2);
     477        os << indent << "... with Ctor/Dtor: ";
     478        callStmt->print( os, indent+1);
    496479        os << endl;
    497480}

  • src/SynTree/Statement.h

    ra8555c5 r50377a4  
    4646        virtual void accept( Visitor &v ) override = 0;
    4747        virtual Statement *acceptMutator( Mutator &m ) override = 0;
    48         virtual void print( std::ostream &os, int indent = 0 ) const override;
     48        virtual void print( std::ostream &os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     67        virtual void print( std::ostream &os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     78        virtual void print( std::ostream &os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     95        virtual void print( std::ostream &os, Indenter indent = {} ) 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, int indent = 0 ) const;
     126        virtual void print( std::ostream & os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     152        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
    153153};
    154154
    … …  
    171171
    172172        virtual SwitchStmt *clone() const override { return new SwitchStmt( *this ); }
    173         virtual void print( std::ostream &os, int indent = 0 ) const override;
     173        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
    174174
    175175};
    … …  
    199199
    200200        virtual CaseStmt *clone() const override { return new CaseStmt( *this ); }
    201         virtual void print( std::ostream &os, int indent = 0 ) const override;
     201        virtual void print( std::ostream &os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     227        virtual void print( std::ostream &os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     253        virtual void print( std::ostream &os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     282        virtual void print( std::ostream &os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     301        virtual void print( std::ostream &os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     325        virtual void print( std::ostream &os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     348        virtual void print( std::ostream &os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     376        virtual void print( std::ostream &os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     393        virtual void print( std::ostream &os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     430        virtual void print( std::ostream &os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     450        virtual void print( std::ostream &os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     472        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
    473473};
    474474

  • src/SynTree/TupleExpr.cc

    ra8555c5 r50377a4  
    3939}
    4040
    41 void UntypedTupleExpr::print( std::ostream &os, int indent ) const {
     41void UntypedTupleExpr::print( std::ostream &os, Indenter indent ) const {
    4242        os << "Untyped Tuple:" << std::endl;
    43         printAll( exprs, os, indent+2 );
     43        printAll( exprs, os, indent+1 );
    4444        Expression::print( os, indent );
    4545}
    … …  
    5757}
    5858
    59 void TupleExpr::print( std::ostream &os, int indent ) const {
     59void TupleExpr::print( std::ostream &os, Indenter indent ) const {
    6060        os << "Tuple:" << std::endl;
    61         printAll( exprs, os, indent+2 );
     61        printAll( exprs, os, indent+1 );
    6262        Expression::print( os, indent );
    6363}
    … …  
    7878}
    7979
    80 void TupleIndexExpr::print( std::ostream &os, int indent ) const {
     80void TupleIndexExpr::print( std::ostream &os, Indenter indent ) const {
    8181        os << "Tuple Index Expression, with tuple:" << 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;
     82        os << indent+1;
     83        tuple->print( os, indent+1 );
     84        os << indent+1 << "with index: " << index << std::endl;
    8585        Expression::print( os, indent );
    8686}
    … …  
    109109}
    110110
    111 void TupleAssignExpr::print( std::ostream &os, int indent ) const {
     111void TupleAssignExpr::print( std::ostream &os, Indenter indent ) const {
    112112        os << "Tuple Assignment Expression, with stmt expr:" << std::endl;
    113         os << std::string( indent+2, ' ' );
    114         stmtExpr->print( os, indent+4 );
     113        os << indent+1;
     114        stmtExpr->print( os, indent+1 );
    115115        Expression::print( os, indent );
    116116}

  • src/SynTree/TupleType.cc

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

  • src/SynTree/Type.cc

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

  • src/SynTree/Type.h

    ra8555c5 r50377a4  
    181181        virtual void accept( Visitor & v ) = 0;
    182182        virtual Type *acceptMutator( Mutator & m ) = 0;
    183         virtual void print( std::ostream & os, int indent = 0 ) const;
     183        virtual void print( std::ostream & os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     200        virtual void print( std::ostream & os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     242        virtual void print( std::ostream & os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     277        virtual void print( std::ostream & os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     305        virtual void print( std::ostream & os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     329        virtual void print( std::ostream & os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     356        virtual void print( std::ostream & os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     378        virtual void print( std::ostream & os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     412        virtual void print( std::ostream & os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     444        virtual void print( std::ostream & os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     516        virtual void print( std::ostream & os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     553        virtual void print( std::ostream & os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     572        virtual void print( std::ostream & os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     601        virtual void print( std::ostream & os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     615        virtual void print( std::ostream & os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     627        virtual void print( std::ostream & os, Indenter indent = {} ) 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, int indent = 0 ) const override;
     639        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    640640};
    641641

  • src/SynTree/TypeDecl.cc

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

  • src/SynTree/TypeExpr.cc

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

  • src/SynTree/TypeSubstitution.cc

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

  • src/SynTree/TypeSubstitution.h

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

  • src/SynTree/TypeofType.cc

    ra8555c5 r50377a4  
    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, int indent ) const {
     35void TypeofType::print( std::ostream &os, Indenter indent ) const {
    3636        Type::print( os, indent );
    3737        os << "type-of expression ";

  • src/SynTree/VarArgsType.cc

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

  • src/SynTree/VoidType.cc

    ra8555c5 r50377a4  
    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, int indent ) const {
     26void VoidType::print( std::ostream &os, Indenter indent ) const {
    2727        Type::print( os, indent );
    2828        os << "void ";

  • src/SynTree/ZeroOneType.cc

    ra8555c5 r50377a4  
    2525ZeroType::ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes ) : Type( tq, attributes ) {}
    2626
    27 void ZeroType::print( std::ostream &os, __attribute__((unused)) int indent ) const {
     27void ZeroType::print( std::ostream &os, Indenter ) 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, __attribute__((unused)) int indent ) const {
     35void OneType::print( std::ostream &os, Indenter ) const {
    3636        os << "one_t";
    3737}

  • src/tests/.expect/castError.txt

    ra8555c5 r50377a4  
    1 castError.c:7:1 error: Cannot choose between 3 alternatives for expression Cast of:
     1castError.c:7:1 error: Cannot choose between 3 alternatives for expression
     2Cast of:
    23  Name: f
     4... to:
     5  charAlternatives are:
     6Cost ( 1, 0, 0, 0 ): Cast of:
     7     Variable Expression: f: function
     8       accepting unspecified arguments
     9     ... returning nothing
    310
    4 to:
    5   char
    6 Alternatives are:        Cost ( 1, 0, 0, 0 ): Cast of:
    7           Variable Expression: f: function
    8                 accepting unspecified arguments
    9               returning
    10                 nothing
     11   ... to:
     12     char
     13 (types:
     14   char
     15 )
     16 Environment:
     17
     18Cost ( 1, 0, 0, 0 ): Cast of:
     19     Variable Expression: f: signed int
     20   ... to:
     21     char
     22 (types:
     23   char
     24 )
     25 Environment:
     26
     27Cost ( 1, 0, 0, 0 ): Cast of:
     28     Variable Expression: f: double
     29   ... to:
     30     char
     31 (types:
     32   char
     33 )
     34 Environment:
    1135
    1236
    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

    ra8555c5 r50377a4  
    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:       Attribute with name: unused
    7 double
    8   with body
    9     CompoundStmt
     3... with parameters
     4  double
     5... returning
     6  _retval_butThisIsAnError: double
     7  ... with attributes:
     8    Attribute with name: unused
    109
     10... with body
     11  CompoundStmt
     12
Note: See TracChangeset for help on using the changeset viewer.