More file managment.

Author: takev

src/cursor.cpp

@@ -0,0 +1,14 @@
+
+#include "cursor.hpp"
+#include "file.hpp"
+#include <cassert>
+
+namespace hl {
+
+constexpr void cursor::set_line(std::string file_name, size_t line)
+{
+    auto &file = get_file(file_name);
+    _source_file_id = file.id();
+}
+
+}

src/cursor.hpp

@@ -0,0 +1,58 @@
+
+#ifndef HL_CURSOR_HPP
+#define HL_CURSOR_HPP
+
+#include "utf8.hpp"
+#include <cstddef>
+
+
+namespace hl {
+
+class cursor {
+public:
+    constexpr cursor() noexcept = default;
+    constexpr cursor(std::size_t file_id) noexcept : _file_id(file_id), _source_file_id(file_id) {}
+
+    constexpr void set_line(size_t line) noexcept
+    {
+        _source_line = line;
+    }
+
+    /** Synchronize the cursor with the source file.
+     * 
+     * This function should be called after advancing beyond the vertical space
+     * after the #line directive.
+     */
+    constexpr void set_line(std::string file_name, size_t line) noexcept;
+
+    constexpr void set_line(std::size_t line) noexcept
+    {
+        _line = line;
+        _source_line = line;
+        _column = 0;
+    }
+
+    constexpr void advance(char32_t cp) noexcept
+    {
+        if (is_vertical_space(cp)) {
+            ++_line;
+            ++_source_line;
+            _column = 0;
+        } else {
+            ++_column;
+        }
+    }
+
+private:
+    std::size_t _file_id = 0;
+    std::size_t _offset = 0;
+    std::size_t _line = 0;
+    std::size_t _column = 0;
+
+    std::size_t _source_file_id = 0;
+    std::size_t _source_line = 0;
+};
+
+}
+
+#endif

src/file.cpp

@@ -1,10 +1,15 @@
 
 #include "file.hpp"
 #include <vector>
+#include <map>
+#include <memory>
+#include <cassert>
+#include <limits>
 
 namespace hl {
 
-static std::vector<file> files;
+static std::vector<std::unique_ptr<file>> files_by_id;
+static std::map<std::string, file*> files_by_name;
 
 file::file(std::size_t id, std::filesystem::path const& path) : _id(id), _path(path)
 {
@@ -39,4 +44,68 @@ std::filesystem::path const& file::path() const
     return make_file(std::filesystem::path("dummy_file_" + std::to_string(file_id)));
 }
 
+file_handle::file_handle(std::size_t id)
+{
+    assert(id < files.size());
+    _id = id;
+}
+
+file_handle::file_handle(std::string_view path)
+{
+    assert(not path.empty());
+
+
+}
+file_handle(std::filesystem::path const& path);
+
+[[nodiscard]] file *file_handle::operator->() const
+{
+    assert(_id < files_by_id.size());
+    return files_by_id[_id].get();
+}
+
+[[nodiscard]] file &operator*() const
+{
+    assert(_id < files_by_id.size());
+    return *files_by_id[_id];
+}
+
+[[nodiscard]] std::size_t file::read(std::size_t position, std::span<char> buffer) const
+{
+    assert(position < _file_size);
+
+    if (buffer.size() == 0) {
+        return 0; // No data to read
+    }
+
+    auto const _ = std::scoped_lock(_mutex);
+
+    if (not _file_stream.is_open()) {
+        _file_stream.open(_path, std::ios::binary);
+        if (not _file_stream) {
+            throw std::runtime_error("Failed to open file stream: " + _path.string());
+        }
+    }
+
+    _file_stream.seekg(position);
+    if (not _file_stream) {
+        throw std::runtime_error("Failed to seek in file stream: " + _path.string());
+    }
+
+    _file_stream.read(buffer.data(), buffer.size());
+    if (not _file_stream) {
+        throw std::runtime_error("Failed to read from file stream: " + _path.string());
+    }
+
+    return _file_stream.gcount();
+}
+
+void file::close() noexcept
+{
+    auto const _ = std::scoped_lock(_mutex);
+    if (_file_stream.is_open()) {
+        _file_stream.close();
+    }
+}
+
 } // namespace hl

src/file.hpp

@@ -4,11 +4,68 @@
 
 #include <filesystem>
 #include <cstddef>
+#include <string>
+#include <string_view>
+#include <limits>
+#include <memory>
+#include <cassert>
+#include <vector>
+#include <map>
+#include <array>
+#include <span>
+#include <mutex>
 
 namespace hl {
 
 class file {
 public:
+    class handle {
+    public:
+        constexpr handle() noexcept = default;
+        handle(handle const&) noexcept = default;
+        handle(handle&&) noexcept = default;
+        handle& operator=(handle const&) noexcept = default;
+        handle& operator=(handle&&) noexcept = default;
+        [[nodiscard]] friend bool operator==(handle const&, handle const&) noexcept = default;
+
+        [[nodiscard]] explicit operator bool() const noexcept
+        {
+            return _id != std::numeric_limits<std::size_t>::max();
+        }
+
+        [[nodiscard]] std::size_t id() const noexcept
+        {
+            return _id;
+        }
+
+        [[nodiscard]] file* operator->() const;
+        
+        [[nodiscard]] file& operator*() const;
+
+    private:
+        std::size_t _id = std::numeric_limits<std::size_t>::max();
+
+        handle(std::size_t id) : _id(id) {}
+
+        friend class file;
+    };
+
+    class reader {
+    public:
+
+        [[nodiscard]] char32_t operator[](std::size_t index) const
+        {
+            assert(_file != nullptr);
+            assert(index < _lookahead.size());
+            return _lookahead[index];
+        }
+
+    private:
+        file* _file = nullptr;
+        std::size_t _position = 0;
+        std::array<char32_t, 8> _lookahead = {};
+    };
+
     /** Create a file object with the given path.
      *
      * @param path The absolute normalized path to the file.
@@ -25,43 +82,53 @@ class file {
      */
     [[nodiscard]] std::filesystem::path const& path() const;
 
-    /** The file's content.
-     *
-     * @return The content of the file as a string view.
-     */
-    [[nodiscard]] std::string_view view() const;
+    [[nodiscard]] std::size_t size() const noexcept
+    {
+        return _file_size;
+    }
 
-    /** Get the line and column at the offset of the file.
+    /** Read the file content into a buffer.
      *
-     * @param offset The offset in the file.
-     * @return A pair containing the line number (0-based) and column number
-     *        (0-based).
+     * @param position The position in the file to start reading from.
+     * @param buffer The buffer to read the content into.
+     * @return The number of bytes read.
      */
-    [[nodiscard]] std::pair<size_t, size_t> line_column(std::size_t offset) const;
+    [[nodiscard]] std::size_t read(std::size_t position, std::span<char> buffer) const;
+
+    void close() noexcept;
+
+    [[nodiscard]] static handle make_file(std::string_view path);
+    [[nodiscard]] static handle make_file(std::string_view path, handle relative_to);
 
 private:
+    inline static std::vector<std::unique_ptr<file>> _files_by_id;
+    inline static std::map<std::string, file*> _files_by_name;
+
     std::size_t _id = 0;
 
-    /** The absolute normalized path to the file.
+    std::mutex _mutex;
+
+    /** The size of the file in bytes.
+     * 
+     * This is set when the file is read for the first time.
      */
-    std::filesystem::path _path;
+    std::size_t _file_size = 0;
 
-    /** The offset where each line starts in the file.
-     *
-     * The first element is always 0, representing the start of the file.
+    /** The absolute normalized path to the file.
      */
-    std::vector<size_t> _line_offsets;
+    std::filesystem::path _path;
 
     /** Is this file a .hic source file.
      * 
      * This may be false when #line directives are used to track the source of
      * generated code.
      */
     bool _is_source_code = false;
+
+    std::ifstream _file_stream;
 };
 
-[[nodiscard]] file& make_file(std::filesystem::path const& path);
-[[nodiscard]] file& get_file(std::size_t file_id);
+
 
 } // namespace hl