loc.h

Go to the documentation of this file.

#pragma once
 
#include <filesystem>
 
#include "fe/sym.h"
 
namespace fe {
 
/// Pos%ition in a source file; pass around as value.
/// We are only using `uint16_t` for row/col because this allows us to have `sizeof(Loc) == 16`:
/// two machine words, which common 64 bit calling conventions (x86-64 System V, AArch64)
/// still pass and return in registers - with `uint32_t`, every Loc would go through memory instead.
/// @warning Rows/cols beyond 65535 wrap around - and row 0 doubles as the "invalid" sentinel,
/// so Pos%itions in such files silently degrade to invalid/wrong ones.
struct Pos {
    Pos() = default; ///< Creates an invalid Pos%ition.
    Pos(uint16_t row)
        : row(row) {}
    Pos(uint16_t row, uint16_t col)
        : row(row)
        , col(col) {}
 
    explicit operator bool() const { return row != 0; } ///< Is a valid Pos%ition?
    auto operator<=>(const Pos&) const = default;
    void dump() const;
 
    uint16_t row = 0;
    uint16_t col = 0;
 
    /// `fe/loc.h` only declares the stream output and dump helpers.
    /// Include `fe/loc.cpp.h` in exactly one translation unit for the default implementation,
    /// or provide your own definitions instead.
    friend std::ostream& operator<<(std::ostream& os, Pos pos);
};
 
/// Loc%ation in a File.
/// It's only two machine words on a 64 bit arch, so pass around as value.
/// @warning Loc::path is only a pointer and it is your job to guarantee
/// that the underlying `std::filesystem::path` outlives this Loc%ation.
struct Loc {
    Loc() = default; ///< Creates an invalid Loc%ation.
    Loc(const std::filesystem::path* path, Pos begin, Pos finis)
        : path(path)
        , begin(begin)
        , finis(finis) {}
    Loc(const std::filesystem::path* file, Pos pos)
        : Loc(file, pos, pos) {}
    Loc(Pos begin, Pos finis)
        : Loc(nullptr, begin, finis) {}
    Loc(Pos pos)
        : Loc(nullptr, pos, pos) {}
 
    Loc anew_begin() const { return {path, begin, begin}; }
    Loc anew_finis() const { return {path, finis, finis}; }
    Loc operator+(Pos pos) const { return {path, begin, pos}; }
    Loc operator+(Loc loc) const { return {path, begin, loc.finis}; }
    explicit operator bool() const { return (bool)begin; } ///< Is a valid Loc%ation?
    /// @note Loc::path is only checked via pointer equality.
    bool operator==(Loc other) const { return begin == other.begin && finis == other.finis && path == other.path; }
    void dump() const;
 
    const std::filesystem::path* path = {};
    Pos begin                         = {};
    Pos finis                         = {};
    ///< It's called `finis` because it refers to the **last** character within this Loc%ation.
    /// In the STL the word `end` refers to the position of something that is one element **past** the end.
 
    /// `fe/loc.h` only declares the stream output and dump helpers.
    /// Include `fe/loc.cpp.h` in exactly one translation unit for the default implementation,
    /// or provide your own definitions instead.
    friend std::ostream& operator<<(std::ostream& os, Loc loc);
};
 
// Keep Loc at two machine words so it is passed/returned in registers (see Pos).
static_assert(sizeof(void*) != 8 || sizeof(Loc) == 16, "Loc should stay two machine words");
 
} // namespace fe