Token.h

Go to the documentation of this file.

#ifndef CLASSIC_Token_HH
#define CLASSIC_Token_HH 1

// ------------------------------------------------------------------------
// $RCSfile: Token.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Class: Token
//
// ------------------------------------------------------------------------
// Class category: Parser
// ------------------------------------------------------------------------
//
// $Date: 2000/03/27 09:32:37 $
// $Author: fci $
//
// ------------------------------------------------------------------------

#include <iosfwd>
#include <string>


// Class Token
// ------------------------------------------------------------------------
//  All tokens contain the name of the input stream and the line number
//  where they came from.

class Token {

public:

    enum Type {
        IS_DELIMITER,
        IS_EOF,
        IS_ERROR,
        IS_INTEGER,
        IS_REAL,
        IS_WORD,
        IS_STRING
    };

    //  Construct empty token.
    Token();

    //  Construct character token with type [b]type[/b] and value [b]c[/b].
    Token(const std::string &file, int line, Type type, char c);

    //  Construct std::string token with type [b]type[/b] and value [b]s[/b].
    Token(const std::string &file, int line, Type type, const char *s);

    //  Construct string token with type [b]type[/b] and value [b]lex[/b].
    Token(const std::string &file, int line, Type type, const std::string &lex);

    //  Construct real numeric token with lexeme [b]lex[/b] and value
    //  [b]value[/b].
    Token(const std::string &file, int line, const std::string &lex,
          double value);

    //  Construct integer token with lexeme [b]lex[/b] and value [b]value[/b].
    Token(const std::string &file, int line, const std::string &lex, int value);

    Token(const Token &);
    ~Token();
    const Token &operator=(const Token &);

    //  Return true, if token is single character [b]del[/b].
    bool isDel(char del) const;

    //  Return true, if token is character string [b]del[/b].
    bool isDel(const char *del) const;

    bool isDel()     const;

    bool isEOF() const;

    bool isError() const;

    bool isInteger() const;

    bool isReal() const;

    bool isWord() const;

    bool isString() const;

    bool isKey(const char *key) const;

    //  Throw ParseError, if token is not boolean.
    bool getBool() const;

    //  Throw ParseError, if token is not numeric.
    int getInteger() const;

    //  Throw ParseError, if token is not numeric.
    double getReal() const;

    //  Throw ParseError, if token is not string.
    std::string getString() const;

    //  Throw ParseError, if token is not word.
    std::string getWord() const;

    const std::string &getLex() const;

    Type getType() const;

    const std::string &getFile() const;

    int getLine() const;

private:

    // Invalid token type.
    void invalid(const char *) const;

    // Input line and file.
    std::string file;
    int line;

    // Token type.
    Type type;

    // Lexeme for token.
    std::string lexeme;

    // Value for token.
    double   d_value;
    int      i_value;
    char     c_value;
};


// Output operator.
std::ostream &operator<<(std::ostream &, const Token &);

#endif // CLASSIC_Token_HH