compiler.h

#ifndef SOURCEMETA_BLAZE_COMPILER_COMPILE_H_
#define SOURCEMETA_BLAZE_COMPILER_COMPILE_H_
 
#ifndef SOURCEMETA_BLAZE_COMPILER_EXPORT
#include <sourcemeta/blaze/compiler_export.h>
#endif
 
#include <sourcemeta/blaze/compiler_error.h>
 
#include <sourcemeta/blaze/evaluator.h>
 
#include <sourcemeta/core/json.h>
#include <sourcemeta/core/jsonpointer.h>
#include <sourcemeta/core/jsonschema.h>
#include <sourcemeta/core/uri.h>
 
#include <cassert>       // assert
#include <cstddef>       // std::size_t
#include <cstdint>       // std::uint8_t, std::uint64_t
#include <functional>    // std::function
#include <limits>        // std::numeric_limits
#include <map>           // std::map
#include <optional>      // std::optional, std::nullopt
#include <set>           // std::set
#include <string>        // std::string
#include <string_view>   // std::string_view
#include <tuple>         // std::tuple
#include <unordered_map> // std::unordered_map
#include <unordered_set> // std::unordered_set
#include <vector>        // std::vector

 
namespace sourcemeta::blaze {

struct SchemaUnevaluatedEntry {
  std::set<sourcemeta::core::WeakPointer> static_dependencies;
  std::set<sourcemeta::core::WeakPointer> dynamic_dependencies;
  bool unresolved{false};
};

using SchemaUnevaluatedEntries =
    std::map<sourcemeta::core::JSON::String, SchemaUnevaluatedEntry>;

struct SchemaContext {
  // NOLINTBEGIN(cppcoreguidelines-avoid-const-or-ref-data-members)
  const sourcemeta::core::WeakPointer &relative_pointer;
  const sourcemeta::core::JSON &schema;
  const sourcemeta::core::SchemaVocabularies &vocabularies;
  const sourcemeta::core::URI &base;
  // NOLINTEND(cppcoreguidelines-avoid-const-or-ref-data-members)
  bool is_property_name;
};

struct DynamicContext {
  // NOLINTBEGIN(cppcoreguidelines-avoid-const-or-ref-data-members)
  const sourcemeta::core::JSON::String &keyword;
  const sourcemeta::core::JSON *keyword_value{nullptr};
  const sourcemeta::core::WeakPointer &base_schema_location;
  const sourcemeta::core::WeakPointer &base_instance_location;
  // NOLINTEND(cppcoreguidelines-avoid-const-or-ref-data-members)

  [[nodiscard]] auto value() const -> const sourcemeta::core::JSON & {
    assert(this->keyword_value != nullptr);
    return *this->keyword_value;
  }
};
 
#if !defined(DOXYGEN)
struct Context;
struct KeywordContext;
#endif

using Compiler =
    // TODO(C++23): Use std::move_only_function when available in libc++
    std::function<Instructions(const KeywordContext &, const Instructions &)>;

enum class Mode : std::uint8_t {
  FastValidation,
  Exhaustive
};

class SOURCEMETA_BLAZE_COMPILER_EXPORT InstructionExtras {
public:
  explicit InstructionExtras(const std::uint64_t limit) : limit_{limit} {}

  auto push_back(InstructionExtra &&entry) -> void {
    if (this->entries_.size() >= this->limit_) [[unlikely]] {
      throw CompilerInstructionLimitError{this->limit_};
    }
 
    this->entries_.push_back(std::move(entry));
  }
 
  [[nodiscard]] auto size() const noexcept -> std::size_t {
    return this->entries_.size();
  }
 
  [[nodiscard]] auto operator[](const std::size_t index) const noexcept
      -> const InstructionExtra & {
    return this->entries_[index];
  }
 
  [[nodiscard]] auto operator[](const std::size_t index) noexcept
      -> InstructionExtra & {
    return this->entries_[index];
  }

  [[nodiscard]] auto release() && -> std::vector<InstructionExtra> {
    return std::move(this->entries_);
  }
 
private:
// Exporting symbols that depends on the standard C++ library is considered
// safe.
// https://learn.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-2-c4275?view=msvc-170&redirectedfrom=MSDN
#if defined(_MSC_VER)
#pragma warning(disable : 4251 4275)
#endif
  std::vector<InstructionExtra> entries_;
#if defined(_MSC_VER)
#pragma warning(default : 4251 4275)
#endif
  std::uint64_t limit_;
};

struct Tweaks {
  bool properties_always_unroll{false};
  bool properties_reorder{true};
  std::size_t target_inline_threshold{50};
  bool format_assertion{false};
  std::optional<std::unordered_set<sourcemeta::core::JSON::StringView>>
      annotations{};
  std::uint64_t max_instructions{std::numeric_limits<std::uint64_t>::max()};
  std::uint64_t max_depth{std::numeric_limits<std::uint64_t>::max()};
};

struct Context {
  // NOLINTBEGIN(cppcoreguidelines-avoid-const-or-ref-data-members)
  const sourcemeta::core::JSON &root;
  const sourcemeta::core::SchemaFrame &frame;
  const std::vector<std::string> resources;
  const sourcemeta::core::SchemaWalker &walker;
  const sourcemeta::core::SchemaResolver &resolver;
  const Compiler &compiler;
  const Mode mode;
  const bool uses_dynamic_scopes;
  const bool collects_annotations;
  const SchemaUnevaluatedEntries unevaluated;
  const Tweaks tweaks;
  const std::map<
      std::tuple<sourcemeta::core::SchemaReferenceType, std::string_view, bool>,
      std::pair<std::size_t, const sourcemeta::core::WeakPointer *>>
      targets;
  std::uint64_t &depth;
  InstructionExtras &extra;
  std::vector<sourcemeta::core::SchemaVocabularies::URI> &vocabularies;
  // NOLINTEND(cppcoreguidelines-avoid-const-or-ref-data-members)
};

const sourcemeta::core::JSON::String EMPTY_KEYWORD;

struct KeywordContext {
  // NOLINTBEGIN(cppcoreguidelines-avoid-const-or-ref-data-members)
  const Context &global;
  const SchemaContext &local;
  // NOLINTEND(cppcoreguidelines-avoid-const-or-ref-data-members)
  DynamicContext target;

  [[nodiscard]] auto keyword() const -> const sourcemeta::core::JSON::String & {
    return this->target.keyword;
  }

  [[nodiscard]] auto value() const -> const sourcemeta::core::JSON & {
    return this->target.value();
  }

  [[nodiscard]] auto schema() const -> const sourcemeta::core::JSON & {
    return this->local.schema;
  }

  [[nodiscard]] auto vocabularies() const
      -> const sourcemeta::core::SchemaVocabularies & {
    return this->local.vocabularies;
  }

  [[nodiscard]] auto base() const -> const sourcemeta::core::URI & {
    return this->local.base;
  }

  [[nodiscard]] auto mode() const -> Mode { return this->global.mode; }

  [[nodiscard]] auto relative() const -> KeywordContext {
    return {
        .global = this->global,
        .local = this->local,
        .target = {.keyword = EMPTY_KEYWORD,
                   .base_schema_location = sourcemeta::core::EMPTY_WEAK_POINTER,
                   .base_instance_location =
                       sourcemeta::core::EMPTY_WEAK_POINTER}};
  }
};

auto SOURCEMETA_BLAZE_COMPILER_EXPORT default_schema_compiler(
    const KeywordContext &, const Instructions &) -> Instructions;

auto SOURCEMETA_BLAZE_COMPILER_EXPORT
compile(const sourcemeta::core::JSON &schema,
        const sourcemeta::core::SchemaWalker &walker,
        const sourcemeta::core::SchemaResolver &resolver,
        const Compiler &compiler, const Mode mode = Mode::FastValidation,
        const std::string_view default_dialect = "",
        const std::string_view default_id = "",
        const std::string_view entrypoint = "",
        const std::optional<Tweaks> &tweaks = std::nullopt,
        std::uint64_t max_locations = std::numeric_limits<std::uint64_t>::max())
    -> Template;

auto SOURCEMETA_BLAZE_COMPILER_EXPORT compile(
    const sourcemeta::core::JSON &schema,
    const sourcemeta::core::SchemaWalker &walker,
    const sourcemeta::core::SchemaResolver &resolver, const Compiler &compiler,
    const sourcemeta::core::SchemaFrame &frame,
    const std::string_view entrypoint, const Mode mode = Mode::FastValidation,
    const std::optional<Tweaks> &tweaks = std::nullopt) -> Template;

auto SOURCEMETA_BLAZE_COMPILER_EXPORT
compile(const KeywordContext &context,
        const sourcemeta::core::WeakPointer &schema_suffix,
        const sourcemeta::core::WeakPointer &instance_suffix =
            sourcemeta::core::EMPTY_WEAK_POINTER,
        std::optional<std::string_view> uri = std::nullopt) -> Instructions;

auto SOURCEMETA_BLAZE_COMPILER_EXPORT to_json(const Template &schema_template)
    -> sourcemeta::core::JSON;
 
} // namespace sourcemeta::blaze
 
#endif