StringStream.cpp

Go to the documentation of this file.

// ------------------------------------------------------------------------
// $RCSfile: StringStream.cpp,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Class: StringStream
//   Implements an input buffer for reading from a string.
//   This string is intended for storing valid OPALX expressions,
//   it must not contain comments.
//
// ------------------------------------------------------------------------
// Class category: Parser
// ------------------------------------------------------------------------
//
// $Date: 2000/03/27 09:32:37 $
// $Author: fci $
//
// ------------------------------------------------------------------------
 
#include "OpalParser/StringStream.h"
#include <cctype>
#include "OpalParser/Token.h"
#include "Utilities/FormatError.h"
 
// Class StringStream
// ------------------------------------------------------------------------
 
StringStream::StringStream(const std::string& str)
    : TokenStream("expression"), line_m(str + '\n'), currentChar_m(0) {}
 
StringStream::~StringStream() {}
 
Token StringStream::readToken() {
    if (put_back_flag) {
        put_back_flag = false;
        return put_back;
    }
 
    while (true) {
        if (currentChar_m >= line_m.length() || line_m[currentChar_m] == '\n') {
            return Token("string", 1, Token::IS_EOF, "EOF");
        } else if (isspace(line_m[currentChar_m])) {
            currentChar_m++;
        } else {
            break;
        }
    }
 
    // First character.
    char ch = line_m[currentChar_m];
 
    if (ch == '"' || ch == '\'') {
        // String token.
        return readString();
    } else if (isalpha(ch)) {
        // Word token.
        return readWord();
    } else if (isdigit(ch) || (ch == '.' && isdigit(line_m[currentChar_m + 1]))) {
        // Numeric token.
        return readNumber();
    } else {
        // Delimiter tokens.
        if (ch == '<' && line_m[currentChar_m + 1] == '=') {
            currentChar_m += 2;
            return Token("string", 1, Token::IS_DELIMITER, "<=");
        } else if (ch == '>' && line_m[currentChar_m + 1] == '=') {
            currentChar_m += 2;
            return Token("string", 1, Token::IS_DELIMITER, ">=");
        } else if (ch == '=' && line_m[currentChar_m + 1] == '=') {
            currentChar_m += 2;
            return Token("string", 1, Token::IS_DELIMITER, "==");
        } else if (ch == '!' && line_m[currentChar_m + 1] == '=') {
            currentChar_m += 2;
            return Token("string", 1, Token::IS_DELIMITER, "!=");
        } else if (ch == '|' && line_m[currentChar_m + 1] == '|') {
            currentChar_m += 2;
            return Token("string", 1, Token::IS_DELIMITER, "||");
        } else if (ch == '&' && line_m[currentChar_m + 1] == '&') {
            currentChar_m += 2;
            return Token("string", 1, Token::IS_DELIMITER, "&&");
        } else if (ch == ':' && line_m[currentChar_m + 1] == '=') {
            currentChar_m += 2;
            return Token("string", 1, Token::IS_DELIMITER, ":=");
        } else if (ch == '-' && line_m[currentChar_m + 1] == '>') {
            currentChar_m += 2;
            return Token("string", 1, Token::IS_DELIMITER, "->");
        } else {
            currentChar_m++;
            return Token("string", 1, Token::IS_DELIMITER, ch);
        }
    }
 
    return Token(stream_name, curr_line, Token::IS_ERROR, "ERROR");
}
 
Token StringStream::readNumber() {
    bool digit   = false;
    bool eflag   = false;
    double value = 0.0;
    int expsig   = 1;
    int expval   = 0;
    int places   = 0;
    int lex_pos  = currentChar_m;
 
    while (isdigit(line_m[currentChar_m])) {
        // Digits preceding decimal point.
        value = 10.0 * value + double(line_m[currentChar_m] - '0');
        digit = true;
        currentChar_m++;
    }
 
    if (digit && line_m[currentChar_m] != '.' && toupper(line_m[currentChar_m]) != 'E') {
        // Unsigned integer seen.
        std::string lexeme(line_m.data() + lex_pos, currentChar_m - lex_pos);
        return Token("string", 1, lexeme, int(value + 0.5));
    }
 
    // Decimal point.
    if (line_m[currentChar_m] == '.') {
        currentChar_m++;
 
        // Digits following decimal point.
        while (isdigit(line_m[currentChar_m])) {
            value = 10.0 * value + double(line_m[currentChar_m++] - '0');
            digit = true;
            places++;
        }
    }
 
    if (!digit) eflag = true;
 
    // Exponent ?
    if (toupper(line_m[currentChar_m]) == 'E') {
        currentChar_m++;
        digit = false;
 
        if (line_m[currentChar_m] == '+') {
            currentChar_m++;
        } else if (line_m[currentChar_m] == '-') {
            currentChar_m++;
            expsig = -1;
        }
 
        while (isdigit(line_m[currentChar_m])) {
            expval = 10 * expval + (line_m[currentChar_m++] - '0');
            digit  = true;
        }
 
        if (!digit) eflag = true;
 
        // Skip over any non-punctuation characters.
        char ch = line_m[currentChar_m];
 
        while (!isspace(ch) && !ispunct(ch)) {
            eflag = true;
            currentChar_m++;
            ch = line_m[currentChar_m];
        }
    }
 
    // Put pieces together.
    std::string lexeme(line_m.data() + lex_pos, currentChar_m - lex_pos);
 
    if (eflag) {
        return Token("string", 1, Token::IS_ERROR, "Invalid numeric token \"" + lexeme + "\".");
    } else {
        int power = expsig * expval - places;
 
        if (power > 0) {
            for (places = power; places > 0; places--)
                value *= 10.0;
        } else {
            for (places = -power; places > 0; places--)
                value /= 10.0;
        }
 
        return Token("string", 1, lexeme, value);
    }
}
 
Token StringStream::readString() {
    std::string lexeme;
 
    if (line_m[currentChar_m] == '"' || line_m[currentChar_m] == '\'') {
        char quote = line_m[currentChar_m];
        currentChar_m++;
 
        while (true) {
            if (currentChar_m >= line_m.length()) {
                throw FormatError("StringStream::readString()", "String not terminated.");
            }
 
            if (line_m[currentChar_m] == quote) {
                currentChar_m++;
                if (line_m[currentChar_m] != quote) break;
            } else if (line_m[currentChar_m] == '\\') {
                currentChar_m++;
            }
 
            lexeme += line_m[currentChar_m++];
        }
    }
 
    return Token("string", 1, Token::IS_STRING, lexeme);
}
 
Token StringStream::readWord() {
    std::string lexeme;
    char ch = line_m[currentChar_m];
 
    if (isalpha(line_m[currentChar_m])) {
        lexeme += toupper(ch);
        char ch = line_m[++currentChar_m];
 
        while (isalnum(ch) || ch == '_' || ch == '.' || ch == '\'') {
            lexeme += toupper(ch);
            ch = line_m[++currentChar_m];
        }
    }
 
    return Token("string", 1, Token::IS_WORD, lexeme);
}