Statement.h

Go to the documentation of this file.

#ifndef MAD_Statement_HH
#define MAD_Statement_HH 1

// ------------------------------------------------------------------------
// $RCSfile: Statement.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1.2.1 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Class: Statement
//
// ------------------------------------------------------------------------
// Class category: Parser
// ------------------------------------------------------------------------
//
// $Date: 2002/10/05 00:48:29 $
// $Author: dbruhwil $
//
// ------------------------------------------------------------------------

#include "Parser/Token.h"
#include <iosfwd>
#include <list>
#include <string>

#include <Ippl.h>

class Parser;


// class Statement
// ------------------------------------------------------------------------
//  The statement is stored as a list of Token's.

class Statement {

public:

    typedef std::list<Token> TokenList;

    //  Store the stream name and the line where the statement begins.
    Statement(const std::string &name, int line);

    //  Stores a name (e.g. for a macro) and the token list.
    Statement(const std::string &name, TokenList &);

    virtual ~Statement();

    void append(const Token &);

    //  This method is called by the parser in order to find out wether
    //  the end of the statement has been reached.
    bool atEnd() const;

    //  If the next item is a boolean literal:
    //  [ol][li]Set [b]value[/b] to its value.
    //  [li]Skip the value in the token list.
    //  [li]Return true.
    //  [/ol]
    //  Otherwise return false.
    bool boolean(bool &value);

    //  If the next item is the given character,
    //  skip it and return true, otherwise return false.
    bool delimiter(char c);

    //  If the next item is one of the characters in the given string,
    //  skip it and return true, otherwise return false.
    bool delimiter(const char *s);

    //  This method must be specially defined in conditional or loop
    //  statements. Normally it just calls the parser to execute the
    //  statement.
    virtual void execute(const Parser &) = 0;

    Token &getCurrent();

    //  If the next item is an integer:
    //  [ol][li]Set [b]value[/b] to its value.
    //  [li]Skip the value in the token list.
    //  [li]Return true.
    //  [/ol]
    //  Otherwise return false.
    bool integer(int &value);

    //  If the next item is an integer:
    //  [ol][li]Set [b]value[/b] to its value.
    //  [li]Skip the value in the token list.
    //  [li]Return true.
    //  [/ol]
    //  Otherwise return false.
    bool integer(unsigned &value);

    //  If the next item is the keyword [b]s[/b], skip it and return true,
    //  otherwise return false.
    bool keyword(const char *s);

    //  If the next item is a real number:
    //  [ol][li]Set [b]value[/b] to its value.
    //  [li]Skip the value in the token list.
    //  [li]Return true.
    //  [/ol]
    //  Otherwise return false.
    bool real(double &value);

    //  If the next item is a string literal:
    //  [ol][li]Set [b]value[/b] to its value.
    //  [li]Skip the value in the token list.
    //  [li]Return true.
    //  [/ol]
    //  Otherwise return false.
    bool str(std::string &value);

    //  If the next item is a word:
    //  [ol][li]Set [b]value[/b] to its value.
    //  [li]Skip the value in the token list.
    //  [li]Return true.
    //  [/ol]
    //  Otherwise return false.
    bool word(std::string &value);

    //  Parsing can later be resumed by calling restore().
    void mark();

    //  Resume parsing at the position wher mark() was last called.
    void restore();

    //  Resume parsing at the beginning of the statement.
    void start();

    //  Skip tokens up to next comma or end of statement, whichever comes first.
    void skip();

    unsigned int position() const;

    //  Print the statement on [b]os[/b].
    virtual void print(std::ostream &os) const;

    //  Print a message, containing the stream name and its line in the input
    //  stream.  If [b]withToken[/b] is true, print also the last token parsed.
    virtual void printWhere(Inform &msg, bool withToken) const;

protected:

    // Line number where statement begins.
    int stat_line;

    // Input stream name.
    std::string buffer_name;

    // Token list.
    TokenList tokens;
    TokenList::iterator curr;
    TokenList::iterator keep;
};


// Output operator.
inline std::ostream &operator<<(std::ostream &os, const Statement &statement) {
    statement.print(os);
    return os;
}

inline Inform &operator<<(Inform &os, const Statement &statement) {
    std::ostringstream msg;
    statement.print(msg);
    os << msg.str();

    return os;
}

#endif // MAD_Statement_HH