AbsFileStream.cpp

Go to the documentation of this file.

// ------------------------------------------------------------------------
// $RCSfile: AbsFileStream.cpp,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Class: AbsFileStream
//   Implements an abstract input buffer for reading from a file.
//
// ------------------------------------------------------------------------
// Class category: Parser
// ------------------------------------------------------------------------
//
// $Date: 2000/03/27 09:32:37 $
// $Author: fci $
//
// ------------------------------------------------------------------------
 
#include "OpalParser/AbsFileStream.h"
#include <algorithm>
#include <cctype>
#include <iostream>
#include "OpalParser/Token.h"
#include "Utilities/FormatError.h"
 
// Class AbsFileStream
// ------------------------------------------------------------------------
 
AbsFileStream::AbsFileStream(const std::string& name)
    : TokenStream(name), line("\n"), curr_char(0) {}
 
AbsFileStream::~AbsFileStream() {}
 
Token AbsFileStream::readToken() {
    if (put_back_flag) {
        put_back_flag = false;
        return put_back;
    }
 
    // Skip white space.
    while (true) {
        char ch = line[curr_char];
 
        if (ch == '\n') {
            // End of line.
            if (!fillLine()) {
                // End of file.
                return Token(stream_name, curr_line, Token::IS_EOF, "EOF");
            }
        } else if (isspace(ch)) {
            // Skip white space.
            curr_char++;
        } else {
            break;
        }
    }
 
    // First character.
    char ch = line[curr_char];
 
    if (ch == '/') {
        // Skip comments.
        char ch1 = line[curr_char + 1];
        if (ch1 == '/') {
            // C++ like comment.
            if (fillLine()) {
                return readToken();
            } else {
                return Token(stream_name, curr_line, Token::IS_EOF, "EOF");
            }
        } else if (ch1 == '*') {
            // C like comment.
            if (skipComments()) {
                return readToken();
            } else {
                return Token(stream_name, curr_line, Token::IS_ERROR, "Comment not closed.");
            }
        }
    }
 
    if (ch == '"' || ch == '\'') {
        // String token.
        return readString();
    } else if (isalpha(ch)) {
        // Word token.
        return readWord();
    } else if (isdigit(ch) || (ch == '.' && isdigit(line[curr_char + 1]))) {
        // Numeric token.
        return readNumber();
    } else {
        // Delimiter tokens.
        if (ch == '<' && line[curr_char + 1] == '=') {
            curr_char += 2;
            return Token(stream_name, curr_line, Token::IS_DELIMITER, "<=");
        } else if (ch == '>' && line[curr_char + 1] == '=') {
            curr_char += 2;
            return Token(stream_name, curr_line, Token::IS_DELIMITER, ">=");
        } else if (ch == '=' && line[curr_char + 1] == '=') {
            curr_char += 2;
            return Token(stream_name, curr_line, Token::IS_DELIMITER, "==");
        } else if (ch == '!' && line[curr_char + 1] == '=') {
            curr_char += 2;
            return Token(stream_name, curr_line, Token::IS_DELIMITER, "!=");
        } else if (ch == '|' && line[curr_char + 1] == '|') {
            curr_char += 2;
            return Token(stream_name, curr_line, Token::IS_DELIMITER, "||");
        } else if (ch == '&' && line[curr_char + 1] == '&') {
            curr_char += 2;
            return Token(stream_name, curr_line, Token::IS_DELIMITER, "&&");
        } else if (ch == ':' && line[curr_char + 1] == '=') {
            curr_char += 2;
            return Token(stream_name, curr_line, Token::IS_DELIMITER, ":=");
        } else if (ch == '-' && line[curr_char + 1] == '>') {
            curr_char += 2;
            return Token(stream_name, curr_line, Token::IS_DELIMITER, "->");
        } else if (ch == '/' && line[curr_char + 1] == '*') {
            curr_char += 2;
            if (skipComments()) {
                return readToken();
            } else {
                return Token(stream_name, curr_line, Token::IS_ERROR, "Comment not closed.");
            }
        } else {
            curr_char++;
            return Token(stream_name, curr_line, Token::IS_DELIMITER, ch);
        }
    }
 
    return Token(stream_name, curr_line, Token::IS_ERROR, "ERROR");
}
 
Token AbsFileStream::readNumber() {
    bool digit   = false;
    bool eflag   = false;
    double value = 0.0;
    int expsig   = 1;
    int expval   = 0;
    int places   = 0;
    int lex_pos  = curr_char;
 
    while (isdigit(line[curr_char])) {
        // Digits preceding decimal point.
        value = 10.0 * value + double(line[curr_char] - '0');
        digit = true;
        curr_char++;
    }
 
    if (digit && line[curr_char] != '.' && toupper(line[curr_char]) != 'E') {
        // Unsigned integer seen.
        std::string lexeme(line.data() + lex_pos, curr_char - lex_pos);
        return Token(stream_name, curr_line, lexeme, int(value + 0.5));
    }
 
    // Decimal point.
    if (line[curr_char] == '.') {
        curr_char++;
 
        // Digits following decimal point.
        while (isdigit(line[curr_char])) {
            value = 10.0 * value + double(line[curr_char++] - '0');
            digit = true;
            places++;
        }
    }
 
    if (!digit) eflag = true;
 
    // Exponent ?
    if (toupper(line[curr_char]) == 'E') {
        curr_char++;
        digit = false;
 
        if (line[curr_char] == '+') {
            curr_char++;
        } else if (line[curr_char] == '-') {
            curr_char++;
            expsig = -1;
        }
 
        while (isdigit(line[curr_char])) {
            expval = 10 * expval + (line[curr_char++] - '0');
            digit  = true;
        }
 
        if (!digit) eflag = true;
 
        // Skip over any non-punctuation characters.
        char ch = line[curr_char];
 
        while (!isspace(ch) && !ispunct(ch)) {
            eflag = true;
            curr_char++;
            ch = line[curr_char];
        }
    }
 
    // Put pieces together.
    std::string lexeme(line.data() + lex_pos, curr_char - lex_pos);
 
    if (eflag) {
        return Token(
                stream_name, curr_line, 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(stream_name, curr_line, lexeme, value);
    }
}
 
Token AbsFileStream::readString() {
    std::string lexeme;
 
    if (line[curr_char] == '"' || line[curr_char] == '\'') {
        char quote = line[curr_char];
        curr_char++;
 
        while (true) {
            if (line[curr_char] == '\n') {
                return Token(
                        stream_name, curr_line, Token::IS_ERROR,
                        "String \"" + lexeme + "\" not terminated at end of line.");
            }
 
            if (line[curr_char] == quote) {
                curr_char++;
                if (line[curr_char] != quote) break;
            } else if (line[curr_char] == '\\') {
                curr_char++;
            }
 
            lexeme += line[curr_char++];
        }
    }
 
    return Token(stream_name, curr_line, Token::IS_STRING, lexeme);
}
 
Token AbsFileStream::readWord() {
    std::string lexeme;
    char ch = line[curr_char];
 
    if (isalpha(line[curr_char])) {
        lexeme += toupper(ch);
        char ch = line[++curr_char];
 
        while (isalnum(ch) || ch == '_' || ch == '.') {
            lexeme += toupper(ch);
            ch = line[++curr_char];
        }
    }
 
    return Token(stream_name, curr_line, Token::IS_WORD, lexeme);
}
 
bool AbsFileStream::skipComments() {
    curr_char += 2;
 
    while (true) {
        while (line[curr_char] != '\n') {
            if (line[curr_char] == '*' && line[curr_char + 1] == '/') {
                curr_char += 2;
                return true;
            } else if (line[curr_char] == '/' && line[curr_char + 1] == '*') {
                skipComments();
            } else {
                curr_char++;
            }
        }
 
        // End of line
        if (!fillLine()) return false;
    }
}