evaluator.h

#ifndef SOURCEMETA_BLAZE_EVALUATOR_H_
#define SOURCEMETA_BLAZE_EVALUATOR_H_
 
#ifndef SOURCEMETA_BLAZE_EVALUATOR_EXPORT
#include <sourcemeta/blaze/evaluator_export.h>
#endif
 
#include <sourcemeta/blaze/evaluator_error.h>
#include <sourcemeta/blaze/evaluator_instruction.h>
 
#include <sourcemeta/core/json.h>
#include <sourcemeta/core/jsonpointer.h>
#include <sourcemeta/core/regex.h>
 
#include <algorithm>   // std::min, std::any_of, std::find
#include <cassert>     // assert
#include <cstdint>     // std::uint8_t
#include <functional>  // std::function
#include <limits>      // std::numeric_limits
#include <ranges>      // std::ranges
#include <string_view> // std::string_view
#include <utility>     // std::pair
#include <vector>      // std::vector

 
namespace sourcemeta::blaze {

struct Template {
  bool dynamic;
  bool track;
  std::vector<Instructions> targets;
  std::vector<std::pair<std::size_t, std::size_t>> labels;
  std::vector<InstructionExtra> extra;
  std::vector<std::string> vocabularies;
  std::vector<std::string> messages;
};

constexpr std::size_t JSON_VERSION{15};

auto SOURCEMETA_BLAZE_EVALUATOR_EXPORT
from_json(const sourcemeta::core::JSON &json) -> std::optional<Template>;

enum class EvaluationType : std::uint8_t { Pre, Post };

// TODO(C++23): Use std::move_only_function when available in libc++
using Callback = std::function<void(
    const EvaluationType, bool, const Instruction &, const InstructionExtra &,
    const sourcemeta::core::WeakPointer &,
    const sourcemeta::core::WeakPointer &, const sourcemeta::core::JSON &)>;

class SOURCEMETA_BLAZE_EVALUATOR_EXPORT Evaluator {
public:
  auto validate(const Template &schema, const sourcemeta::core::JSON &instance)
      -> bool {
    assert(this->evaluate_path.empty());
    assert(this->instance_location.empty());
    assert(this->resources.empty());
 
    if (schema.track && schema.dynamic) [[unlikely]] {
      this->evaluated.clear();
      return this->evaluate_impl<true, true, false>(schema, instance, nullptr);
    } else if (schema.track) [[unlikely]] {
      this->evaluated.clear();
      return this->evaluate_impl<true, false, false>(schema, instance, nullptr);
    } else if (schema.dynamic) [[unlikely]] {
      return this->evaluate_impl<false, true, false>(schema, instance, nullptr);
    } else {
      return this->evaluate_impl<false, false, false>(schema, instance,
                                                      nullptr);
    }
  }

  auto validate(const Template &schema, const sourcemeta::core::JSON &instance,
                const Callback &callback) -> bool {
    assert(this->evaluate_path.empty());
    assert(this->instance_location.empty());
    assert(this->resources.empty());
    this->evaluated.clear();
    if (schema.dynamic) [[unlikely]] {
      return this->evaluate_impl<true, true, true>(schema, instance, &callback);
    }
 
    return this->evaluate_impl<true, false, true>(schema, instance, &callback);
  }
 
#ifndef DOXYGEN
  template <bool Track, bool Dynamic, bool HasCallback>
  auto evaluate_impl(const Template &schema,
                     const sourcemeta::core::JSON &instance,
                     const Callback *callback) -> bool;
 
  // NOLINTBEGIN(cppcoreguidelines-avoid-non-const-global-variables,cert-err58-cpp,bugprone-throwing-static-initialization)
  static inline const sourcemeta::core::JSON NULL_VALUE{nullptr};
  static inline const sourcemeta::core::JSON EMPTY_STRING{""};
  // NOLINTEND(cppcoreguidelines-avoid-non-const-global-variables,cert-err58-cpp,bugprone-throwing-static-initialization)
 
  // Compute a hash that fits within the IEEE 754 double-precision safe
  // integer range (2^53 - 1), ensuring the serialized template labels
  // are usable from JavaScript and other languages whose numbers are doubles
  [[nodiscard]] static auto hash(const std::size_t resource,
                                 const std::string_view fragment) noexcept
      -> std::size_t {
    constexpr std::size_t MASK{(1ULL << 53) - 1};
    std::size_t result{14695981039346656037ULL & MASK};
    for (const auto byte : fragment) {
      result ^= static_cast<std::size_t>(static_cast<unsigned char>(byte));
      result = (result * 1099511628211ULL) & MASK;
    }
 
    return (resource + result) & MASK;
  }
 
  auto evaluate(const sourcemeta::core::JSON *target) -> void {
    Evaluation mark{.instance = target,
                    .evaluate_path = this->evaluate_path,
                    .skip = false};
    this->evaluated.push_back(std::move(mark));
  }
 
  [[nodiscard]] auto is_evaluated(const sourcemeta::core::JSON *target) const
      -> bool {
    // NOLINTNEXTLINE(modernize-loop-convert)
    for (auto iterator = this->evaluated.rbegin();
         iterator != this->evaluated.rend(); ++iterator) {
      if (target == iterator->instance && !iterator->skip &&
          iterator->evaluate_path.starts_with_initial(this->evaluate_path)) {
        return true;
      }
    }
 
    return false;
  }
 
  auto unevaluate() -> void {
    for (auto &entry : this->evaluated) {
      if (!entry.skip && entry.evaluate_path.starts_with(this->evaluate_path)) {
        entry.skip = true;
      }
    }
  }
 
  // A subschema that ends up failing must not contribute any of the marks it
  // made along the way, so a disjunction records the length here before each
  // branch and truncates back to it when the branch does not hold. Marks are
  // only ever appended, never inserted earlier, so everything a branch adds
  // sits past the recorded length and nothing from outside it can be lost
  [[nodiscard]] auto checkpoint() const -> std::size_t {
    return this->evaluated.size();
  }
 
  auto rewind(const std::size_t checkpoint) -> void {
    assert(checkpoint <= this->evaluated.size());
    this->evaluated.resize(checkpoint);
  }
 
#if defined(_MSC_VER)
#pragma warning(disable : 4251 4275)
#endif
  sourcemeta::core::WeakPointer evaluate_path;
  sourcemeta::core::WeakPointer instance_location;
  std::vector<std::size_t> resources;
 
  struct Evaluation {
    const sourcemeta::core::JSON *instance;
    sourcemeta::core::WeakPointer evaluate_path;
    bool skip;
  };
 
  std::vector<Evaluation> evaluated;
#if defined(_MSC_VER)
#pragma warning(default : 4251 4275)
#endif
#endif
};
 
} // namespace sourcemeta::blaze
 
#ifndef DOXYGEN
 
#include <sourcemeta/blaze/evaluator_dispatch.h>
 
template <bool Track, bool Dynamic, bool HasCallback>
auto sourcemeta::blaze::Evaluator::evaluate_impl(
    const Template &schema, const sourcemeta::core::JSON &instance,
    const Callback *callback) -> bool {
  assert(!schema.targets.empty());
  dispatch::DispatchContext<Track, Dynamic, HasCallback> context{
      .schema = &schema,
      .callback = callback,
      .evaluator = this,
      .property_target = nullptr};
  bool overall{true};
  for (const auto &instruction : schema.targets[0]) {
    if (!dispatch::evaluate_instruction(instruction, instance, 0, context))
        [[unlikely]] {
      overall = false;
      break;
    }
  }
 
  if constexpr (Track || HasCallback) {
    assert(this->evaluate_path.empty());
  }
  if constexpr (HasCallback) {
    assert(this->instance_location.empty());
  }
  if constexpr (Dynamic) {
    assert(this->resources.empty());
  }
 
  return overall;
}
 
#endif // !DOXYGEN
 
#endif