ParserPosition.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstdint>
#include <string>
#include <iostream>
 
struct ParserPosition {
    const std::string* filename;
    uint32_t line = 0;
    uint32_t column = 0;
 
    explicit ParserPosition(const std::string* f = nullptr, uint32_t l = 0, uint32_t c = 0)
        : filename(f), line(l), column(c) {}
 
    inline void initialize(const std::string* fn = nullptr, uint32_t l = 0, uint32_t c = 0) {
        filename = fn;
        line = l;
        column = c;
    }
 
    inline void lines(uint32_t count = 1) {
        if (count) {
            column = 0;
            line += count;
        }
    }
 
    inline void columns(uint32_t count = 1) {
        column += count;
    }
};
 
inline ParserPosition& operator+=(ParserPosition& lhs, uint32_t rhs) {
    lhs.columns(rhs);
    return lhs;
}
 
inline ParserPosition operator+(ParserPosition lhs, uint32_t rhs) {
    return lhs += rhs;
}
 
inline std::ostream& operator<<(std::ostream& os, const ParserPosition& pos) {
    if (pos.filename) {
        os << *(pos.filename) << ':';
    }
    return os << pos.line << '.' << pos.column;
}
 
struct ParserLocation {
    ParserPosition begin;
    ParserPosition end;
 
    explicit ParserLocation(const ParserPosition& b, const ParserPosition& e)
        : begin(b), end(e) {}
    
    explicit ParserLocation(const ParserPosition& p = ParserPosition())
        : begin(p), end(p) {}
    
    explicit ParserLocation(const std::string* f, uint32_t l = 0, uint32_t c = 0)
        : begin(f, l, c), end(f, l, c) {}
    
    inline void initialize(const std::string* f = nullptr, uint32_t l = 0, uint32_t c = 0) {
        begin.initialize(f, l, c);
        end = begin;
    }
 
    inline void step() {
        begin = end;
    }
 
    inline void columns(uint32_t count = 1) {
        end.columns(count);
    }
 
    inline void lines(uint32_t count = 1) {
        end.lines(count);
    }
};
 
inline ParserLocation& operator+=(ParserLocation& lhs, uint32_t rhs) {
    lhs.columns(rhs);
    return lhs;
}
 
inline ParserLocation operator+(ParserLocation lhs, uint32_t rhs) {
    return lhs += rhs;
}
 
inline std::ostream& operator<<(std::ostream& os, const ParserLocation& loc) {
    uint32_t end_col = 0 < loc.end.column ? loc.end.column - 1 : 0;
    os << loc.begin;
    if (loc.end.filename && (!loc.begin.filename || *loc.begin.filename != *loc.end.filename)) {
        os << '-' << *(loc.end.filename) << ':' << loc.end.line << '.' << end_col;
    } else if (loc.begin.line < loc.end.line) {
        os << '-' << loc.end.line << '.' << end_col;
    } else if (loc.begin.column < end_col) {
        os << '-' << end_col;
    }
    return os;
}