Token.cpp

Go to the documentation of this file.

// ------------------------------------------------------------------------
// $RCSfile: Token.cpp,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1.2.2 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Class: Token:
//   Holds a single input token.
//
// ------------------------------------------------------------------------
// Class category: Parser
// ------------------------------------------------------------------------
//
// $Date: 2004/11/12 18:57:54 $
// $Author: adelmann $
//
// ------------------------------------------------------------------------
 
#include "Parser/Token.h"
#include "Utilities/ParseError.h"
#include <cctype>
#include <iostream>
#include <sstream>
 
 
// Class Token
// ------------------------------------------------------------------------
 
Token::Token():
    file(), line(0), type(IS_ERROR), lexeme(),
    d_value(0.0), i_value(0), c_value(0)
{}
 
 
Token::Token(const Token &rhs):
    file(rhs.file), line(rhs.line), type(rhs.type), lexeme(rhs.lexeme),
    d_value(rhs.d_value), i_value(rhs.i_value), c_value(rhs.c_value)
{}
 
 
Token::Token(const std::string &fil, int lin, Type typ, char value):
    file(fil), line(lin), type(typ), lexeme(1u, value),
    d_value(0.0), i_value(0), c_value(value)
{}
 
 
Token::Token(const std::string &fil, int lin, Type typ, const char *value):
    file(fil), line(lin), type(typ), lexeme(value),
    d_value(0.0), i_value(0), c_value(0)
{}
 
 
Token::Token
(const std::string &fil, int lin, Type typ, const std::string &lex):
    file(fil), line(lin), type(typ), lexeme(lex),
    d_value(0.0), i_value(0), c_value(0)
{}
 
 
Token::Token
(const std::string &fil, int lin, const std::string &lex, double value):
    file(fil), line(lin), type(IS_REAL), lexeme(lex),
    d_value(value), i_value(0), c_value(0)
{}
 
 
Token::Token
(const std::string &fil, int lin, const std::string &lex, int value):
    file(fil), line(lin), type(IS_INTEGER), lexeme(lex),
    d_value(0.0), i_value(value), c_value(0)
{}
 
 
Token::~Token()
{}
 
 
const Token &Token::operator=(const Token &rhs) {
    file = rhs.file;
    line = rhs.line;
    type = rhs.type;
    lexeme = rhs.lexeme;
    d_value = rhs.d_value;
    i_value = rhs.i_value;
    c_value = rhs.c_value;
    return *this;
}
 
 
bool Token::isDel(char del) const {
    return (type == IS_DELIMITER  &&  lexeme == std::string(1u, del));
}
 
 
bool Token::isDel(const char *del) const {
    return (type == IS_DELIMITER  &&  lexeme == del);
}
 
 
bool Token::isDel() const {
    return (type == IS_DELIMITER);
}
 
 
bool Token::isEOF() const {
    return (type == IS_EOF);
}
 
 
bool Token::isError() const {
    return (type == IS_ERROR);
}
 
 
bool Token::isInteger() const {
    return (type == IS_INTEGER);
}
 
 
bool Token::isReal() const {
    return (type == IS_REAL);
}
 
 
bool Token::isWord() const {
    return (type == IS_WORD);
}
 
 
bool Token::isString() const {
    return (type == IS_STRING);
}
 
 
bool Token::isKey(const char *key) const {
    return (type == IS_WORD  &&  lexeme == key);
}
 
 
bool Token::getBool() const {
    if(type == IS_WORD) {
        if(lexeme == "TRUE") {
            return true;
        } else if(lexeme == "FALSE") {
            return false;
        }
    }
 
    invalid("boolean");
    return false;
}
 
 
int Token::getInteger() const {
    if(type == IS_INTEGER) {
        return i_value;
    } else if(type == IS_REAL) {
        return int(d_value + 0.5);
    }
 
    invalid("integer");
    return 0;
}
 
 
double Token::getReal() const {
    if(type == IS_INTEGER) {
        return double(i_value);
    } else if(type == IS_REAL) {
        return d_value;
    }
 
    invalid("real");
    return 0.0;
}
 
 
std::string Token::getString() const {
    if(type == IS_STRING) {
        return lexeme;
    }
 
    invalid("string");
    return "";
}
 
 
std::string Token::getWord() const {
    if(type == IS_WORD) {
        return lexeme;
    }
 
    invalid("identifier");
    return "";
}
 
 
const std::string &Token::getLex() const {
    return lexeme;
}
 
 
Token::Type Token::getType() const {
    return type;
}
 
 
const std::string &Token::getFile() const {
    return file;
}
 
 
int Token::getLine() const {
    return line;
}
 
 
std::ostream &operator<<(std::ostream &os, const Token &token) {
    switch(token.getType()) {
 
        case Token::IS_DELIMITER:
            os << token.getLex();
            break;
 
        case Token::IS_EOF:
            os << "End of file";
            break;
 
        case Token::IS_ERROR:
            os << "Error token: " << token.getLex();
            break;
 
        case Token::IS_INTEGER:
            os << token.getInteger();
            break;
 
        case Token::IS_REAL:
            os << token.getReal();
            break;
 
        case Token::IS_WORD:
            os << token.getLex();
            break;
 
        case Token::IS_STRING:
            os << '"' << token.getLex() << '"';
            break;
    }
 
    return os;
}
 
 
void Token::invalid(const char *type) const {
    std::ostringstream os;
    os << "Expected " << type << " token in line " << line << " of file \""
       << file << "\".";
    throw ParseError("Token::invalid()", os.str().c_str());
}