Statement.h

Go to the documentation of this file.

#ifndef OPALX_Statement_HH
#define OPALX_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 <iosfwd>
#include <list>
#include <string>
#include "OpalParser/Token.h"
 
#include "Utility/Inform.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;
 
    std::string str() 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  // OPALX_Statement_HH