ah-source.H

Go to the documentation of this file.

/*
                          Aleph_w
 
  Data structures & Algorithms
  version 2.0.0b
  https://github.com/lrleon/Aleph-w
 
  This file is part of Aleph-w library
 
  Copyright (c) 2002-2026 Leandro Rabindranath Leon
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:
 
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
 
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
*/
 
 
# ifndef AH_SOURCE_H
# define AH_SOURCE_H
 
# include <cstddef>
# include <fstream>
# include <sstream>
# include <string>
# include <utility>
 
# include <ah-errors.H>
# include <tpl_dynArray.H>
 
namespace Aleph
{
  using Source_File_Id = size_t;
  using Source_Offset = size_t;
 
  struct Source_Position
  {
    Source_File_Id file_id = 0; 
    std::string file_name; 
    Source_Offset offset = 0; 
    size_t line = 1; 
    size_t column = 1; 
 
    bool is_valid() const noexcept
    {
      return file_id != 0;
    }
 
    std::string to_string() const
    {
      std::ostringstream out;
      if (not file_name.empty())
        out << file_name << ":";
      out << line << ":" << column;
      return out.str();
    }
  };
 
  struct Source_Span
  {
    Source_File_Id file_id = 0; 
    Source_Offset begin = 0; 
    Source_Offset end = 0; 
 
    bool is_valid() const noexcept
    {
      return file_id != 0 and begin <= end;
    }
 
    bool empty() const noexcept
    {
      return begin == end;
    }
 
    size_t size() const noexcept
    {
      return end - begin;
    }
 
    bool contains(const Source_Offset offset) const noexcept
    {
      return begin <= offset and offset < end;
    }
 
    std::string to_string() const
    {
      std::ostringstream out;
      if (not is_valid())
        {
          out << "<invalid-span>";
          return out.str();
        }
 
      out << "#" << file_id << ":[" << begin << "," << end << ")";
      return out.str();
    }
  };
 
  struct Source_File
  {
    Source_File_Id id = 0; 
    std::string name; 
    std::string text; 
    DynArray<Source_Offset> line_starts; 
  };
 
  struct Source_Snippet
  {
    std::string file_name; 
    size_t line = 1; 
    size_t column = 1; 
    std::string line_text; 
    size_t highlight_column = 1; 
    size_t highlight_width = 1; 
  };
 
  class Source_Manager
  {
    DynArray<Source_File> files;
 
    static DynArray<Source_Offset>
    compute_line_starts(const std::string & text)
    {
      DynArray<Source_Offset> starts;
      starts.append(0);
 
      for (size_t i = 0; i < text.size(); ++i)
        if (text[i] == '\n')
          starts.append(i + 1);
 
      return starts;
    }
 
    size_t checked_index(const Source_File_Id id) const
    {
      ah_out_of_range_error_unless(id > 0 and id <= files.size())
        << "Source_Manager: invalid file id " << id;
      return id - 1;
    }
 
    const Source_File & checked_file(const Source_File_Id id) const
    {
      return files.access(checked_index(id));
    }
 
    size_t line_index_from_offset(const Source_File & file,
                                  const Source_Offset off) const
    {
      ah_out_of_range_error_unless(off <= file.text.size())
        << "Source_Manager: offset " << off
        << " out of range for file '" << file.name << "'";
 
      size_t lo = 0;
      size_t hi = file.line_starts.size();
      while (lo + 1 < hi)
        {
          const size_t mid = lo + (hi - lo)/2;
          if (file.line_starts.access(mid) <= off)
            lo = mid;
          else
            hi = mid;
        }
 
      return lo;
    }
 
    size_t line_end_offset(const Source_File & file, const size_t line_idx) const
    {
      ah_out_of_range_error_unless(line_idx < file.line_starts.size())
        << "Source_Manager: invalid line index " << line_idx;
 
      size_t end = line_idx + 1 < file.line_starts.size() ?
          file.line_starts.access(line_idx + 1) : file.text.size();
 
      if (end > file.line_starts.access(line_idx)
          and end <= file.text.size() and file.text[end - 1] == '\n')
        --end;
      if (end > file.line_starts.access(line_idx)
          and end <= file.text.size() and file.text[end - 1] == '\r')
        --end;
 
      return end;
    }
 
  public:
    Source_File_Id add_virtual_file(const std::string & name,
                                    const std::string & text)
    {
      Source_File file;
      file.id = files.size() + 1;
      file.name = name;
      file.text = text;
      file.line_starts = compute_line_starts(file.text);
      files.append(std::move(file));
      return files.size();
    }
 
    Source_File_Id load_file(const std::string & path)
    {
      std::ifstream input(path, std::ios::binary);
      ah_runtime_error_unless(input.is_open())
        << "Source_Manager: cannot open file '" << path << "'";
 
      std::ostringstream out;
      out << input.rdbuf();
      return add_virtual_file(path, out.str());
    }
 
    const Source_File & file(const Source_File_Id id) const
    {
      return checked_file(id);
    }
 
    const std::string & file_name(const Source_File_Id id) const
    {
      return checked_file(id).name;
    }
 
    const std::string & file_text(const Source_File_Id id) const
    {
      return checked_file(id).text;
    }
 
    size_t file_size(const Source_File_Id id) const
    {
      return checked_file(id).text.size();
    }
 
    size_t num_files() const noexcept
    {
      return files.size();
    }
 
    Source_Span span(const Source_File_Id id,
                     const Source_Offset begin,
                     const Source_Offset end) const
    {
      const auto & src = checked_file(id);
      ah_out_of_range_error_unless(begin <= end and end <= src.text.size())
        << "Source_Manager: invalid span [" << begin << ", " << end
        << ") for file '" << src.name << "'";
 
      return {id, begin, end};
    }
 
    Source_Position position(const Source_File_Id id, const Source_Offset off) const
    {
      const auto & src = checked_file(id);
      const size_t line_idx = line_index_from_offset(src, off);
      const Source_Offset line_start = src.line_starts.access(line_idx);
      return {id, src.name, off, line_idx + 1, off - line_start + 1};
    }
 
    Source_Position begin_position(const Source_Span & span) const
    {
      ah_invalid_argument_unless(span.is_valid())
        << "Source_Manager::begin_position(): invalid span";
      return position(span.file_id, span.begin);
    }
 
    Source_Position end_position(const Source_Span & span) const
    {
      ah_invalid_argument_unless(span.is_valid())
        << "Source_Manager::end_position(): invalid span";
      return position(span.file_id, span.end);
    }
 
    std::string slice(const Source_Span & span) const
    {
      ah_invalid_argument_unless(span.is_valid())
        << "Source_Manager::slice(): invalid span";
 
      const auto & src = checked_file(span.file_id);
      ah_out_of_range_error_unless(span.end <= src.text.size())
        << "Source_Manager::slice(): span end out of range";
 
      return src.text.substr(span.begin, span.size());
    }
 
    Source_Snippet snippet(const Source_Span & span) const
    {
      ah_invalid_argument_unless(span.is_valid())
        << "Source_Manager::snippet(): invalid span";
 
      const auto & src = checked_file(span.file_id);
      const auto begin_pos = begin_position(span);
      const size_t line_idx = begin_pos.line - 1;
      const Source_Offset line_begin = src.line_starts.access(line_idx);
      const Source_Offset line_end = line_end_offset(src, line_idx);
 
      Source_Offset clipped_end = span.end;
      if (clipped_end > line_end)
        clipped_end = line_end;
      if (clipped_end < span.begin)
        clipped_end = span.begin;
 
      size_t width = clipped_end - span.begin;
      if (width == 0)
        width = 1;
 
      return {
        src.name,
        begin_pos.line,
        begin_pos.column,
        src.text.substr(line_begin, line_end - line_begin),
        begin_pos.column,
        width
      };
    }
  };
}
 
# endif // AH_SOURCE_H