layout.hpp

Go to the documentation of this file.

 
#ifndef SCILEX_LAYOUT_HPP
#define SCILEX_LAYOUT_HPP
 
#include <cstddef>
#include <limits>
#include <span>
#include <stdexcept>
#include <string>
#include <vector>
 
#include "token.hpp"
 
namespace scilex {
 
  inline constexpr int newline {std::numeric_limits<int>::min() + 1};
  inline constexpr int indent  {std::numeric_limits<int>::min() + 2};
  inline constexpr int dedent  {std::numeric_limits<int>::min() + 3};
 
  // The reserved kinds (this family plus end_of_input and error) must stay mutually distinct — they
  // share the low end of the int range, and a collision would make two reserved kinds indistinguishable.
  static_assert(end_of_input != newline && newline != indent && indent != dedent
                && end_of_input != error && newline != error && indent != error && dedent != error,
                "reserved token kinds must be distinct");
 
  class layout_error : public std::runtime_error
  {
  public:
 
    layout_error(const std::string& message,
                 position           where)
      : std::runtime_error(message),
        where_(where)
    {}
 
    [[nodiscard]] position where() const noexcept
    {
      return where_;
    }
 
  private:
 
    position where_; 
  };
 
  [[nodiscard]] inline std::vector<token> layout(std::span<const token>   tokens,
                                                 const std::vector<bool>& mode_significant = {})
  {
    std::vector<token>       out;
    std::vector<std::size_t> levels        {0};
    bool                     started       {false};
    std::size_t              previous_line {0}; // last *significant* line seen
    position                 end_position  {0, 1, 1};
 
    for (const token& current : tokens) {
      if (current.kind == end_of_input) {
        end_position = current.start; // remember; emit our own terminal at the end
        continue;
      }
      // A token shapes layout unless its mode is marked insignificant. An empty
      // policy makes every token significant — identical to the positional pass.
      const bool significant {mode_significant.empty()
                              || current.mode_id >= mode_significant.size()
                              || mode_significant[current.mode_id]};
      if (significant && (!started || current.start.line != previous_line)) {
        if (started) {
          out.push_back(token {newline, {}, current.start});
        }
        const std::size_t width {current.start.column - 1};
        if (width > levels.back()) {
          levels.push_back(width);
          out.push_back(token {indent, {}, current.start});
        }
        else {
          while (width < levels.back()) {
            levels.pop_back();
            out.push_back(token {dedent, {}, current.start});
          }
          if (width != levels.back()) {
            throw layout_error("inconsistent indentation", current.start);
          }
        }
        previous_line = current.start.line; // only significant lines advance this
        started       = true;
      }
      out.push_back(current); // every token is kept, significant or not
    }
 
    if (started) {
      out.push_back(token {newline, {}, end_position});
    }
    while (levels.back() > 0) {
      levels.pop_back();
      out.push_back(token {dedent, {}, end_position});
    }
    out.push_back(token {end_of_input, {}, end_position});
    return out;
  }
} // namespace scilex
 
#endif // SCILEX_LAYOUT_HPP