Statement.cpp

Go to the documentation of this file.

// ------------------------------------------------------------------------
// $RCSfile: Statement.cpp,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Class: Statement
//   An abstract base class for all input language statements.
//
// ------------------------------------------------------------------------
// Class category: Parser
// ------------------------------------------------------------------------
//
// $Date: 2000/03/27 09:32:37 $
// $Author: fci $
//
// ------------------------------------------------------------------------
 
#include "OpalParser/Statement.h"
#include <iostream>
#include "OpalParser/Token.h"
 
// Class Statement
// ------------------------------------------------------------------------
 
Statement::Statement(const std::string& name, int line)
    : stat_line(line), buffer_name(name), tokens() {}
 
Statement::Statement(const std::string& name, TokenList& list)
    : stat_line(1), buffer_name(name), tokens() {
    tokens.swap(list);
    curr = tokens.begin();
}
 
Statement::~Statement() { tokens.erase(tokens.begin(), tokens.end()); }
 
void Statement::append(const Token& token) { tokens.push_back(token); }
 
bool Statement::atEnd() const { return TokenList::const_iterator(curr) == tokens.end(); }
 
bool Statement::boolean(bool& value) {
    if (curr != tokens.end() && curr->isWord()) {
        std::string word = curr->getWord();
 
        if (word == "TRUE") {
            value = true;
            ++curr;
            return true;
        } else if (word == "FALSE") {
            value = false;
            ++curr;
            return true;
        }
    }
 
    return false;
}
 
Token& Statement::getCurrent() { return *(curr++); }
 
bool Statement::integer(int& value) {
    if (curr != tokens.end() && curr->isInteger()) {
        value = curr->getInteger();
        ++curr;
        return true;
    } else {
        return false;
    }
}
 
bool Statement::integer(unsigned& value) {
    if (curr != tokens.end() && curr->isInteger()) {
        value = curr->getInteger();
        ++curr;
        return true;
    } else {
        return false;
    }
}
 
bool Statement::delimiter(char c) {
    if (curr != tokens.end() && (*curr).isDel(c)) {
        ++curr;
        return true;
    } else {
        return false;
    }
}
 
bool Statement::delimiter(const char* s) {
    if (curr != tokens.end() && (*curr).isDel(s)) {
        ++curr;
        return true;
    } else {
        return false;
    }
}
 
bool Statement::keyword(const char* key) {
    if (curr != tokens.end() && (*curr).isKey(key)) {
        ++curr;
        return true;
    } else {
        return false;
    }
}
 
bool Statement::real(double& value) {
    if (curr != tokens.end()) {
        if (curr->isReal()) {
            value = curr->getReal();
            ++curr;
            return true;
        } else if (curr->isInteger()) {
            value = double(curr->getInteger());
            ++curr;
            return true;
        }
    }
 
    return false;
}
 
bool Statement::str(std::string& value) {
    if (curr != tokens.end() && curr->isString()) {
        value = curr->getLex();
        ++curr;
        return true;
    } else {
        return false;
    }
}
 
bool Statement::word(std::string& value) {
    if (curr != tokens.end() && curr->isWord()) {
        value = curr->getLex();
        ++curr;
        return true;
    } else {
        return false;
    }
}
 
void Statement::mark() { keep = curr; }
 
void Statement::restore() { curr = keep; }
 
void Statement::start() { curr = tokens.begin(); }
 
void Statement::skip() {
    while (!atEnd() && !(*curr).isDel(','))
        curr++;
}
 
unsigned int Statement::position() const {
    std::ostringstream os;
    bool white = false;
 
    for (TokenList::const_iterator c = tokens.begin(); c != curr; ++c) {
        if (white && !c->isDel()) os << ' ';
        white = !c->isDel();
        os << *c;
    }
    if (white && !std::next(curr)->isDel()) os << ' ';
 
    return os.str().length() - 1;
}
 
void Statement::print(std::ostream& msg) const {
    bool white = false;
 
    for (TokenList::const_iterator c = tokens.begin(); c != tokens.end(); ++c) {
        if (white && !c->isDel()) msg << ' ';
        white = !c->isDel();
        msg << *c;
    }
 
    msg << ';' << std::endl;
}
 
void Statement::printWhere(Inform& msg, bool withToken) const {
    msg << "*** in line " << stat_line << " of file \"" << buffer_name << "\"";
 
    if (withToken) {
        if (TokenList::const_iterator(curr) == tokens.end()) {
            msg << " at end of statement:" << endl;
        } else {
            msg << " before token \"" << *curr << "\":" << endl;
        }
    } else {
        msg << ":\n";
    }
}
 
std::string Statement::str() const {
    std::ostringstream str;
    print(str);
 
    return str.str();
}