Changeset 3b0bc16


Ignore:
Timestamp:
Feb 1, 2022, 8:22:12 PM (8 months ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
enum, forall-pointer-decay, master, pthread-emulation, qualifiedEnum
Children:
fde0a58
Parents:
729c991
Message:

change class name WhileStmt? to WhileDoStmt?, add else clause to WhileDoStmt? and ForStmt?, change names thenPart/ElsePart to then/else_

Location:
src
Files:
29 edited

Legend:

Unmodified
Added
Removed
  • src/AST/Convert.cpp

    r729c991 r3b0bc16  
    99// Author           : Thierry Delisle
    1010// Created On       : Thu May 09 15::37::05 2019
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Wed Jul 14 16:15:00 2021
    13 // Update Count     : 37
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Tue Feb  1 16:27:15 2022
     13// Update Count     : 39
    1414//
    1515
     
    393393                auto stmt = new IfStmt(
    394394                        get<Expression>().accept1( node->cond ),
    395                         get<Statement>().accept1( node->thenPart ),
    396                         get<Statement>().accept1( node->elsePart ),
     395                        get<Statement>().accept1( node->then ),
     396                        get<Statement>().accept1( node->else_ ),
    397397                        get<Statement>().acceptL( node->inits )
    398398                );
     
    419419        }
    420420
    421         const ast::Stmt * visit( const ast::WhileStmt * node ) override final {
     421        const ast::Stmt * visit( const ast::WhileDoStmt * node ) override final {
    422422                if ( inCache( node ) ) return nullptr;
    423423                auto inits = get<Statement>().acceptL( node->inits );
    424                 auto stmt = new WhileStmt(
     424                auto stmt = new WhileDoStmt(
    425425                        get<Expression>().accept1( node->cond ),
    426426                        get<Statement>().accept1( node->body ),
     
    18721872                        old->location,
    18731873                        GET_ACCEPT_1(condition, Expr),
    1874                         GET_ACCEPT_1(thenPart, Stmt),
    1875                         GET_ACCEPT_1(elsePart, Stmt),
     1874                        GET_ACCEPT_1(then, Stmt),
     1875                        GET_ACCEPT_1(else_, Stmt),
    18761876                        GET_ACCEPT_V(initialization, Stmt),
    18771877                        GET_LABELS_V(old->labels)
     
    19021902        }
    19031903
    1904         virtual void visit( const WhileStmt * old ) override final {
     1904        virtual void visit( const WhileDoStmt * old ) override final {
    19051905                if ( inCache( old ) ) return;
    1906                 this->node = new ast::WhileStmt(
     1906                this->node = new ast::WhileDoStmt(
    19071907                        old->location,
    19081908                        GET_ACCEPT_1(condition, Expr),
  • src/AST/Fwd.hpp

    r729c991 r3b0bc16  
    1010// Created On       : Wed May  8 16:05:00 2019
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar 12 18:37:39 2021
    13 // Update Count     : 4
     12// Last Modified On : Tue Feb  1 09:08:33 2022
     13// Update Count     : 5
    1414//
    1515
     
    4444class DirectiveStmt;
    4545class IfStmt;
    46 class WhileStmt;
     46class WhileDoStmt;
    4747class ForStmt;
    4848class SwitchStmt;
  • src/AST/Node.cpp

    r729c991 r3b0bc16  
    1010// Created On       : Thu May 16 14:16:00 2019
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar 12 18:25:06 2021
    13 // Update Count     : 2
     12// Last Modified On : Tue Feb  1 09:09:39 2022
     13// Update Count     : 3
    1414//
    1515
     
    146146template class ast::ptr_base< ast::IfStmt, ast::Node::ref_type::weak >;
    147147template class ast::ptr_base< ast::IfStmt, ast::Node::ref_type::strong >;
    148 template class ast::ptr_base< ast::WhileStmt, ast::Node::ref_type::weak >;
    149 template class ast::ptr_base< ast::WhileStmt, ast::Node::ref_type::strong >;
     148template class ast::ptr_base< ast::WhileDoStmt, ast::Node::ref_type::weak >;
     149template class ast::ptr_base< ast::WhileDoStmt, ast::Node::ref_type::strong >;
    150150template class ast::ptr_base< ast::ForStmt, ast::Node::ref_type::weak >;
    151151template class ast::ptr_base< ast::ForStmt, ast::Node::ref_type::strong >;
  • src/AST/Pass.hpp

    r729c991 r3b0bc16  
    146146        const ast::Stmt *             visit( const ast::DirectiveStmt        * ) override final;
    147147        const ast::Stmt *             visit( const ast::IfStmt               * ) override final;
    148         const ast::Stmt *             visit( const ast::WhileStmt            * ) override final;
     148        const ast::Stmt *             visit( const ast::WhileDoStmt          * ) override final;
    149149        const ast::Stmt *             visit( const ast::ForStmt              * ) override final;
    150150        const ast::Stmt *             visit( const ast::SwitchStmt           * ) override final;
  • src/AST/Pass.impl.hpp

    r729c991 r3b0bc16  
    756756                maybe_accept( node, &IfStmt::inits    );
    757757                maybe_accept( node, &IfStmt::cond     );
    758                 maybe_accept_as_compound( node, &IfStmt::thenPart );
    759                 maybe_accept_as_compound( node, &IfStmt::elsePart );
     758                maybe_accept_as_compound( node, &IfStmt::then );
     759                maybe_accept_as_compound( node, &IfStmt::else_ );
    760760        }
    761761
     
    764764
    765765//--------------------------------------------------------------------------
    766 // WhileStmt
    767 template< typename core_t >
    768 const ast::Stmt * ast::Pass< core_t >::visit( const ast::WhileStmt * node ) {
     766// WhileDoStmt
     767template< typename core_t >
     768const ast::Stmt * ast::Pass< core_t >::visit( const ast::WhileDoStmt * node ) {
    769769        VISIT_START( node );
    770770
     
    772772                // while statements introduce a level of scope (for the initialization)
    773773                guard_symtab guard { *this };
    774                 maybe_accept( node, &WhileStmt::inits );
    775                 maybe_accept( node, &WhileStmt::cond  );
    776                 maybe_accept_as_compound( node, &WhileStmt::body  );
     774                maybe_accept( node, &WhileDoStmt::inits );
     775                maybe_accept( node, &WhileDoStmt::cond  );
     776                maybe_accept_as_compound( node, &WhileDoStmt::body  );
    777777        }
    778778
  • src/AST/Print.cpp

    r729c991 r3b0bc16  
    511511                ++indent;
    512512                os << indent;
    513                 safe_print( node->thenPart );
    514                 --indent;
    515 
    516                 if ( node->elsePart != 0 ) {
     513                safe_print( node->then );
     514                --indent;
     515
     516                if ( node->else_ != 0 ) {
    517517                        os << indent << "... else:" << endl;
    518518                        ++indent;
    519519                        os << indent;
    520                         node->elsePart->accept( *this );
     520                        node->else_->accept( *this );
    521521                        --indent;
    522522                } // if
     
    524524        }
    525525
    526         virtual const ast::Stmt * visit( const ast::WhileStmt * node ) override final {
     526        virtual const ast::Stmt * visit( const ast::WhileDoStmt * node ) override final {
    527527                if ( node->isDoWhile ) { os << "Do-"; }
    528528                os << "While on condition:" << endl;
  • src/AST/Stmt.hpp

    r729c991 r3b0bc16  
    1010// Created On       : Wed May  8 13:00:00 2019
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Jan 31 22:38:53 2022
    13 // Update Count     : 12
     12// Last Modified On : Tue Feb  1 17:44:46 2022
     13// Update Count     : 24
    1414//
    1515
     
    4242                : ParseNode(loc), labels(std::move(labels)) {}
    4343
    44         Stmt(const Stmt& o) : ParseNode(o), labels(o.labels) {}
     44        Stmt(const Stmt & o) : ParseNode(o), labels(o.labels) {}
    4545
    4646        const Stmt * accept( Visitor & v ) const override = 0;
     
    5656
    5757        CompoundStmt(const CodeLocation & loc, std::list<ptr<Stmt>> && ks = {},
    58                                  std::vector<Label>&& labels = {} )
     58                                 std::vector<Label> && labels = {} )
    5959                : Stmt(loc, std::move(labels)), kids(std::move(ks)) {}
    6060
    61         CompoundStmt( const CompoundStmt& o );
    62         CompoundStmt( CompoundStmt&& o ) = default;
     61        CompoundStmt( const CompoundStmt & o );
     62        CompoundStmt( CompoundStmt && o ) = default;
    6363
    6464        void push_back( const Stmt * s ) { kids.emplace_back( s ); }
     
    8888        ptr<Expr> expr;
    8989
    90         ExprStmt( const CodeLocation& loc, const Expr* e, std::vector<Label>&& labels = {} )
     90        ExprStmt( const CodeLocation & loc, const Expr* e, std::vector<Label> && labels = {} )
    9191                : Stmt(loc, std::move(labels)), expr(e) {}
    9292
     
    139139  public:
    140140        ptr<Expr> cond;
    141         ptr<Stmt> thenPart;
    142         ptr<Stmt> elsePart;
     141        ptr<Stmt> then;
     142        ptr<Stmt> else_;
    143143        std::vector<ptr<Stmt>> inits;
    144144
    145         IfStmt( const CodeLocation & loc, const Expr * cond, const Stmt * thenPart,
    146                         const Stmt * elsePart = nullptr, std::vector<ptr<Stmt>> && inits = {},
     145        IfStmt( const CodeLocation & loc, const Expr * cond, const Stmt * then,
     146                        const Stmt * else_ = nullptr, std::vector<ptr<Stmt>> && inits = {},
    147147                        std::vector<Label> && labels = {} )
    148                 : Stmt(loc, std::move(labels)), cond(cond), thenPart(thenPart), elsePart(elsePart),
     148                : Stmt(loc, std::move(labels)), cond(cond), then(then), else_(else_),
    149149                  inits(std::move(inits)) {}
    150150
     
    191191
    192192// While loop: while (...) ... else ... or do ... while (...) else ...;
    193 class WhileStmt final : public Stmt {
     193class WhileDoStmt final : public Stmt {
    194194  public:
    195195        ptr<Expr> cond;
    196196        ptr<Stmt> body;
    197         ptr<Stmt> elsePart;
     197        ptr<Stmt> else_;
    198198        std::vector<ptr<Stmt>> inits;
    199199        bool isDoWhile;
    200200
    201         WhileStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body,
     201        WhileDoStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body,
    202202                           std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, std::vector<Label> && labels = {} )
    203                 : Stmt(loc, std::move(labels)), cond(cond), body(body), inits(std::move(inits)), isDoWhile(isDoWhile) {}
    204 
    205         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    206   private:
    207         WhileStmt * clone() const override { return new WhileStmt{ *this }; }
     203                : Stmt(loc, std::move(labels)), cond(cond), body(body), else_(nullptr), inits(std::move(inits)), isDoWhile(isDoWhile) {}
     204
     205        WhileDoStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body, const Stmt * else_,
     206                           std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, std::vector<Label> && labels = {} )
     207                : Stmt(loc, std::move(labels)), cond(cond), body(body), else_(else_), inits(std::move(inits)), isDoWhile(isDoWhile) {}
     208
     209        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     210  private:
     211        WhileDoStmt * clone() const override { return new WhileDoStmt{ *this }; }
    208212        MUTATE_FRIEND
    209213};
     
    216220        ptr<Expr> inc;
    217221        ptr<Stmt> body;
    218         ptr<Stmt> elsePart;
     222        ptr<Stmt> else_;
    219223
    220224        ForStmt( const CodeLocation & loc, std::vector<ptr<Stmt>> && inits, const Expr * cond,
    221                          const Expr * inc, const Stmt * body, std::vector<Label> && labels = {} )
    222                 : Stmt(loc, std::move(labels)), inits(std::move(inits)), cond(cond), inc(inc), body(body) {}
     225                         const Expr * inc, const Stmt * body, std::vector<Label> && label = {} )
     226                : Stmt(loc, std::move(label)), inits(std::move(inits)), cond(cond), inc(inc), body(body), else_(nullptr) {}
     227
     228        ForStmt( const CodeLocation & loc, std::vector<ptr<Stmt>> && inits, const Expr * cond,
     229                         const Expr * inc, const Stmt * body, const Stmt * else_, std::vector<Label> && labels = {} )
     230                : Stmt(loc, std::move(labels)), inits(std::move(inits)), cond(cond), inc(inc), body(body), else_(else_) {}
    223231
    224232        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
  • src/AST/Visitor.hpp

    r729c991 r3b0bc16  
    1010// Created On       : Thr May 9 15:28:00 2019
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar 12 18:25:07 2021
    13 // Update Count     : 1
     12// Last Modified On : Tue Feb  1 09:09:34 2022
     13// Update Count     : 2
    1414//
    1515
     
    3838    virtual const ast::Stmt *             visit( const ast::DirectiveStmt        * ) = 0;
    3939    virtual const ast::Stmt *             visit( const ast::IfStmt               * ) = 0;
    40     virtual const ast::Stmt *             visit( const ast::WhileStmt            * ) = 0;
     40    virtual const ast::Stmt *             visit( const ast::WhileDoStmt          * ) = 0;
    4141    virtual const ast::Stmt *             visit( const ast::ForStmt              * ) = 0;
    4242    virtual const ast::Stmt *             visit( const ast::SwitchStmt           * ) = 0;
  • src/CodeGen/CodeGenerator.cc

    r729c991 r3b0bc16  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar 12 19:00:42 2021
    13 // Update Count     : 536
     12// Last Modified On : Tue Feb  1 16:29:25 2022
     13// Update Count     : 540
    1414//
    1515#include "CodeGenerator.h"
     
    4242        bool wantSpacing( Statement * stmt) {
    4343                return dynamic_cast< IfStmt * >( stmt ) || dynamic_cast< CompoundStmt * >( stmt ) ||
    44                         dynamic_cast< WhileStmt * >( stmt ) || dynamic_cast< ForStmt * >( stmt ) || dynamic_cast< SwitchStmt *>( stmt );
     44                        dynamic_cast< WhileDoStmt * >( stmt ) || dynamic_cast< ForStmt * >( stmt ) || dynamic_cast< SwitchStmt *>( stmt );
    4545        }
    4646
     
    955955                output << " ) ";
    956956
    957                 ifStmt->get_thenPart()->accept( *visitor );
    958 
    959                 if ( ifStmt->get_elsePart() != 0) {
     957                ifStmt->get_then()->accept( *visitor );
     958
     959                if ( ifStmt->get_else() != 0) {
    960960                        output << " else ";
    961                         ifStmt->get_elsePart()->accept( *visitor );
     961                        ifStmt->get_else()->accept( *visitor );
    962962                } // if
    963963        }
     
    11251125        }
    11261126
    1127         void CodeGenerator::postvisit( WhileStmt * whileStmt ) {
    1128                 if ( whileStmt->get_isDoWhile() ) {
     1127        void CodeGenerator::postvisit( WhileDoStmt * whileDoStmt ) {
     1128                if ( whileDoStmt->get_isDoWhile() ) {
    11291129                        output << "do";
    11301130                } else {
    11311131                        output << "while (";
    1132                         whileStmt->get_condition()->accept( *visitor );
     1132                        whileDoStmt->get_condition()->accept( *visitor );
    11331133                        output << ")";
    11341134                } // if
    11351135                output << " ";
    11361136
    1137                 output << CodeGenerator::printLabels( whileStmt->get_body()->get_labels() );
    1138                 whileStmt->get_body()->accept( *visitor );
     1137                output << CodeGenerator::printLabels( whileDoStmt->get_body()->get_labels() );
     1138                whileDoStmt->get_body()->accept( *visitor );
    11391139
    11401140                output << indent;
    11411141
    1142                 if ( whileStmt->get_isDoWhile() ) {
     1142                if ( whileDoStmt->get_isDoWhile() ) {
    11431143                        output << " while (";
    1144                         whileStmt->get_condition()->accept( *visitor );
     1144                        whileDoStmt->get_condition()->accept( *visitor );
    11451145                        output << ");";
    11461146                } // if
  • src/CodeGen/CodeGenerator.h

    r729c991 r3b0bc16  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar 12 18:35:38 2021
    13 // Update Count     : 63
     12// Last Modified On : Tue Feb  1 09:23:21 2022
     13// Update Count     : 64
    1414//
    1515
     
    116116                void postvisit( WaitForStmt * );
    117117                void postvisit( WithStmt * );
    118                 void postvisit( WhileStmt * );
     118                void postvisit( WhileDoStmt * );
    119119                void postvisit( ForStmt * );
    120120                void postvisit( NullStmt * );
  • src/Common/CodeLocationTools.cpp

    r729c991 r3b0bc16  
    1010// Created On       : Fri Dec  4 15:42:00 2020
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar 12 18:35:37 2021
    13 // Update Count     : 2
     12// Last Modified On : Tue Feb  1 09:14:39 2022
     13// Update Count     : 3
    1414//
    1515
     
    109109    macro(DirectiveStmt, Stmt) \
    110110    macro(IfStmt, Stmt) \
    111     macro(WhileStmt, Stmt) \
     111    macro(WhileDoStmt, Stmt) \
    112112    macro(ForStmt, Stmt) \
    113113    macro(SwitchStmt, Stmt) \
  • src/Common/PassVisitor.h

    r729c991 r3b0bc16  
    9292        virtual void visit( IfStmt * ifStmt ) override final;
    9393        virtual void visit( const IfStmt * ifStmt ) override final;
    94         virtual void visit( WhileStmt * whileStmt ) override final;
    95         virtual void visit( const WhileStmt * whileStmt ) override final;
     94        virtual void visit( WhileDoStmt * whileDoStmt ) override final;
     95        virtual void visit( const WhileDoStmt * whileDoStmt ) override final;
    9696        virtual void visit( ForStmt * forStmt ) override final;
    9797        virtual void visit( const ForStmt * forStmt ) override final;
     
    277277        virtual Statement * mutate( DirectiveStmt * dirStmt ) override final;
    278278        virtual Statement * mutate( IfStmt * ifStmt ) override final;
    279         virtual Statement * mutate( WhileStmt * whileStmt ) override final;
     279        virtual Statement * mutate( WhileDoStmt * whileDoStmt ) override final;
    280280        virtual Statement * mutate( ForStmt * forStmt ) override final;
    281281        virtual Statement * mutate( SwitchStmt * switchStmt ) override final;
  • src/Common/PassVisitor.impl.h

    r729c991 r3b0bc16  
    11891189                maybeAccept_impl( node->initialization, *this );
    11901190                visitExpression ( node->condition );
    1191                 node->thenPart = visitStatement( node->thenPart );
    1192                 node->elsePart = visitStatement( node->elsePart );
     1191                node->then = visitStatement( node->then );
     1192                node->else_ = visitStatement( node->else_ );
    11931193        }
    11941194        VISIT_END( node );
     
    12031203                maybeAccept_impl( node->initialization, *this );
    12041204                visitExpression ( node->condition );
    1205                 visitStatement  ( node->thenPart );
    1206                 visitStatement  ( node->elsePart );
     1205                visitStatement  ( node->then );
     1206                visitStatement  ( node->else_ );
    12071207        }
    12081208        VISIT_END( node );
     
    12171217                maybeMutate_impl( node->initialization, *this );
    12181218                node->condition = mutateExpression( node->condition );
    1219                 node->thenPart  = mutateStatement ( node->thenPart  );
    1220                 node->elsePart  = mutateStatement ( node->elsePart  );
     1219                node->then  = mutateStatement ( node->then  );
     1220                node->else_  = mutateStatement ( node->else_  );
    12211221        }
    12221222        MUTATE_END( Statement, node );
     
    12241224
    12251225//--------------------------------------------------------------------------
    1226 // WhileStmt
    1227 template< typename pass_type >
    1228 void PassVisitor< pass_type >::visit( WhileStmt * node ) {
     1226// WhileDoStmt
     1227template< typename pass_type >
     1228void PassVisitor< pass_type >::visit( WhileDoStmt * node ) {
    12291229        VISIT_START( node );
    12301230
     
    12411241
    12421242template< typename pass_type >
    1243 void PassVisitor< pass_type >::visit( const WhileStmt * node ) {
     1243void PassVisitor< pass_type >::visit( const WhileDoStmt * node ) {
    12441244        VISIT_START( node );
    12451245
     
    12561256
    12571257template< typename pass_type >
    1258 Statement * PassVisitor< pass_type >::mutate( WhileStmt * node ) {
     1258Statement * PassVisitor< pass_type >::mutate( WhileDoStmt * node ) {
    12591259        MUTATE_START( node );
    12601260
  • src/ControlStruct/ForExprMutator.cc

    r729c991 r3b0bc16  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Mar 11 22:26:52 2019
    13 // Update Count     : 14
     12// Last Modified On : Tue Feb  1 09:26:12 2022
     13// Update Count     : 16
    1414//
    1515
     
    4545                return hoist( forStmt, forStmt->initialization );
    4646        }
    47         Statement * ForExprMutator::postmutate( WhileStmt * whileStmt ) {
    48                 return hoist( whileStmt, whileStmt->initialization );
     47        Statement * ForExprMutator::postmutate( WhileDoStmt * whileDoStmt ) {
     48                return hoist( whileDoStmt, whileDoStmt->initialization );
    4949        }
    5050} // namespace ControlStruct
  • src/ControlStruct/ForExprMutator.h

    r729c991 r3b0bc16  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Jan 30 09:14:46 2022
    13 // Update Count     : 6
     12// Last Modified On : Tue Feb  1 09:18:50 2022
     13// Update Count     : 7
    1414//
    1515
     
    1818class IfStmt;
    1919class ForStmt;
    20 class WhileStmt;
     20class WhileDoStmt;
    2121class Statement;
    2222
     
    2626                Statement * postmutate( IfStmt * );
    2727                Statement * postmutate( ForStmt * );
    28                 Statement * postmutate( WhileStmt * );
     28                Statement * postmutate( WhileDoStmt * );
    2929        };
    3030} // namespace ControlStruct
  • src/ControlStruct/HoistControlDecls.cpp

    r729c991 r3b0bc16  
    1010// Created On       : Fri Dec  3 15:34:00 2021
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Jan 31 18:52:35 2022
    13 // Update Count     : 23
     12// Last Modified On : Tue Feb  1 18:59:47 2022
     13// Update Count     : 25
    1414//
    1515
     
    3535
    3636        CompoundStmt * block = new CompoundStmt( stmt->location ); // create empty compound statement
    37         //    {
    38         //    }
     37        //    {}
    3938
    4039        for ( const Stmt * next : stmt->inits ) {                       // link conditional declarations into compound
     
    6968                return hoist<ForStmt>( stmt );
    7069        }
    71         const Stmt * postvisit( const WhileStmt * stmt ) {
    72                 return hoist<WhileStmt>( stmt );
     70        const Stmt * postvisit( const WhileDoStmt * stmt ) {
     71                return hoist<WhileDoStmt>( stmt );
    7372        }
    7473};
  • src/ControlStruct/LabelFixer.cc

    r729c991 r3b0bc16  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Jan 31 22:28:31 2022
    13 // Update Count     : 161
     12// Last Modified On : Tue Feb  1 09:12:09 2022
     13// Update Count     : 162
    1414//
    1515
     
    2929bool LabelFixer::Entry::insideLoop() {
    3030        return ( dynamic_cast< ForStmt * > ( definition ) ||
    31                 dynamic_cast< WhileStmt * > ( definition )  );
     31                dynamic_cast< WhileDoStmt * > ( definition )  );
    3232}
    3333
  • src/ControlStruct/MLEMutator.cc

    r729c991 r3b0bc16  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Wed Jan 22 11:50:00 2020
    13 // Update Count     : 223
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Tue Feb  1 09:26:28 2022
     13// Update Count     : 225
    1414//
    1515
     
    3939        namespace {
    4040                bool isLoop( const MultiLevelExitMutator::Entry & e ) {
    41                         return dynamic_cast< WhileStmt * >( e.get_controlStructure() )
     41                        return dynamic_cast< WhileDoStmt * >( e.get_controlStructure() )
    4242                                || dynamic_cast< ForStmt * >( e.get_controlStructure() );
    4343                }
     
    295295        }
    296296
    297         void MultiLevelExitMutator::premutate( WhileStmt * whileStmt ) {
    298                 return prehandleLoopStmt( whileStmt );
     297        void MultiLevelExitMutator::premutate( WhileDoStmt * whileDoStmt ) {
     298                return prehandleLoopStmt( whileDoStmt );
    299299        }
    300300
     
    303303        }
    304304
    305         Statement * MultiLevelExitMutator::postmutate( WhileStmt * whileStmt ) {
    306                 return posthandleLoopStmt( whileStmt );
     305        Statement * MultiLevelExitMutator::postmutate( WhileDoStmt * whileDoStmt ) {
     306                return posthandleLoopStmt( whileDoStmt );
    307307        }
    308308
  • src/ControlStruct/MLEMutator.h

    r729c991 r3b0bc16  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Wed Jan 22 11:50:00 2020
    13 // Update Count     : 48
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Tue Feb  1 09:27:24 2022
     13// Update Count     : 50
    1414//
    1515
     
    4242                void premutate( CompoundStmt *cmpndStmt );
    4343                Statement * postmutate( BranchStmt *branchStmt ) throw ( SemanticErrorException );
    44                 void premutate( WhileStmt *whileStmt );
    45                 Statement * postmutate( WhileStmt *whileStmt );
     44                void premutate( WhileDoStmt *whileDoStmt );
     45                Statement * postmutate( WhileDoStmt *whileDoStmt );
    4646                void premutate( ForStmt *forStmt );
    4747                Statement * postmutate( ForStmt *forStmt );
     
    6767                                stmt( stmt ), breakExit( breakExit ), contExit( contExit ) {}
    6868
    69                         explicit Entry( WhileStmt *stmt, Label breakExit, Label contExit ) :
     69                        explicit Entry( WhileDoStmt *stmt, Label breakExit, Label contExit ) :
    7070                                stmt( stmt ), breakExit( breakExit ), contExit( contExit ) {}
    7171
  • src/ControlStruct/MultiLevelExit.cpp

    r729c991 r3b0bc16  
    1010// Created On       : Mon Nov  1 13:48:00 2021
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Jan 31 22:35:08 2022
    13 // Update Count     : 28
     12// Last Modified On : Tue Feb  1 18:48:47 2022
     13// Update Count     : 29
    1414//
    1515
     
    4040
    4141        enum Kind {
    42                 ForStmtK, WhileStmtK, CompoundStmtK, IfStmtK, CaseStmtK, SwitchStmtK, TryStmtK
     42                ForStmtK, WhileDoStmtK, CompoundStmtK, IfStmtK, CaseStmtK, SwitchStmtK, TryStmtK
    4343        } kind;
    4444
     
    5353        Entry( const ForStmt * stmt, Label breakExit, Label contExit ) :
    5454                stmt( stmt ), firstTarget( breakExit ), secondTarget( contExit ), kind( ForStmtK ) {}
    55         Entry( const WhileStmt * stmt, Label breakExit, Label contExit ) :
    56                 stmt( stmt ), firstTarget( breakExit ), secondTarget( contExit ), kind( WhileStmtK ) {}
     55        Entry( const WhileDoStmt * stmt, Label breakExit, Label contExit ) :
     56                stmt( stmt ), firstTarget( breakExit ), secondTarget( contExit ), kind( WhileDoStmtK ) {}
    5757        Entry( const CompoundStmt *stmt, Label breakExit ) :
    5858                stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( CompoundStmtK ) {}
     
    6666                stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( TryStmtK ) {}
    6767
    68         bool isContTarget() const { return kind <= WhileStmtK; }
     68        bool isContTarget() const { return kind <= WhileDoStmtK; }
    6969        bool isBreakTarget() const { return kind != CaseStmtK; }
    7070        bool isFallTarget() const { return kind == CaseStmtK; }
     
    7272
    7373        // These routines set a target as being "used" by a BranchStmt
    74         Label useContExit() { assert( kind <= WhileStmtK ); return useTarget(secondTarget); }
     74        Label useContExit() { assert( kind <= WhileDoStmtK ); return useTarget(secondTarget); }
    7575        Label useBreakExit() { assert( kind != CaseStmtK ); return useTarget(firstTarget); }
    7676        Label useFallExit() { assert( kind == CaseStmtK );  return useTarget(firstTarget); }
     
    7878
    7979        // These routines check if a specific label for a statement is used by a BranchStmt
    80         bool isContUsed() const { assert( kind <= WhileStmtK ); return secondTarget.used; }
     80        bool isContUsed() const { assert( kind <= WhileDoStmtK ); return secondTarget.used; }
    8181        bool isBreakUsed() const { assert( kind != CaseStmtK ); return firstTarget.used; }
    8282        bool isFallUsed() const { assert( kind == CaseStmtK ); return firstTarget.used; }
     
    112112        const CompoundStmt * previsit( const CompoundStmt * );
    113113        const BranchStmt * postvisit( const BranchStmt * );
    114         void previsit( const WhileStmt * );
    115         const WhileStmt * postvisit( const WhileStmt * );
     114        void previsit( const WhileDoStmt * );
     115        const WhileDoStmt * postvisit( const WhileDoStmt * );
    116116        void previsit( const ForStmt * );
    117117        const ForStmt * postvisit( const ForStmt * );
     
    342342}
    343343
    344 void MultiLevelExitCore::previsit( const WhileStmt * stmt ) {
     344void MultiLevelExitCore::previsit( const WhileDoStmt * stmt ) {
    345345        return prehandleLoopStmt( stmt );
    346346}
    347347
    348 const WhileStmt * MultiLevelExitCore::postvisit( const WhileStmt * stmt ) {
     348const WhileDoStmt * MultiLevelExitCore::postvisit( const WhileDoStmt * stmt ) {
    349349        return posthandleLoopStmt( stmt );
    350350}
  • src/Parser/ParseNode.h

    r729c991 r3b0bc16  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jan 29 09:45:56 2022
    13 // Update Count     : 901
     12// Last Modified On : Tue Feb  1 11:06:18 2022
     13// Update Count     : 903
    1414//
    1515
     
    414414Statement * build_case( ExpressionNode * ctl );
    415415Statement * build_default();
    416 Statement * build_while( CondCtl * ctl, StatementNode * stmt );
    417 Statement * build_do_while( ExpressionNode * ctl, StatementNode * stmt );
    418 Statement * build_for( ForCtrl * forctl, StatementNode * stmt );
     416Statement * build_while( CondCtl * ctl, StatementNode * stmt, StatementNode * els = nullptr );
     417Statement * build_do_while( ExpressionNode * ctl, StatementNode * stmt, StatementNode * els = nullptr );
     418Statement * build_for( ForCtrl * forctl, StatementNode * stmt, StatementNode * els = nullptr );
    419419Statement * build_branch( BranchStmt::Type kind );
    420420Statement * build_branch( std::string * identifier, BranchStmt::Type kind );
  • src/Parser/StatementNode.cc

    r729c991 r3b0bc16  
    1010// Created On       : Sat May 16 14:59:41 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jan 29 09:45:51 2022
    13 // Update Count     : 384
     12// Last Modified On : Tue Feb  1 18:39:00 2022
     13// Update Count     : 395
    1414//
    1515
     
    145145} // build_default
    146146
    147 Statement * build_while( CondCtl * ctl, StatementNode * stmt ) {
    148         std::list< Statement * > branches;
    149         buildMoveList< Statement, StatementNode >( stmt, branches );
    150         assert( branches.size() == 1 );
    151 
     147Statement * build_while( CondCtl * ctl, StatementNode * stmt, StatementNode * else_ ) {
    152148        std::list< Statement * > init;
    153149        Expression * cond = build_if_control( ctl, init );
    154         return new WhileStmt( cond, branches.front(), init, false );
     150
     151        std::list< Statement * > aststmt;
     152        buildMoveList< Statement, StatementNode >( stmt, aststmt );
     153        assert( aststmt.size() == 1 );
     154
     155        std::list< Statement * > astelse;
     156        buildMoveList< Statement, StatementNode >( else_, astelse );
     157
     158        return new WhileDoStmt( cond, aststmt.front(), astelse.front(), init, false );
    155159} // build_while
    156160
    157 Statement * build_do_while( ExpressionNode * ctl, StatementNode * stmt ) {
    158         std::list< Statement * > branches;
    159         buildMoveList< Statement, StatementNode >( stmt, branches );
    160         assert( branches.size() == 1 );
     161Statement * build_do_while( ExpressionNode * ctl, StatementNode * stmt, StatementNode * else_ ) {
     162        std::list< Statement * > aststmt;
     163        buildMoveList< Statement, StatementNode >( stmt, aststmt );
     164        assert( aststmt.size() == 1 );
     165
     166        std::list< Statement * > astelse;
     167        buildMoveList< Statement, StatementNode >( else_, astelse );
    161168
    162169        std::list< Statement * > init;
    163         return new WhileStmt( notZeroExpr( maybeMoveBuild< Expression >(ctl) ), branches.front(), init, true );
     170        return new WhileDoStmt( notZeroExpr( maybeMoveBuild< Expression >(ctl) ), aststmt.front(), astelse.front(), init, true );
    164171} // build_do_while
    165172
    166 Statement * build_for( ForCtrl * forctl, StatementNode * stmt ) {
    167         std::list< Statement * > branches;
    168         buildMoveList< Statement, StatementNode >( stmt, branches );
    169         assert( branches.size() == 1 );
    170 
     173Statement * build_for( ForCtrl * forctl, StatementNode * stmt, StatementNode * else_ ) {
    171174        std::list< Statement * > init;
    172         if ( forctl->init != 0 ) {
     175        if ( forctl->init != nullptr ) {
    173176                buildMoveList( forctl->init, init );
    174177        } // if
    175178
    176         Expression * cond = 0;
    177         if ( forctl->condition != 0 )
     179        Expression * cond = nullptr;
     180        if ( forctl->condition != nullptr )
    178181                cond = notZeroExpr( maybeMoveBuild< Expression >(forctl->condition) );
    179182
    180         Expression * incr = 0;
    181         if ( forctl->change != 0 )
     183        Expression * incr = nullptr;
     184        if ( forctl->change != nullptr )
    182185                incr = maybeMoveBuild< Expression >(forctl->change);
    183186
     187        std::list< Statement * > aststmt;
     188        buildMoveList< Statement, StatementNode >( stmt, aststmt );
     189        assert( aststmt.size() == 1 );
     190
     191        std::list< Statement * > astelse;
     192        buildMoveList< Statement, StatementNode >( else_, astelse );
     193
    184194        delete forctl;
    185         return new ForStmt( init, cond, incr, branches.front() );
     195        return new ForStmt( init, cond, incr, aststmt.front(), astelse.front() );
    186196} // build_for
    187197
  • src/Parser/parser.yy

    r729c991 r3b0bc16  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Jan 30 09:41:13 2022
    13 // Update Count     : 5165
     12// Last Modified On : Tue Feb  1 11:06:13 2022
     13// Update Count     : 5167
    1414//
    1515
     
    11971197                { $$ = new StatementNode( build_while( $3, maybe_build_compound( $5 ) ) ); }
    11981198        | WHILE '(' conditional_declaration ')' statement ELSE statement // CFA
    1199                 { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
     1199                // { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
     1200                { $$ = new StatementNode( build_while( $3, maybe_build_compound( $5 ), $7 ) ); }
    12001201        | DO statement WHILE '(' ')' ';'                                        // CFA => do while( 1 )
    12011202                { $$ = new StatementNode( build_do_while( new ExpressionNode( build_constantInteger( *new string( "1" ) ) ), maybe_build_compound( $2 ) ) ); }
     
    12031204                { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ) ) ); }
    12041205        | DO statement WHILE '(' comma_expression ')' ELSE statement // CFA
    1205                 { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
     1206                // { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
     1207                { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ), $8 ) ); }
    12061208        | FOR '(' ')' statement                                                         // CFA => for ( ;; )
    12071209                { $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), maybe_build_compound( $4 ) ) ); }
     
    12091211                { $$ = new StatementNode( build_for( $3, maybe_build_compound( $5 ) ) ); }
    12101212        | FOR '(' for_control_expression_list ')' statement ELSE statement // CFA
    1211                 { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
     1213                // { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
     1214                { $$ = new StatementNode( build_for( $3, maybe_build_compound( $5 ), $7 ) ); }
    12121215        ;
    12131216
  • src/ResolvExpr/Resolver.cc

    r729c991 r3b0bc16  
    99// Author           : Aaron B. Moss
    1010// Created On       : Sun May 17 12:17:01 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Fri Mar 27 11:58:00 2020
    13 // Update Count     : 242
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Tue Feb  1 16:27:14 2022
     13// Update Count     : 245
    1414//
    1515
     
    8080                void previsit( AsmStmt * asmStmt );
    8181                void previsit( IfStmt * ifStmt );
    82                 void previsit( WhileStmt * whileStmt );
     82                void previsit( WhileDoStmt * whileDoStmt );
    8383                void previsit( ForStmt * forStmt );
    8484                void previsit( SwitchStmt * switchStmt );
     
    502502        }
    503503
    504         void Resolver_old::previsit( WhileStmt * whileStmt ) {
    505                 findIntegralExpression( whileStmt->condition, indexer );
     504        void Resolver_old::previsit( WhileDoStmt * whileDoStmt ) {
     505                findIntegralExpression( whileDoStmt->condition, indexer );
    506506        }
    507507
     
    572572
    573573        void Resolver_old::previsit( CatchStmt * catchStmt ) {
    574                 // Until we are very sure this invarent (ifs that move between passes have thenPart)
     574                // Until we are very sure this invarent (ifs that move between passes have then)
    575575                // holds, check it. This allows a check for when to decode the mangling.
    576576                if ( IfStmt * ifStmt = dynamic_cast<IfStmt *>( catchStmt->body ) ) {
    577                         assert( ifStmt->thenPart );
     577                        assert( ifStmt->then );
    578578                }
    579579                // Encode the catchStmt so the condition can see the declaration.
     
    588588                // Decode the catchStmt so everything is stored properly.
    589589                IfStmt * ifStmt = dynamic_cast<IfStmt *>( catchStmt->body );
    590                 if ( nullptr != ifStmt && nullptr == ifStmt->thenPart ) {
     590                if ( nullptr != ifStmt && nullptr == ifStmt->then ) {
    591591                        assert( ifStmt->condition );
    592                         assert( ifStmt->elsePart );
     592                        assert( ifStmt->else_ );
    593593                        catchStmt->cond = ifStmt->condition;
    594                         catchStmt->body = ifStmt->elsePart;
     594                        catchStmt->body = ifStmt->else_;
    595595                        ifStmt->condition = nullptr;
    596                         ifStmt->elsePart = nullptr;
     596                        ifStmt->else_ = nullptr;
    597597                        delete ifStmt;
    598598                }
     
    12721272                const ast::AsmStmt *         previsit( const ast::AsmStmt * );
    12731273                const ast::IfStmt *          previsit( const ast::IfStmt * );
    1274                 const ast::WhileStmt *       previsit( const ast::WhileStmt * );
     1274                const ast::WhileDoStmt *       previsit( const ast::WhileDoStmt * );
    12751275                const ast::ForStmt *         previsit( const ast::ForStmt * );
    12761276                const ast::SwitchStmt *      previsit( const ast::SwitchStmt * );
     
    15811581        }
    15821582
    1583         const ast::WhileStmt * Resolver_new::previsit( const ast::WhileStmt * whileStmt ) {
     1583        const ast::WhileDoStmt * Resolver_new::previsit( const ast::WhileDoStmt * whileDoStmt ) {
    15841584                return ast::mutate_field(
    1585                         whileStmt, &ast::WhileStmt::cond, findIntegralExpression( whileStmt->cond, symtab ) );
     1585                        whileDoStmt, &ast::WhileDoStmt::cond, findIntegralExpression( whileDoStmt->cond, symtab ) );
    15861586        }
    15871587
     
    16691669
    16701670        const ast::CatchStmt * Resolver_new::previsit( const ast::CatchStmt * catchStmt ) {
    1671                 // Until we are very sure this invarent (ifs that move between passes have thenPart)
     1671                // Until we are very sure this invarent (ifs that move between passes have then)
    16721672                // holds, check it. This allows a check for when to decode the mangling.
    16731673                if ( auto ifStmt = catchStmt->body.as<ast::IfStmt>() ) {
    1674                         assert( ifStmt->thenPart );
     1674                        assert( ifStmt->then );
    16751675                }
    16761676                // Encode the catchStmt so the condition can see the declaration.
     
    16871687                // Decode the catchStmt so everything is stored properly.
    16881688                const ast::IfStmt * ifStmt = catchStmt->body.as<ast::IfStmt>();
    1689                 if ( nullptr != ifStmt && nullptr == ifStmt->thenPart ) {
     1689                if ( nullptr != ifStmt && nullptr == ifStmt->then ) {
    16901690                        assert( ifStmt->cond );
    1691                         assert( ifStmt->elsePart );
     1691                        assert( ifStmt->else_ );
    16921692                        ast::CatchStmt * stmt = ast::mutate( catchStmt );
    16931693                        stmt->cond = ifStmt->cond;
    1694                         stmt->body = ifStmt->elsePart;
     1694                        stmt->body = ifStmt->else_;
    16951695                        // ifStmt should be implicately deleted here.
    16961696                        return stmt;
  • src/SynTree/Mutator.h

    r729c991 r3b0bc16  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar 12 18:35:36 2021
    13 // Update Count     : 18
     12// Last Modified On : Tue Feb  1 09:26:49 2022
     13// Update Count     : 20
    1414//
    1515#pragma once
     
    4242        virtual Statement * mutate( DirectiveStmt * dirStmt ) = 0;
    4343        virtual Statement * mutate( IfStmt * ifStmt ) = 0;
    44         virtual Statement * mutate( WhileStmt * whileStmt ) = 0;
     44        virtual Statement * mutate( WhileDoStmt * whileDoStmt ) = 0;
    4545        virtual Statement * mutate( ForStmt * forStmt ) = 0;
    4646        virtual Statement * mutate( SwitchStmt * switchStmt ) = 0;
  • src/SynTree/Statement.cc

    r729c991 r3b0bc16  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Mon Jan 20 16:03:00 2020
    13 // Update Count     : 71
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Tue Feb  1 17:55:29 2022
     13// Update Count     : 79
    1414//
    1515
     
    145145}
    146146
    147 IfStmt::IfStmt( Expression * condition, Statement * thenPart, Statement * elsePart, std::list<Statement *> initialization ):
    148         Statement(), condition( condition ), thenPart( thenPart ), elsePart( elsePart ), initialization( initialization ) {}
     147IfStmt::IfStmt( Expression * condition, Statement * then, Statement * else_, std::list<Statement *> initialization ):
     148        Statement(), condition( condition ), then( then ), else_( else_ ), initialization( initialization ) {}
    149149
    150150IfStmt::IfStmt( const IfStmt & other ) :
    151         Statement( other ), condition( maybeClone( other.condition ) ), thenPart( maybeClone( other.thenPart ) ), elsePart( maybeClone( other.elsePart ) ) {
     151        Statement( other ), condition( maybeClone( other.condition ) ), then( maybeClone( other.then ) ), else_( maybeClone( other.else_ ) ) {
    152152        cloneAll( other.initialization, initialization );
    153153}
     
    156156        deleteAll( initialization );
    157157        delete condition;
    158         delete thenPart;
    159         delete elsePart;
     158        delete then;
     159        delete else_;
    160160}
    161161
     
    177177
    178178        os << indent+1;
    179         thenPart->print( os, indent+1 );
    180 
    181         if ( elsePart != nullptr ) {
     179        then->print( os, indent+1 );
     180
     181        if ( else_ != nullptr ) {
    182182                os << indent << "... else: " << endl;
    183183                os << indent+1;
    184                 elsePart->print( os, indent+1 );
     184                else_->print( os, indent+1 );
    185185        } // if
    186186}
     
    246246}
    247247
    248 WhileStmt::WhileStmt( Expression * condition, Statement * body, std::list< Statement * > & initialization, bool isDoWhile ):
    249         Statement(), condition( condition), body( body), initialization( initialization ), isDoWhile( isDoWhile) {
    250 }
    251 
    252 WhileStmt::WhileStmt( const WhileStmt & other ):
     248WhileDoStmt::WhileDoStmt( Expression * condition, Statement * body, std::list< Statement * > & initialization, bool isDoWhile ):
     249        Statement(), condition( condition ), body( body ), else_( nullptr ), initialization( initialization ), isDoWhile( isDoWhile) {
     250}
     251
     252WhileDoStmt::WhileDoStmt( Expression * condition, Statement * body, Statement * else_, std::list< Statement * > & initialization, bool isDoWhile ):
     253        Statement(), condition( condition), body( body ), else_( else_ ), initialization( initialization ), isDoWhile( isDoWhile) {
     254}
     255
     256WhileDoStmt::WhileDoStmt( const WhileDoStmt & other ):
    253257        Statement( other ), condition( maybeClone( other.condition ) ), body( maybeClone( other.body ) ), isDoWhile( other.isDoWhile ) {
    254258}
    255259
    256 WhileStmt::~WhileStmt() {
     260WhileDoStmt::~WhileDoStmt() {
    257261        delete body;
    258262        delete condition;
    259263}
    260264
    261 void WhileStmt::print( std::ostream & os, Indenter indent ) const {
     265void WhileDoStmt::print( std::ostream & os, Indenter indent ) const {
    262266        os << "While on condition: " << endl ;
    263267        condition->print( os, indent+1 );
     
    268272}
    269273
    270 ForStmt::ForStmt( std::list<Statement *> initialization, Expression * condition, Expression * increment, Statement * body ):
    271         Statement(), initialization( initialization ), condition( condition ), increment( increment ), body( body ) {
     274ForStmt::ForStmt( std::list<Statement *> initialization, Expression * condition, Expression * increment, Statement * body, Statement * else_ ):
     275        Statement(), initialization( initialization ), condition( condition ), increment( increment ), body( body ), else_( else_ ) {
    272276}
    273277
    274278ForStmt::ForStmt( const ForStmt & other ):
    275         Statement( other ), condition( maybeClone( other.condition ) ), increment( maybeClone( other.increment ) ), body( maybeClone( other.body ) ) {
     279        Statement( other ), condition( maybeClone( other.condition ) ), increment( maybeClone( other.increment ) ), body( maybeClone( other.body ) ), else_( maybeClone( other.else_ ) ) {
    276280                cloneAll( other.initialization, initialization );
    277281
     
    283287        delete increment;
    284288        delete body;
     289        delete else_;
    285290}
    286291
     
    311316                os << "\n" << indent << "... with body: \n" << indent+1;
    312317                body->print( os, indent+1 );
     318        }
     319
     320        if ( else_ != nullptr ) {
     321                os << "\n" << indent << "... with body: \n" << indent+1;
     322                else_->print( os, indent+1 );
    313323        }
    314324        os << endl;
  • src/SynTree/Statement.h

    r729c991 r3b0bc16  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Jan 10 14:13:24 2020
    13 // Update Count     : 85
     12// Last Modified On : Tue Feb  1 17:07:32 2022
     13// Update Count     : 93
    1414//
    1515
     
    148148  public:
    149149        Expression * condition;
    150         Statement * thenPart;
    151         Statement * elsePart;
     150        Statement * then;
     151        Statement * else_;
    152152        std::list<Statement *> initialization;
    153153
    154         IfStmt( Expression * condition, Statement * thenPart, Statement * elsePart,
     154        IfStmt( Expression * condition, Statement * then, Statement * else_,
    155155                        std::list<Statement *> initialization = std::list<Statement *>() );
    156156        IfStmt( const IfStmt & other );
     
    160160        Expression * get_condition() { return condition; }
    161161        void set_condition( Expression * newValue ) { condition = newValue; }
    162         Statement * get_thenPart() { return thenPart; }
    163         void set_thenPart( Statement * newValue ) { thenPart = newValue; }
    164         Statement * get_elsePart() { return elsePart; }
    165         void set_elsePart( Statement * newValue ) { elsePart = newValue; }
     162        Statement * get_then() { return then; }
     163        void set_then( Statement * newValue ) { then = newValue; }
     164        Statement * get_else() { return else_; }
     165        void set_else( Statement * newValue ) { else_ = newValue; }
    166166
    167167        virtual IfStmt * clone() const override { return new IfStmt( *this ); }
     
    225225};
    226226
    227 class WhileStmt : public Statement {
     227class WhileDoStmt : public Statement {
    228228  public:
    229229        Expression * condition;
    230230        Statement * body;
     231        Statement * else_;
    231232        std::list<Statement *> initialization;
    232233        bool isDoWhile;
    233234
    234         WhileStmt( Expression * condition, Statement * body, std::list<Statement *> & initialization, bool isDoWhile = false );
    235         WhileStmt( const WhileStmt & other );
    236         virtual ~WhileStmt();
     235        WhileDoStmt( Expression * condition, Statement * body, std::list<Statement *> & initialization, bool isDoWhile = false );
     236        WhileDoStmt( Expression * condition, Statement * body, Statement * els, std::list<Statement *> & initialization, bool isDoWhile = false );
     237        WhileDoStmt( const WhileDoStmt & other );
     238        virtual ~WhileDoStmt();
    237239
    238240        Expression * get_condition() { return condition; }
     
    243245        void set_isDoWhile( bool newValue ) { isDoWhile = newValue; }
    244246
    245         virtual WhileStmt * clone() const override { return new WhileStmt( *this ); }
     247        virtual WhileDoStmt * clone() const override { return new WhileDoStmt( *this ); }
    246248        virtual void accept( Visitor & v ) override { v.visit( this ); }
    247249        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     
    256258        Expression * increment;
    257259        Statement * body;
    258 
    259         ForStmt( std::list<Statement *> initialization, Expression * condition = nullptr, Expression * increment = nullptr, Statement * body = nullptr );
     260        Statement * else_;
     261
     262        ForStmt( std::list<Statement *> initialization, Expression * condition = nullptr, Expression * increment = nullptr, Statement * body = nullptr, Statement * else_ = nullptr );
    260263        ForStmt( const ForStmt & other );
    261264        virtual ~ForStmt();
  • src/SynTree/SynTree.h

    r729c991 r3b0bc16  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar 12 18:56:44 2021
    13 // Update Count     : 13
     12// Last Modified On : Tue Feb  1 09:22:33 2022
     13// Update Count     : 14
    1414//
    1515
     
    4545class DirectiveStmt;
    4646class IfStmt;
    47 class WhileStmt;
     47class WhileDoStmt;
    4848class ForStmt;
    4949class SwitchStmt;
  • src/SynTree/Visitor.h

    r729c991 r3b0bc16  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar 12 18:35:35 2021
    13 // Update Count     : 15
     12// Last Modified On : Tue Feb  1 09:26:57 2022
     13// Update Count     : 17
    1414//
    1515
     
    6060        virtual void visit( IfStmt * node ) { visit( const_cast<const IfStmt *>(node) ); }
    6161        virtual void visit( const IfStmt * ifStmt ) = 0;
    62         virtual void visit( WhileStmt * node ) { visit( const_cast<const WhileStmt *>(node) ); }
    63         virtual void visit( const WhileStmt * whileStmt ) = 0;
     62        virtual void visit( WhileDoStmt * node ) { visit( const_cast<const WhileDoStmt *>(node) ); }
     63        virtual void visit( const WhileDoStmt * whileDoStmt ) = 0;
    6464        virtual void visit( ForStmt * node ) { visit( const_cast<const ForStmt *>(node) ); }
    6565        virtual void visit( const ForStmt * forStmt ) = 0;
Note: See TracChangeset for help on using the changeset viewer.