include/comma/ast/Stmt.h

Go to the documentation of this file.

//===-- ast/Stmt.h -------------------------------------------- -*- C++ -*-===//
//
// This file is distributed under the MIT license.  See LICENSE.txt for details.
//
// Copyright (C) 2008-2010, Stephen Wilson
//
//===----------------------------------------------------------------------===//

#ifndef COMMA_AST_STMT_HDR_GUARD
#define COMMA_AST_STMT_HDR_GUARD

#include "comma/ast/AstBase.h"
#include "comma/ast/DeclRegion.h"
#include "comma/ast/SubroutineCall.h"

namespace comma {

class Pragma;

//===----------------------------------------------------------------------===//
// Stmt
class Stmt : public Ast {

protected:
    Stmt(AstKind kind, Location loc) : Ast(kind), location(loc) { }

public:
    Location getLocation() const { return location; }

    bool isTerminator() const;

    // Support isa/dyn_cast.
    static bool classof(const Stmt *node) { return true; }
    static bool classof(const Ast *node) {
        return node->denotesStmt();
    }

private:
    Location location;
};

//===----------------------------------------------------------------------===//
// StmtSequence
//
// Represents a sequence of statements.
class StmtSequence : public Stmt {

    typedef llvm::SmallVector<Stmt*, 16> StatementVec;
    typedef llvm::SmallVector<HandlerStmt*, 2> HandlerVec;
    StatementVec statements;
    HandlerVec handlers;

protected:
    StmtSequence(AstKind kind, Location loc) : Stmt(kind, loc) { }

public:
    StmtSequence(Location loc) : Stmt(AST_StmtSequence, loc) { }

    template <class Iter>
    StmtSequence(Location loc, Iter I, Iter E)
        : Stmt(AST_StmtSequence, loc),
          statements(I, E) { }

    void addStmt(Stmt *stmt) { statements.push_back(stmt); }

    template <class Iter>
    void addStmts(Iter I, Iter E) {
        for ( ; I != E; ++I)
            statements.push_back(*I);
    }

    unsigned numStatements() const { return statements.size(); }

    bool isEmpty() const { return numStatements() == 0; }


    Stmt *front() { return statements.front(); }
    const Stmt *front() const { return statements.front(); }


    Stmt *back() { return statements.back(); }
    const Stmt *back() const { return statements.back(); }


    typedef StatementVec::iterator stmt_iter;
    stmt_iter stmt_begin() { return statements.begin(); }
    stmt_iter stmt_end()   { return statements.end(); }

    typedef StatementVec::const_iterator const_stmt_iter;
    const_stmt_iter stmt_begin() const { return statements.begin(); }
    const_stmt_iter stmt_end()   const { return statements.end(); }

    bool isHandled() const { return !handlers.empty(); }

    unsigned numHandlers() const { return handlers.size(); }

    bool hasCatchAll() const;

    bool handles(const ExceptionDecl *exception) const;

    void addHandler(HandlerStmt *handler) {
        assert(!hasCatchAll() && "Catch-all handler already present!");
        handlers.push_back(handler);
    }


    typedef HandlerVec::iterator handler_iter;
    handler_iter handler_begin() { return handlers.begin(); }
    handler_iter handler_end() { return handlers.end(); }

    typedef HandlerVec::const_iterator const_handler_iter;
    const_handler_iter handler_begin() const { return handlers.begin(); }
    const_handler_iter handler_end() const { return handlers.end(); }

    // Support isa/dyn_cast
    static bool classof(const StmtSequence *node) { return true; }
    static bool classof(const Ast *node) {
        AstKind kind = node->getKind();
        return kind == AST_StmtSequence || kind == AST_BlockStmt ||
            kind == AST_HandlerStmt;
    }
};

//===----------------------------------------------------------------------===//
// HandlerStmt
//
class HandlerStmt : public StmtSequence {

public:
    HandlerStmt(Location loc, ExceptionRef **choices, unsigned numChoices);

    unsigned getNumChoices() const { return numChoices; }

    bool isCatchAll() const { return getNumChoices() == 0; }

    bool handles(const ExceptionDecl *exception) const;



    typedef ExceptionRef **choice_iterator;
    choice_iterator choice_begin() { return choices; }
    choice_iterator choice_end() { return choices + numChoices; }

    typedef const ExceptionRef *const *const_choice_iterator;
    const_choice_iterator choice_begin() const { return choices; }
    const_choice_iterator choice_end() const { return choices + numChoices; }

    // Support isa/dyn_cast.
    static bool classof(const HandlerStmt *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_HandlerStmt;
    }

private:
    unsigned numChoices;
    ExceptionRef **choices;
};

//===----------------------------------------------------------------------===//
// BlockStmt
//
// Represents a block statement consisting of an optional identifier, a possibly
// empty declarative region, and a sequence of statements constituting the body.
class BlockStmt : public StmtSequence, public DeclRegion {

public:
    BlockStmt(Location        loc,
              DeclRegion     *parent,
              IdentifierInfo *label = 0)
        : StmtSequence(AST_BlockStmt, loc),
          DeclRegion(AST_BlockStmt, parent),
          label(label) { }

    // Returns true if this block has an associated label.
    bool hasLabel() const { return label != 0; }

    // Returns the label associated with this block, or 0 if there is no such
    // label.
    IdentifierInfo *getLabel() { return label; }

    // Support isa/dyn_cast.
    static bool classof(const BlockStmt *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_BlockStmt;
    }

private:
    IdentifierInfo *label;
};

//===----------------------------------------------------------------------===//
// ProcedureCallStmt
//
// Representation of a procedure call statement.
class ProcedureCallStmt : public Stmt, public SubroutineCall {

public:
    ProcedureCallStmt(SubroutineRef *ref,
                      Expr **positionalArgs, unsigned numPositional,
                      KeywordSelector **keyedArgs, unsigned numKeys);

    Location getLocation() const {
        // Required since SubroutineCall::getLocation is pure virtual.
        return Stmt::getLocation();
    }


    const ProcedureDecl *getConnective() const {
        return llvm::cast<ProcedureDecl>(SubroutineCall::getConnective());
    }
    ProcedureDecl *getConnective() {
        return llvm::cast<ProcedureDecl>(SubroutineCall::getConnective());
    }

    // Support isa and dyn_cast.
    static bool classof(const ProcedureCallStmt *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_ProcedureCallStmt;
    }
};

//===----------------------------------------------------------------------===//
// ReturnStmt.
class ReturnStmt : public Stmt {

public:
    ReturnStmt(Location loc, Expr *expr = 0)
        : Stmt(AST_ReturnStmt, loc), returnExpr(expr) { }

    ~ReturnStmt();

    bool hasReturnExpr() const { return returnExpr != 0; }

    const Expr *getReturnExpr() const { return returnExpr; }
    Expr *getReturnExpr() { return returnExpr; }

    static bool classof(const ReturnStmt *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_ReturnStmt;
    }

private:
    Expr *returnExpr;
};

//===----------------------------------------------------------------------===//
// AssignmentStmt
class AssignmentStmt : public Stmt {

public:
    AssignmentStmt(Expr *target, Expr *value);

    Expr *getTarget() { return target; }
    const Expr *getTarget() const { return target; }

    Expr *getAssignedExpr() { return value; }
    const Expr *getAssignedExpr() const { return value; }

    // Support isa/dyn_cast.
    static bool classof(const AssignmentStmt *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_AssignmentStmt;
    }

private:
    Expr *target;
    Expr *value;
};

//===----------------------------------------------------------------------===//
// IfStmt
class IfStmt : public Stmt {

public:
    // IfStmt's are always constructed with a condition and a consequent.  If
    // the statement contains "elsif" components, one must call addElsif for
    // each component.  Similarly, one must call setAlternate to define the
    // "else" component.
    IfStmt(Location loc, Expr *condition, StmtSequence *consequent)
        : Stmt(AST_IfStmt, loc),
          elseLocation(0),
          condition(condition),
          consequent(consequent),
          alternate(0) { }

    // Returns the predicate expression controlling this IfStmt.
    Expr *getCondition() { return condition; }
    const Expr *getCondition() const { return condition; }

    // Returns the statement associated with the "then" branch of this IfStmt.
    StmtSequence *getConsequent() { return consequent; }
    const StmtSequence *getConsequent() const { return consequent; }

    // Sets the statement associated with the "else" branch of this IfStmt.
    void setAlternate(Location loc, StmtSequence *stmt) {
        assert(alternate == 0 &&  "Cannot reset IfStmt alternate!");
        elseLocation = loc;
        alternate    = stmt;
    }

    // Returns true if this IfStmt has been supplied with an "else" clause.
    bool hasAlternate() const { return alternate != 0; }

    // Returns the statement associated with the "else" clause, or 0 if no such
    // component exists.
    StmtSequence *getAlternate() { return alternate; }
    const StmtSequence *getAlternate() const { return alternate; }

    // The following class is used to represent "elsif" components of a
    // conditional.
    class Elsif {

    public:
        Location getLocation() const { return location; }

        Expr *getCondition() { return condition; }
        const Expr *getCondition() const { return condition; }

        StmtSequence *getConsequent() { return consequent; }
        const StmtSequence *getConsequent() const { return consequent; }

    private:
        Elsif(Location loc, Expr *cond, StmtSequence *stmt)
            : location(loc), condition(cond), consequent(stmt) { }

        friend class IfStmt;

        Location      location;
        Expr         *condition;
        StmtSequence *consequent;
    };

private:
    // The type used to store Elsif components.
    typedef llvm::SmallVector<Elsif, 2> ElsifVector;

public:
    typedef ElsifVector::iterator       iterator;
    typedef ElsifVector::const_iterator const_iterator;

    iterator beginElsif() { return elsifs.begin(); }
    iterator endElsif()   { return elsifs.end(); }

    const_iterator beginElsif() const { return elsifs.begin(); }
    const_iterator endElsif()   const { return elsifs.end(); }

    // Adds an "elsif" branch to this IfStmt.  The order in which this function
    // is called determines the order of the elsif branches.
    void addElsif(Location loc, Expr *condition, StmtSequence *consequent) {
        elsifs.push_back(Elsif(loc, condition, consequent));
    }

    // Returns true if this if statement contains elsif clauses.
    bool hasElsif() const { return !elsifs.empty(); }

    // Returns the location of the "if" token.
    Location getIfLocation() const { return Stmt::getLocation(); }

    // Returns the location of the "else" token if an alternate branch exists.
    Location getElseLocation() const { return elseLocation; }

    static bool classof(const IfStmt *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_IfStmt;
    }

private:
    Location      elseLocation;
    Expr         *condition;
    StmtSequence *consequent;
    StmtSequence *alternate;
    ElsifVector   elsifs;
};

//===----------------------------------------------------------------------===//
// WhileStmt
//
// Ast nodes representing the 'while' loop construct.
class WhileStmt : public Stmt {

public:
    WhileStmt(Location loc, Expr *condition, StmtSequence *body)
        : Stmt(AST_WhileStmt, loc),
          condition(condition),
          body(body) { }

    // Returns the condition expression controlling this loop.
    Expr *getCondition() { return condition; }
    const Expr *getCondition() const { return condition; }

    // Returns the body of this loop.
    StmtSequence *getBody() { return body; }
    const StmtSequence *getBody() const { return body; }

    static bool classof(const WhileStmt *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_WhileStmt;
    }

private:
    Expr *condition;
    StmtSequence *body;
};

//===----------------------------------------------------------------------===//
// ForStmt
//
class ForStmt : public Stmt {

public:
    ForStmt(Location loc, LoopDecl *iterationDecl, DSTDefinition *control);


    const LoopDecl *getLoopDecl() const { return iterationDecl; }
    LoopDecl *getLoopDecl() { return iterationDecl; }


    const DSTDefinition *getControl() const { return control; }
    DSTDefinition *getControl() { return control; }



    const DiscreteType *getControlType() const {
        return getLoopDecl()->getType();
    }
    DiscreteType *getControlType() { return getLoopDecl()->getType(); }

    bool isReversed() const { return bits == 1; }

    void markAsReversed() { bits = 1; }





    const StmtSequence *getBody() const { return &body; }
    StmtSequence *getBody() { return &body; }

    // Support isa/dyn_cast.
    static bool classof(const ForStmt *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_ForStmt;
    }

private:
    LoopDecl *iterationDecl;
    DSTDefinition *control;
    StmtSequence body;
};

//===----------------------------------------------------------------------===//
// LoopStmt
//
class LoopStmt : public Stmt {

public:
    LoopStmt(Location loc, StmtSequence *body)
        : Stmt(AST_LoopStmt, loc),
          body(body) { }


    const StmtSequence *getBody() const { return body; }
    StmtSequence *getBody() { return body; }

    // Support isa/dyn_cast.
    static bool classof(const LoopStmt *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_LoopStmt;
    }

private:
    StmtSequence *body;
};

//===----------------------------------------------------------------------===//
// PragmaStmt
//
// This is a simple Stmt node which wraps a pragma so that it can appear within
// a sequence of statements.
class PragmaStmt : public Stmt {

public:
    PragmaStmt(Pragma *pragma);

    const Pragma *getPragma() const { return pragma; }
    Pragma *getPragma() { return pragma; }

    // Support isa/dyn_cast.
    static bool classof(const PragmaStmt *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_PragmaStmt;
    }

private:
    Pragma *pragma;
};

//===----------------------------------------------------------------------===//
// RaiseStmt
class RaiseStmt : public Stmt {

public:
    RaiseStmt(Location loc, ExceptionRef *exception, Expr *message = 0)
        : Stmt(AST_RaiseStmt, loc),
          ref(exception), message(message) { }


    const ExceptionDecl *getExceptionDecl() const;
    ExceptionDecl *getExceptionDecl();


    const ExceptionRef *getExceptionRef() const { return ref; }
    ExceptionRef *getExceptionRef() { return ref; }

    bool hasMessage() const { return message != 0; }


    const Expr *getMessage() const { return message; }
    Expr *getMessage() { return message; }

    void setMessage(Expr *message) { this->message = message; }

    void setException(ExceptionRef *exception) { ref = exception; }

    // Support isa/dyn_cast.
    static bool classof(const RaiseStmt *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_RaiseStmt;
    }

private:
    ExceptionRef *ref;
    Expr *message;
};

//===----------------------------------------------------------------------===//
// NullStmt
class NullStmt : public Stmt {

public:
    NullStmt(Location loc) : Stmt(AST_NullStmt, loc) { }

    // Support isa/dyn_cast.
    static bool classof(const NullStmt *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_NullStmt;
    }
};

} // End comma namespace.

#endif

---