rego-cpp/cpp/rego_8hh_source.html

// Copyright (c) Microsoft Corporation.

// Licensed under the MIT License.


#pragma once


#include "rego_c.h"

#include "trieste/logging.h"

#include "trieste/token.h"


#include <initializer_list>

#include <trieste/trieste.h>


namespace rego

{

  using namespace trieste;

  using namespace wf::ops;


  inline const auto Module =

    TokenDef("rego-module", flag::lookup | flag::symtab);

  inline const auto Package = TokenDef("rego-package");

  inline const auto Policy = TokenDef("rego-policy");

  inline const auto Rule = TokenDef(

    "rego-rule",

    flag::lookup | flag::lookdown | flag::symtab | flag::defbeforeuse);

  inline const auto RuleHead = TokenDef("rego-rulehead");

  inline const auto RuleHeadComp = TokenDef("rego-ruleheadcomp");

  inline const auto RuleHeadFunc = TokenDef("rego-ruleheadfunc");

  inline const auto RuleHeadSet = TokenDef("rego-ruleheadset");

  inline const auto RuleHeadObj = TokenDef("rego-ruleheadobj");

  inline const auto RuleArgs = TokenDef("rego-ruleargs");

  inline const auto Query = TokenDef("rego-query");

  inline const auto Literal = TokenDef("rego-literal");

  inline const auto Expr = TokenDef("rego-expr");

  inline const auto ExprInfix = TokenDef("rego-exprinfix");

  inline const auto ExprCall = TokenDef("rego-exprcall");

  inline const auto ExprEvery = TokenDef("rego-exprevery", flag::symtab);

  inline const auto ExprParens = TokenDef("rego-exprparens");

  inline const auto UnaryExpr = TokenDef("rego-unaryexpr");

  inline const auto NotExpr = TokenDef("rego-not-expr");

  inline const auto Term = TokenDef("rego-term");

  inline const auto InfixOperator = TokenDef("rego-infixoperator");

  inline const auto BoolOperator = TokenDef("rego-booloperator");

  inline const auto ArithOperator = TokenDef("rego-arithoperator");

  inline const auto AssignOperator = TokenDef("rego-assignoperator");

  inline const auto BinOperator = TokenDef("rego-binoperator");

  inline const auto Ref = TokenDef("rego-ref");

  inline const auto RefArgBrack = TokenDef("rego-refargbrack");

  inline const auto RefArgDot = TokenDef("rego-refargdot");

  inline const auto Var = TokenDef("rego-var", flag::print);

  inline const auto Scalar = TokenDef("rego-scalar");

  inline const auto String = TokenDef("rego-string");

  inline const auto Array = TokenDef("rego-array");

  inline const auto Object = TokenDef("rego-object");

  inline const auto Set = TokenDef("rego-set");

  inline const auto ObjectItem = TokenDef("rego-objectitem");

  inline const auto RawString = TokenDef("rego-rawstring", flag::print);

  inline const auto JSONString = TokenDef("rego-STRING", flag::print);

  inline const auto Int = TokenDef("rego-INT", flag::print);

  inline const auto Float = TokenDef("rego-FLOAT", flag::print);

  inline const auto True = TokenDef("rego-true");

  inline const auto False = TokenDef("rego-false");

  inline const auto Null = TokenDef("rego-null");

  inline const auto Equals = TokenDef("rego-equals");

  inline const auto NotEquals = TokenDef("rego-notequals");

  inline const auto LessThan = TokenDef("rego-lessthan");

  inline const auto GreaterThan = TokenDef("rego-greaterthan");

  inline const auto LessThanOrEquals = TokenDef("rego-lessthanorequals");

  inline const auto GreaterThanOrEquals = TokenDef("rego-greaterthanorequals");

  inline const auto Add = TokenDef("rego-add");

  inline const auto Subtract = TokenDef("rego-subtract");

  inline const auto Multiply = TokenDef("rego-multiply");

  inline const auto Divide = TokenDef("rego-divide");

  inline const auto Modulo = TokenDef("rego-modulo");

  inline const auto And = TokenDef("rego-and");

  inline const auto Or = TokenDef("rego-or");

  inline const auto Assign = TokenDef("rego-assign");

  inline const auto Unify = TokenDef("rego-unify");

  inline const auto Default = TokenDef("rego-default");

  inline const auto Some = TokenDef("rego-some");

  inline const auto SomeDecl = TokenDef("rego-somedecl");

  inline const auto If = TokenDef("rego-if");

  inline const auto IsIn = TokenDef("rego-in");

  inline const auto Contains = TokenDef("rego-contains");

  inline const auto Else = TokenDef("rego-else");

  inline const auto As = TokenDef("rego-as");

  inline const auto With = TokenDef("rego-with");

  inline const auto Every = TokenDef("rego-every");

  inline const auto ArrayCompr = TokenDef("rego-arraycompr", flag::symtab);

  inline const auto ObjectCompr = TokenDef("rego-objectcompr", flag::symtab);

  inline const auto SetCompr = TokenDef("rego-setcompr", flag::symtab);

  inline const auto Membership = TokenDef("rego-membership");

  inline const auto Not = TokenDef("rego-not");

  inline const auto Import =

    TokenDef("rego-import", flag::lookdown | flag::lookup | flag::shadowing);

  inline const auto Placeholder = TokenDef("rego-placeholder");

  inline const auto Version = TokenDef("rego-version", flag::print);


  // intermediate tokens

  inline const auto RuleBodySeq = TokenDef("rego-rulebodyseq");

  inline const auto ImportSeq = TokenDef("rego-importseq");

  inline const auto RuleRef = TokenDef("rego-ruleref");

  inline const auto RuleHeadType = TokenDef("rego-ruleheadtype");

  inline const auto WithSeq = TokenDef("rego-withseq");

  inline const auto TermSeq = TokenDef("rego-termseq");

  inline const auto ExprSeq = TokenDef("rego-exprseq");

  inline const auto VarSeq = TokenDef("rego-varseq");

  inline const auto RefHead = TokenDef("rego-refhead");

  inline const auto RefArgSeq = TokenDef("rego-refargseq");

  inline const auto Key = TokenDef("rego-key", flag::print);

  inline const auto Val = TokenDef("rego-value");

  inline const auto Undefined = TokenDef("rego-undefined");

  inline const auto Name = TokenDef("rego-name");

  inline const auto Return = TokenDef("rego-return");

  inline const auto Target = TokenDef("rego-target");

  inline const auto Lhs = TokenDef("rego-lhs");

  inline const auto Rhs = TokenDef("rego-rhs");

  inline const auto Src = TokenDef("rego-src");

  inline const auto Args = TokenDef("rego-args");

  inline const auto Idx = TokenDef("rego-idx");

  inline const auto Row = TokenDef("rego-row");

  inline const auto Col = TokenDef("rego-col");


  // other tokens

  inline const auto Results = TokenDef("rego-results", flag::symtab);

  inline const auto Result = TokenDef("rego-result", flag::symtab);

  inline const auto Bindings = TokenDef("rego-bindings");

  inline const auto Terms = TokenDef("rego-terms");

  inline const auto Binding = TokenDef("rego-binding", flag::lookdown);

  inline const auto ErrorCode = TokenDef("rego-errorcode");

  inline const auto ErrorSeq = TokenDef("rego-errorseq");

  inline const auto Line = TokenDef("rego-line", flag::print);


  inline const auto wf_assign_op = Assign | Unify;

  inline const auto wf_arith_op = Add | Subtract | Multiply | Divide | Modulo;

  inline const auto wf_bin_op = And | Or | Subtract;

  inline const auto wf_bool_op = Equals | NotEquals | LessThan |

    LessThanOrEquals | GreaterThan | GreaterThanOrEquals | Not;

  inline const auto wf_exprs =

    Term | ExprCall | ExprInfix | ExprEvery | ExprParens | UnaryExpr;


  // clang-format off

  inline const auto wf =

      (Top <<= Query | Module)

    | (Module <<= Package * Version * ImportSeq * Policy)

    | (ImportSeq <<= Import++)

    | (Import <<= Ref * Var)

    | (Package <<= Ref)

    | (Policy <<= Rule++)

    | (Rule <<= (Default >>= True | False) * RuleHead * RuleBodySeq)

    | (RuleHead <<= RuleRef * (RuleHeadType >>= (RuleHeadSet | RuleHeadObj | RuleHeadFunc | RuleHeadComp)))

    | (RuleRef <<= Var | Ref)

    | (RuleHeadComp <<= Expr)

    | (RuleHeadObj <<= Expr * Expr)

    | (RuleHeadFunc <<= RuleArgs * Expr)

    | (RuleHeadSet <<= Expr)

    | (RuleArgs <<= Term++)

    | (RuleBodySeq <<= (Else | Query)++)

    | (Else <<= Expr * Query)

    | (Query <<= Literal++)

    | (Literal <<= (Expr >>= SomeDecl | Expr | NotExpr) * WithSeq)

    | (WithSeq <<= With++)

    | (With <<= Term * Expr)

    | (SomeDecl <<= ExprSeq * (IsIn >>= Expr | Undefined))

    | (NotExpr <<= Expr)

    | (Expr <<= (Term | ExprCall | ExprInfix | ExprEvery | ExprParens | UnaryExpr))

    | (ExprCall <<= Ref * ExprSeq)

    | (ExprSeq <<= Expr++)

    | (ExprInfix <<= Expr * InfixOperator * Expr)

    | (ExprEvery <<= VarSeq * (IsIn >>= Term | ExprCall | ExprInfix) * Query)

    | (VarSeq <<= Var++[1])

    | (ExprParens <<= Expr)

    | (UnaryExpr <<= Expr)

    | (Membership <<= ExprSeq * Expr)

    | (Term <<= Ref | Var | Scalar | Array | Object | Set | Membership | ArrayCompr | ObjectCompr | SetCompr)

    | (ArrayCompr <<= Expr * Query)

    | (SetCompr <<= Expr * Query)

    | (ObjectCompr <<= Expr * Expr * Query)

    | (InfixOperator <<= AssignOperator | BoolOperator | ArithOperator | BinOperator)

    | (BoolOperator <<= Equals | NotEquals | LessThan | GreaterThan | LessThanOrEquals | GreaterThanOrEquals)

    | (ArithOperator <<= Add | Subtract | Multiply | Divide | Modulo)

    | (BinOperator <<= And | Or)

    | (AssignOperator <<= Assign | Unify)

    | (Ref <<= RefHead * RefArgSeq)

    | (RefHead <<= Var | Array | Object | Set | ArrayCompr | ObjectCompr | SetCompr | ExprCall)

    | (RefArgSeq <<= (RefArgDot | RefArgBrack)++)

    | (RefArgBrack <<= Expr | Placeholder)

    | (RefArgDot <<= Var)

    | (Scalar <<= String | Int | Float | True | False | Null)

    | (String <<= JSONString | RawString)

    | (Array <<= Expr++)

    | (Object <<= ObjectItem++)

    | (ObjectItem <<= (Key >>= Expr) * (Val >>= Expr))

    | (Set <<= Expr++)

    ;

  // clang-format on


  // clang-format off

  inline const auto wf_result =

    (Top <<= Results | Undefined)

    | (Results <<= Result++[1])

    | (Result <<= Terms * Bindings)

    | (Terms <<= Term++)

    | (Bindings <<= Binding++)

    | (Binding <<= (Key >>= Var) * (Val >>= Term))[Key]

    | (Term <<= Scalar | Array | Object | Set)

    | (Array <<= Term++)

    | (Set <<= Term++)

    | (Object <<= ObjectItem++)

    | (ObjectItem <<= (Key >>= Term) * (Val >>= Term))

    | (Scalar <<= JSONString | Int | Float | True | False | Null)

    | (Error <<= ErrorMsg * ErrorAst * ErrorCode)

    ;

  // clang-format on


  struct BuiltInDef;


  using BuiltIn = std::shared_ptr<BuiltInDef>;


  using BuiltInBehavior = std::function<Node(const Nodes&)>;


  //  This is a basic, non-optimized implementation of a big integer


  class BigInt

  {

  public:

    BigInt();

    BigInt(const Location& value);

    BigInt(std::int64_t value);


    const Location& loc() const;

    std::optional<std::int64_t> to_int() const;

    std::optional<std::size_t> to_size() const;


    bool is_negative() const;


    bool is_zero() const;


    BigInt increment() const;

    BigInt decrement() const;

    BigInt abs() const;

    BigInt negate() const;


    static bool is_int(const Location& loc);


    friend BigInt operator+(const BigInt& lhs, const BigInt& rhs);


    friend BigInt operator-(const BigInt& lhs, const BigInt& rhs);


    friend BigInt operator*(const BigInt& lhs, const BigInt& rhs);


    friend BigInt operator/(const BigInt& lhs, const BigInt& rhs);


    friend BigInt operator%(const BigInt& lhs, const BigInt& rhs);


    friend bool operator>(const BigInt& lhs, const BigInt& rhs);


    friend bool operator<(const BigInt& lhs, const BigInt& rhs);


    friend bool operator<=(const BigInt& lhs, const BigInt& rhs);


    friend bool operator>=(const BigInt& lhs, const BigInt& rhs);


    friend bool operator==(const BigInt& lhs, const BigInt& rhs);


    friend bool operator!=(const BigInt& lhs, const BigInt& rhs);


    friend std::ostream& operator<<(std::ostream& os, const BigInt& value);


  private:

    struct DivideResult

    {

      std::string quotient;

      std::string remainder;

    };


    static bool less_than(

      const std::string_view& lhs, const std::string_view& rhs);

    static bool greater_than(

      const std::string_view& lhs, const std::string_view& rhs);

    static bool equal(const std::string_view& lhs, const std::string_view& rhs);

    static std::string add(

      const std::string_view& lhs, const std::string_view& rhs, bool negative);

    static std::string subtract(

      const std::string_view& lhs, const std::string_view& rhs, bool negative);

    static DivideResult divide(

      const std::string_view& lhs, const std::string_view& rhs);

    static std::string multiply(

      const std::string_view& lhs, const std::string_view& rhs);

    std::string_view digits() const;

    Location m_loc;

    static Location Zero;

    static Location One;

  };


  struct UnwrapResult

  {

    Node node;


    bool success;

  };


  class UnwrapOpt

  {

  public:

    UnwrapOpt(std::size_t index);


    bool exclude_got() const;


    UnwrapOpt& exclude_got(bool exclude_got);


    bool specify_number() const;


    UnwrapOpt& specify_number(bool specify_number);


    const std::string& code() const;


    UnwrapOpt& code(const std::string& value);


    const std::string& pre() const;


    UnwrapOpt& pre(const std::string& value);


    const std::string& message() const;


    UnwrapOpt& message(const std::string& value);


    const std::string& func() const;


    UnwrapOpt& func(const std::string& value);


    const std::vector<Token>& types() const;


    UnwrapOpt& types(const std::vector<Token>& value);


    const Token& type() const;


    UnwrapOpt& type(const Token& value);


    Node unwrap(const Nodes& args) const;


  private:

    bool m_exclude_got;

    bool m_specify_number;

    std::string m_code;

    std::string m_prefix;

    std::string m_message;

    std::string m_func;

    std::vector<Token> m_types;

    Token m_type;

    std::size_t m_index;

  };


  Node unwrap_arg(const Nodes& args, const UnwrapOpt& options);


  UnwrapResult unwrap(const Node& term, const Token& type);


  UnwrapResult unwrap(const Node& term, const std::set<Token>& types);


  BigInt get_int(const Node& node);


  std::optional<BigInt> try_get_int(const Node& node);


  double get_double(const Node& node);


  std::optional<double> try_get_double(const Node& node);


  std::string get_string(const Node& node);


  std::optional<std::string> try_get_string(const Node& node);


  bool get_bool(const Node& node);


  std::optional<bool> try_get_bool(const Node& node);


  std::optional<Node> try_get_item(

    const Node& node, const std::string_view& key);


  std::string_view get_raw_string(const Node& node);


  Node scalar(BigInt value);


  Node scalar(double value);


  Node scalar(bool value);


  Node scalar(const char* value);


  Node scalar(const std::string& value);


  Node scalar();


  Node number(double value);


  Node boolean(bool value);


  Node string(const char* value);


  Node string(const std::string& value);


  Node null();


  Node object_item(const Node& key_term, const Node& val_term);


  Node object(const std::initializer_list<Node>& object_items);


  Node array(const std::initializer_list<Node>& array_members);


  Node set(const std::initializer_list<Node>& set_members);


  namespace builtins

  {

    const std::size_t AnyArity = std::numeric_limits<std::size_t>::max();


    inline const auto Decl = TokenDef("rego-builtin-decl");

    inline const auto Arg = TokenDef("rego-builtin-arg");

    inline const auto Args = TokenDef("rego-builtin-args");

    inline const auto VarArgs = TokenDef("rego-builtin-varargs");

    inline const auto Result = TokenDef("rego-builtin-result");

    inline const auto Void = TokenDef("rego-builtin-void");

    inline const auto Return = TokenDef("rego-builtins-return");

    inline const auto Name = TokenDef("rego-builtin-name", flag::print);

    inline const auto Description =

      TokenDef("rego-builtin-description", flag::print);

    inline const auto Type = TokenDef("rego-builtin-type");

    inline const auto ArgSeq = TokenDef("rego-builtin-argseq");

    inline const auto MemberType = TokenDef("rego-builtin-membertype");

    inline const auto TypeSeq = TokenDef("rego-builtin-typeseq");

    inline const auto DynamicArray = TokenDef("rego-builtin-dynamicarray");

    inline const auto StaticArray = TokenDef("rego-builtin-staticarray");

    inline const auto Set = TokenDef("rego-builtin-set");

    inline const auto DynamicObject = TokenDef("rego-builtin-dynamicobject");

    inline const auto StaticObject = TokenDef("rego-builtin-staticobject");

    inline const auto HybridObject = TokenDef("rego-builtin-hybridobject");

    inline const auto ObjectItem = TokenDef("rego-builtin-objectitem");

    inline const auto Any = TokenDef("rego-builtin-any");

    inline const auto String = TokenDef("rego-builtin-string");

    inline const auto Number = TokenDef("rego-builtin-number");

    inline const auto Boolean = TokenDef("rego-builtin-boolean");

    inline const auto Null = TokenDef("rego-builtin-null");


    // clang-format off

    inline const auto wf_decl =

      (Decl <<= (Args >>= ArgSeq | VarArgs) * (Return >>= Result | Void))

      | (ArgSeq <<= Arg++)

      | (Arg <<= Name * Description * Type)

      | (Type <<= Any | String | Number | Boolean | Null | DynamicArray | StaticArray | DynamicObject | StaticObject | HybridObject | Set | TypeSeq)

      | (TypeSeq <<= Type++)

      | (DynamicArray <<= Type)

      | (StaticArray <<= Type++)

      | (Set <<= Type)

      | (DynamicObject <<= (Key >>= Type) * (Val >>= Type))

      | (StaticObject <<= ObjectItem++)

      | (HybridObject <<= DynamicObject * StaticObject)

      | (ObjectItem <<= Name * Type)

      | (Result <<= Name * Description * Type)

      ;

    // clang-format on

  }


  struct BuiltInDef

  {

    Location name;


    Node decl;


    std::size_t arity;


    BuiltInBehavior behavior;


    bool available;


    BuiltInDef(

      Location name_, Node decl_, BuiltInBehavior behavior_, bool available_);


    virtual ~BuiltInDef() = default;


    virtual void clear();


    static BuiltIn create(

      const Location& name, Node decl, BuiltInBehavior behavior);


    static BuiltIn create(

      const Location& name, size_t arity, BuiltInBehavior behavior);


    static BuiltIn placeholder(

      const Location& name, Node decl, const std::string& message);

  };


  typedef BuiltIn (*BuiltInFactory)();


  class BuiltInsDef

  {

  public:

    BuiltInsDef() noexcept;


    bool is_builtin(const Location& name);


    Node decl(const Location& name);


    bool is_deprecated(const Location& version, const Location& name) const;


    Node call(const Location& name, const Location& version, const Nodes& args);


    void clear();


    BuiltInsDef& register_builtin(const BuiltIn& built_in);


    BuiltIn at(const Location& name);


    bool strict_errors() const;


    BuiltInsDef& strict_errors(bool strict_errors);


    template <typename T>


    BuiltInsDef& register_builtins(const T& built_ins)

    {

      for (auto& built_in : built_ins)

      {

        register_builtin(built_in);

      }


      return *this;

    }


    BuiltInsDef& register_standard_builtins();


    template <typename T>


    BuiltInsDef& whitelist(const std::initializer_list<T>& allowed)

    {

      m_lookup_behavior = BuiltInsDef::LookupBehavior::Whitelist;

      m_list.clear();

      m_list.insert(allowed.begin(), allowed.end());

      m_builtins.clear();

      return *this;

    }


    template <typename T>


    BuiltInsDef& whitelist(T begin, T end)

    {

      m_lookup_behavior = BuiltInsDef::LookupBehavior::Whitelist;

      m_list.clear();

      m_list.insert(begin, end);

      m_builtins.clear();

      return *this;

    }


    template <typename T>


    BuiltInsDef& blacklist(const std::initializer_list<T>& forbidden)

    {

      m_lookup_behavior = BuiltInsDef::LookupBehavior::Blacklist;

      m_list.clear();

      m_list.insert(forbidden.begin(), forbidden.end());

      m_builtins.clear();

      return *this;

    }


    template <typename T>


    BuiltInsDef& blacklist(T begin, T end)

    {

      m_lookup_behavior = BuiltInsDef::LookupBehavior::Blacklist;

      m_list.clear();

      m_list.insert(begin, end);

      m_builtins.clear();

      return *this;

    }


    BuiltInsDef& allow_all();


    static std::shared_ptr<BuiltInsDef> create();


  private:

    static BuiltIn lookup(const Location& name);


    enum class LookupBehavior

    {

      AllowAll,

      Whitelist,

      Blacklist

    };


    LookupBehavior m_lookup_behavior;

    std::set<Location> m_list;

    std::map<Location, BuiltIn> m_builtins;

    bool m_strict_errors;

  };


  using BuiltIns = std::shared_ptr<BuiltInsDef>;


  const std::string UnknownError = "unknown_error";

  const std::string EvalTypeError = "eval_type_error";

  const std::string EvalBuiltInError = "eval_builtin_error";

  const std::string RegoTypeError = "rego_type_error";

  const std::string RegoParseError = "rego_parse_error";

  const std::string RegoCompileError = "rego_compile_error";

  const std::string EvalConflictError = "eval_conflict_error";

  const std::string WellFormedError = "wellformed_error";

  const std::string RuntimeError = "runtime_error";

  const std::string RecursionError = "rego_recursion_error";

  const std::string TimeoutError = "timeout_error";

  const std::string DefaultVersion = "v1";


  Node err(

    NodeRange& r,

    const std::string& msg,

    const std::string& code = UnknownError);


  Node err(

    Node node, const std::string& msg, const std::string& code = UnknownError);


  Node version();


  std::string to_key(

    const trieste::Node& node,

    bool set_as_array = false,

    bool sort_arrays = false,

    const char* list_delim = ",");


  enum class LogLevel : regoEnum

  {

    None = REGO_LOG_LEVEL_NONE,

    Error = REGO_LOG_LEVEL_ERROR,

    Output = REGO_LOG_LEVEL_OUTPUT,

    Warn = REGO_LOG_LEVEL_WARN,

    Info = REGO_LOG_LEVEL_INFO,

    Debug = REGO_LOG_LEVEL_DEBUG,

    Trace = REGO_LOG_LEVEL_TRACE

  };


  namespace bundle

  {


    enum class OperandType

    {

      None,

      Local = 1,

      String = 2,

      True = 3,

      False = 4,

      Index,

      Value

    };


    struct Operand

    {

      OperandType type;

      union

      {

        std::int64_t value;

        size_t index;

      };


      Operand();


      static Operand from_op(const Node& n);


      static Operand from_index(const Node& n);


      static Operand from_value(const Node& n);


      friend std::ostream& operator<<(std::ostream& stream, const Operand& op);

    };


    enum class StatementType

    {

      Nop = 0,

      ArrayAppend = 1,

      AssignInt = 2,

      AssignVarOnce = 3,

      AssignVar = 4,

      Block = 5,

      Break = 6,

      CallDynamic = 7,

      Call = 8,

      Dot = 9,

      Equal = 10,

      IsArray = 11,

      IsDefined = 12,

      IsObject = 13,

      IsSet = 14,

      IsUndefined = 15,

      Len = 16,

      MakeArray = 17,

      MakeNull = 18,

      MakeNumberInt = 19,

      MakeNumberRef = 20,

      MakeObject = 21,

      MakeSet = 22,

      NotEqual = 23,

      Not = 24,

      ObjectInsert = 25,

      ObjectInsertOnce = 26,

      ObjectMerge = 27,

      ResetLocal = 28,

      ResultSetAdd = 29,

      ReturnLocal = 30,

      Scan = 31,

      SetAdd = 32,

      With = 33

    };


    struct Statement;


    typedef std::vector<Statement> Block;


    struct CallExt

    {

      Location func;

      std::vector<Operand> ops;

    };


    struct CallDynamicExt

    {

      std::vector<Operand> path;

      std::vector<Operand> ops;

    };


    struct WithExt

    {

      std::vector<size_t> path;

      Block block;

    };


    struct StatementExt

    {

      std::variant<CallExt, CallDynamicExt, WithExt, std::vector<Block>, Block>

        contents;


      const CallExt& call() const;

      const CallDynamicExt& call_dynamic() const;

      const WithExt& with() const;

      const std::vector<Block>& blocks() const;

      const Block& block() const;


      StatementExt(CallExt&& ext);

      StatementExt(CallDynamicExt&& ext);

      StatementExt(WithExt&& ext);

      StatementExt(std::vector<Block>&& blocks);

      StatementExt(Block&& block);

    };


    struct Statement

    {

      StatementType type;

      Location location;


      Operand op0;


      Operand op1;


      std::int32_t target;


      std::shared_ptr<const StatementExt> ext;


      Statement();


      friend std::ostream& operator<<(

        std::ostream& stream, const Statement& stmt);

    };


    struct Plan

    {

      Location name;

      std::vector<Block> blocks;

    };


    struct Function

    {

      Location name;

      size_t arity;

      std::vector<Location> path;

      std::vector<size_t> parameters;

      size_t result;

      std::vector<Block> blocks;

      bool cacheable;

    };


  }


  struct BundleDef;


  typedef std::shared_ptr<BundleDef> Bundle;


  struct BundleDef

  {

    Node data;

    std::map<Location, Node> builtin_functions;

    std::map<Location, size_t> name_to_func;

    std::map<Location, size_t> name_to_plan;

    std::vector<bundle::Plan> plans;

    std::vector<bundle::Function> functions;

    std::vector<Location> strings;

    std::vector<Source> files;

    size_t local_count;

    std::optional<size_t> query_plan;


    Source query;


    std::optional<size_t> find_plan(const Location& name) const;


    std::optional<size_t> find_function(const Location& name) const;


    bool is_function(const Location& name) const;


    void save(std::ostream& stream) const;


    void save(const std::filesystem::path& path) const;


    static Bundle from_node(Node bundle);


    static Bundle load(std::istream& stream);


    static Bundle load(const std::filesystem::path& path);

  };


  class VirtualMachine

  {

  public:

    VirtualMachine();


    Node run_entrypoint(const Location& entrypoint, Node input) const;


    Node run_query(Node input) const;


    VirtualMachine& builtins(BuiltIns builtins);


    BuiltIns builtins() const;


    VirtualMachine& bundle(Bundle bundle);


    Bundle bundle() const;


    size_t stmt_limit() const;


    VirtualMachine& stmt_limit(size_t stmt_limit);


  private:

    typedef std::vector<Node> Frame;


    enum class Code

    {

      Break,

      Continue,

      Undefined,

      MultipleOutputs,

      Return,

      Timeout,

      Error

    };


    class State

    {

    public:

      State(Node input, Node data, size_t num_locals);

      Node read_local(size_t index) const;

      void write_local(size_t index, Node value);

      bool is_defined(size_t key) const;

      void reset_local(size_t key);

      void add_result(Node node);

      const Nodes& result_set() const;

      bool is_in_call_stack(const Location& func_name) const;

      std::string_view root_function_name() const;

      void push_function(const Location& func_name, size_t num_args);

      void pop_function(const Location& func_name);

      const Nodes& errors() const;

      void add_error(Node error);

      void add_error_multiple_output(Node inst);

      void add_error_object_insert(Node inst);

      void put_function_result(const Location& func_name, Node result);

      Node get_function_result(const Location& func_name) const;

      bool in_with() const;

      void push_with();

      void pop_with();

      bool in_break() const;

      void push_break(size_t levels);

      void pop_break();

      size_t stmt_count() const;

      size_t inc_stmts();


    private:

      Frame m_frame;

      Nodes m_errors;

      BuiltIns m_builtins;

      std::vector<Location> m_call_stack;

      std::vector<size_t> m_num_args;

      std::map<Location, Node> m_function_cache;

      Nodes m_result_set;

      size_t m_with_count;

      size_t m_break_count;

      size_t m_stmt_count;

    };


    void run_plan(const bundle::Plan& plan, State& state) const;

    Code run_block(State& state, const bundle::Block& block) const;

    Code run_stmt(

      State& state, size_t index, const bundle::Statement& stmt) const;

    Code run_scan(State& state, const bundle::Statement& stmt) const;

    Code run_with(State& state, const bundle::Statement& stmt) const;

    Code run_call(

      State& state,

      const Location& func,

      const std::vector<bundle::Operand>& args,

      size_t target) const;

    Node dot(const Node& source, const Node& key) const;

    Node merge_objects(const Node& a, const Node& b) const;

    Node merge_sets(const Node& a, const Node& b) const;

    bool insert_into_object(

      const Node& a, const Node& key, const Node& value, bool once) const;

    Node to_term(const Node& value) const;

    Node unpack_operand(

      const State& state, const bundle::Operand& operand) const;

    Node write_and_swap(

      State& state,

      size_t key,

      const std::vector<size_t>& path,

      Node value) const;


    Bundle m_bundle;

    BuiltIns m_builtins;

    RE2 m_int_regex;

    size_t m_stmt_limit;

  };


  class Output

  {

    Node m_node;

    std::string m_json;


  public:

    Output(Node node);


    bool ok() const;


    Node node() const;


    size_t size() const;


    Node expressions_at(size_t index) const;


    Node expressions() const;


    Node binding_at(size_t index, const std::string& name) const;


    Node binding(const std::string& name) const;


    const std::string& json() const;


    std::vector<std::string> errors() const;

  };


  class Interpreter

  {

  public:

    Interpreter();


    Node add_module_file(const std::filesystem::path& path);


    Node add_module(const std::string& name, const std::string& contents);


    Node add_data_json_file(const std::filesystem::path& path);


    Node add_data_json(const std::string& json);


    Node add_data(const Node& node);


    Node set_input_json_file(const std::filesystem::path& path);


    Node set_input_json(const std::string& json);


    Node set_input_term(const std::string& term);


    Node set_input(const Node& node);


    Node set_query(const std::string& query);


    Interpreter& entrypoints(

      const std::initializer_list<std::string>& entrypoints);


    Interpreter& entrypoints(const std::vector<std::string>& entrypoints);


    const std::vector<std::string>& entrypoints() const;


    std::vector<std::string>& entrypoints();


    std::string query();


    std::string query(const std::string& query_expr);


    Node query_node(const std::string& query_expr);


    Node query_node();


    Output query_output(const std::string& query_expr);


    Output query_output();


    // clang-format off


    Node build();


    // clang-format on


    Node save_bundle(const std::filesystem::path& dir, const Node& bundle);


    Node load_bundle(const std::filesystem::path& dir);


    Node query_bundle(const Bundle& bundle);


    Node query_bundle(const Bundle& bundle, const std::string& endpoint);


    Interpreter& debug_path(const std::filesystem::path& prefix);


    const std::filesystem::path& debug_path() const;


    Interpreter& debug_enabled(bool enabled);


    bool debug_enabled() const;


    Interpreter& wf_check_enabled(bool enabled);


    bool wf_check_enabled() const;


    BuiltIns builtins() const;


    std::string output_to_string(const Node& output) const;


    LogLevel log_level() const;


    Interpreter& log_level(LogLevel level);


    Interpreter& log_level(const std::string& level);


    const std::string& c_error() const;


    Interpreter& c_error(const std::string& error);


    size_t stmt_limit() const;


    Interpreter& stmt_limit(size_t stmt_limit);


  private:

    Reader& reader();

    Reader& json();

    Rewriter& data_from_json();

    Rewriter& input_from_json();

    Rewriter& to_input();

    Rewriter& bundle();

    Rewriter& write_bundle();

    Rewriter& read_bundle();


    void merge(const Node& ast);


    Node m_dataseq;

    Node m_moduleseq;

    Node m_input;

    Node m_query;

    std::vector<std::string> m_entrypoints;

    std::filesystem::path m_debug_path;

    bool m_debug_enabled;

    bool m_wf_check_enabled;

    LogLevel m_log_level;


    BuiltIns m_builtins;

    std::unique_ptr<Reader> m_reader;

    std::unique_ptr<Reader> m_json;

    std::unique_ptr<Rewriter> m_data_from_json;

    std::unique_ptr<Rewriter> m_input_from_json;

    std::unique_ptr<Rewriter> m_to_input;

    std::unique_ptr<Rewriter> m_bundle;

    std::unique_ptr<Rewriter> m_write_bundle;

    std::unique_ptr<Rewriter> m_read_bundle;

    VirtualMachine m_vm;

    std::size_t m_data_count;

    std::map<std::string, Node> m_cache;


    std::string m_c_error;

  };


  LogLevel log_level_from_string(const std::string& value);


  inline const auto RegoBundle = TokenDef("rego-bundle", flag::symtab);

  inline const auto Data = TokenDef("rego-data");

  inline const auto ModuleFile = TokenDef("rego-modulefile");

  inline const auto Static = TokenDef("rego-static");

  inline const auto BuiltInFunction = TokenDef("rego-builtinfunction");

  inline const auto Plan = TokenDef("rego-plan", flag::lookup | flag::symtab);

  inline const auto Block = TokenDef("rego-block");

  inline const auto Function =

    TokenDef("rego-function", flag::lookup | flag::symtab);

  inline const auto LocalIndex = TokenDef("rego-localindex", flag::print);

  inline const auto Operand = TokenDef("rego-operand");

  inline const auto Int32 = TokenDef("rego-int32", flag::print);

  inline const auto Int64 = TokenDef("rego-int64", flag::print);

  inline const auto UInt32 = TokenDef("rego-uint32", flag::print);

  inline const auto StringIndex = TokenDef("rego-stringindex", flag::print);

  inline const auto Boolean = TokenDef("rego-boolean", flag::print);

  inline const auto IRString = TokenDef("rego-irstring", flag::print);

  inline const auto IRQuery = TokenDef("rego-irquery");

  inline const auto IRPath = TokenDef("rego-irpath");


  // sequences

  inline const auto BlockSeq = TokenDef("rego-blockseq");

  inline const auto ParameterSeq = TokenDef("rego-parameterseq");

  inline const auto PlanSeq = TokenDef("rego-planseq");

  inline const auto FunctionSeq = TokenDef("rego-functionseq");

  inline const auto BuiltInFunctionSeq = TokenDef("rego-builtinfunctionseq");

  inline const auto StringSeq = TokenDef("rego-stringseq");

  inline const auto PathSeq = TokenDef("rego-pathseq");

  inline const auto OperandSeq = TokenDef("rego-operandseq");

  inline const auto Int32Seq = TokenDef("rego-int32seq");

  inline const auto EntryPointSeq = TokenDef("rego-entrypointseq");

  inline const auto ModuleFileSeq = TokenDef("rego-modulefileseq");


  // Statements

  inline const auto ArrayAppendStmt = TokenDef("rego-arrayappendstmt");

  inline const auto AssignIntStmt = TokenDef("rego-assignintstmt");

  inline const auto AssignVarOnceStmt = TokenDef("rego-assignvaroncestmt");

  inline const auto AssignVarStmt = TokenDef("rego-assignvarstmt");

  inline const auto BlockStmt = TokenDef("rego-blockstmt");

  inline const auto BreakStmt = TokenDef("rego-breakstmt");

  inline const auto CallDynamicStmt = TokenDef("rego-calldynamicstmt");

  inline const auto CallStmt = TokenDef("rego-callstmt");

  inline const auto DotStmt = TokenDef("rego-dotstmt");

  inline const auto EqualStmt = TokenDef("rego-equalstmt");

  inline const auto IsArrayStmt = TokenDef("rego-isarraystmt");

  inline const auto IsDefinedStmt = TokenDef("rego-isdefinedstmt");

  inline const auto IsObjectStmt = TokenDef("rego-isobjectstmt");

  inline const auto IsSetStmt = TokenDef("rego-issetstmt");

  inline const auto IsUndefinedStmt = TokenDef("rego-isundefinedstmt");

  inline const auto LenStmt = TokenDef("rego-lenstmt");

  inline const auto MakeArrayStmt = TokenDef("rego-makearraystmt");

  inline const auto MakeNullStmt = TokenDef("rego-makenullstmt");

  inline const auto MakeNumberIntStmt = TokenDef("rego-makenumberintstmt");

  inline const auto MakeNumberRefStmt = TokenDef("rego-makenumberrefstmt");

  inline const auto MakeObjectStmt = TokenDef("rego-makeobjectstmt");

  inline const auto MakeSetStmt = TokenDef("rego-makesetstmt");

  inline const auto NotEqualStmt = TokenDef("rego-notequalstmt");

  inline const auto NotStmt = TokenDef("rego-notstmt");

  inline const auto ObjectInsertOnceStmt =

    TokenDef("rego-objectinsertoncestmt");

  inline const auto ObjectInsertStmt = TokenDef("rego-objectinsertstmt");

  inline const auto ObjectMergeStmt = TokenDef("rego-objectmergestmt");

  inline const auto ResetLocalStmt = TokenDef("rego-resetlocalstmt");

  inline const auto ResultSetAddStmt = TokenDef("rego-resultsetaddstmt");

  inline const auto ReturnLocalStmt = TokenDef("rego-returnlocalstmt");

  inline const auto ScanStmt = TokenDef("rego-scanstmt");

  inline const auto SetAddStmt = TokenDef("rego-setaddstmt");

  inline const auto WithStmt = TokenDef("rego-withstmt");


  // other tokens

  inline const auto Blocks = TokenDef("rego-blocks");

  inline const auto Func = TokenDef("rego-func");

  inline const auto Capacity = TokenDef("rego-capacity");

  inline const auto Stmt = TokenDef("rego-stmt");


  inline const auto wf_ir_statements = ArrayAppendStmt | AssignIntStmt |

    AssignVarOnceStmt | AssignVarStmt | BlockStmt | BreakStmt |

    CallDynamicStmt | CallStmt | DotStmt | EqualStmt | IsArrayStmt |

    IsDefinedStmt | IsObjectStmt | IsSetStmt | IsUndefinedStmt | LenStmt |

    MakeArrayStmt | MakeNullStmt | MakeNumberIntStmt | MakeNumberRefStmt |

    MakeObjectStmt | MakeSetStmt | NotEqualStmt | NotStmt |

    ObjectInsertOnceStmt | ObjectInsertStmt | ObjectMergeStmt | ResetLocalStmt |

    ResultSetAddStmt | ReturnLocalStmt | ScanStmt | SetAddStmt | WithStmt;


  // clang-format off

  inline const auto wf_bundle =

    builtins::wf_decl

    | wf_result

    | (Top <<= RegoBundle)

    | (RegoBundle <<= Data * Policy * ModuleFileSeq)

    | (ModuleFileSeq <<= ModuleFile++)

    | (ModuleFile <<= (Name >>= IRString) * (Contents >>= IRString))

    | (Data <<= rego::Object)

    | (Policy <<= Static * PlanSeq * IRQuery * FunctionSeq)

    | (IRQuery <<= (IRString|Undefined))

    | (Static <<= StringSeq * PathSeq * BuiltInFunctionSeq)

    | (StringSeq <<= IRString++)

    | (BuiltInFunctionSeq <<= BuiltInFunction++)

    | (BuiltInFunction <<= (Name >>= IRString) * builtins::Decl)

    | (PathSeq <<= IRString++)

    | (PlanSeq <<= Plan++[1])

    | (Plan <<= (Name >>= IRString) * BlockSeq)

    | (BlockSeq <<= Block++)

    | (Block <<= wf_ir_statements++)

    | (FunctionSeq <<= Function++)

    | (Function <<= (Name >>= IRString) * IRPath * ParameterSeq * (Return >>= LocalIndex) * BlockSeq)[Name]

    | (IRPath <<= IRString++[1])

    | (ParameterSeq <<= LocalIndex++)

    | (ArrayAppendStmt <<= (Array >>= LocalIndex) * (Val >>= Operand))

    | (AssignIntStmt <<= (Val >>= Int64) * (Target >>= LocalIndex))

    | (AssignVarOnceStmt <<= (Src >>= Operand) * (Target >>= LocalIndex))

    | (AssignVarStmt <<= (Src >>= Operand) * (Target >>= LocalIndex))

    | (BlockStmt <<= (Blocks >>= BlockSeq))

    | (BreakStmt <<= (Idx >>= UInt32))

    | (CallDynamicStmt <<= (Func >>= OperandSeq) * (Args >>= OperandSeq) * (Result >>= LocalIndex))

    | (CallStmt <<= (Func >>= IRString) * (Args >>= OperandSeq) * (Result >>= LocalIndex))

    | (DotStmt <<= (Src >>= Operand) * (Key >>= Operand) * (Target >>= LocalIndex))

    | (EqualStmt <<= (Lhs >>= Operand) * (Rhs >>= Operand))

    | (IsArrayStmt <<= (Src >>= Operand))

    | (IsDefinedStmt <<= (Src >>= LocalIndex))

    | (IsObjectStmt <<= (Src >>= Operand))

    | (IsSetStmt <<= (Src >>= Operand))

    | (IsUndefinedStmt <<= (Src >>= LocalIndex))

    | (LenStmt <<= (Src >>= Operand) * (Target >>= LocalIndex))

    | (MakeArrayStmt <<= (Capacity >>= Int32) * (Target >>= LocalIndex))

    | (MakeNullStmt <<= (Target >>= LocalIndex))

    | (MakeNumberIntStmt <<= (Val >>= Int64) * (Target >>= LocalIndex))

    | (MakeNumberRefStmt <<= (Idx >>= Int32) * (Target >>= LocalIndex))

    | (MakeObjectStmt <<= (Target >>= LocalIndex))

    | (MakeSetStmt <<= (Target >>= LocalIndex))

    | (NotEqualStmt <<= (Lhs >>= Operand) * (Rhs >>= Operand))

    | (NotStmt <<= Block)

    | (ObjectInsertOnceStmt <<= (Key >>= Operand) * (Val >>= Operand) * (Object >>= LocalIndex))

    | (ObjectInsertStmt <<= (Key >>= Operand) * (Val >>= Operand) * (Object >>= LocalIndex))

    | (ObjectMergeStmt <<= (Lhs >>= LocalIndex) * (Rhs >>= LocalIndex) * (Target >>= LocalIndex))

    | (ResetLocalStmt <<= (Target >>= LocalIndex))

    | (ResultSetAddStmt <<= (Val >>= LocalIndex))

    | (ReturnLocalStmt <<= (Src >>= LocalIndex))

    | (ScanStmt <<= (Src >>= LocalIndex) * (Key >>= LocalIndex) * (Val >>= LocalIndex) * Block)

    | (SetAddStmt <<= (Val >>= Operand) * (Set >>= LocalIndex))

    | (WithStmt <<= LocalIndex * (Path >>= Int32Seq) * (Val >>= Operand) * Block)

    | (Operand <<= LocalIndex | Boolean | StringIndex)

    | (OperandSeq <<= Operand++)

    | (Int32Seq <<= Int32++)

    ;

  // clang-format on


  Reader file_to_rego();


  Rewriter rego_to_input();


  Rewriter json_to_rego(bool as_term = false);


  Rewriter rego_to_json();


  Rewriter rego_to_yaml();


  Rewriter json_to_bundle();


  Rewriter bundle_to_json();


  Rewriter rego_to_bundle(BuiltIns builtins = BuiltInsDef::create());

}


rego::BigInt
Big Integer implemention based on strings.
Definition rego.hh:240

rego::BigInt::operator+
friend BigInt operator+(const BigInt &lhs, const BigInt &rhs)
Adds two BigInts.

rego::BigInt::to_size
std::optional< std::size_t > to_size() const
Attempts to convert the BigInt to a size_t integer.

rego::BigInt::operator*
friend BigInt operator*(const BigInt &lhs, const BigInt &rhs)
Multiplies two BigInts.

rego::BigInt::operator<
friend bool operator<(const BigInt &lhs, const BigInt &rhs)
Compares two BigInts for less-than.

rego::BigInt::operator>
friend bool operator>(const BigInt &lhs, const BigInt &rhs)
Compares two BigInts for greater-than.

rego::BigInt::to_int
std::optional< std::int64_t > to_int() const
Attempts to convert the BigInt to a 64-bit integer.

rego::BigInt::operator-
friend BigInt operator-(const BigInt &lhs, const BigInt &rhs)
Subtracts two BigInts.

rego::BigInt::negate
BigInt negate() const
Negates the BigInt.

rego::BigInt::operator!=
friend bool operator!=(const BigInt &lhs, const BigInt &rhs)
Compares two BigInts for inequality.

rego::BigInt::is_negative
bool is_negative() const
Checks if the BigInt is negative.

rego::BigInt::operator<=
friend bool operator<=(const BigInt &lhs, const BigInt &rhs)
Compares two BigInts for less-than-or-equal.

rego::BigInt::is_int
static bool is_int(const Location &loc)
Checks if a Location represents a valid integer string.

rego::BigInt::operator%
friend BigInt operator%(const BigInt &lhs, const BigInt &rhs)
Computes the remainder of dividing two BigInts.

rego::BigInt::is_zero
bool is_zero() const
Checks if the BigInt is zero.

rego::BigInt::operator==
friend bool operator==(const BigInt &lhs, const BigInt &rhs)
Compares two BigInts for equality.

rego::BigInt::increment
BigInt increment() const
Increments the BigInt by one.

rego::BigInt::BigInt
BigInt(std::int64_t value)
Constructs a BigInt from a 64-bit integer.

rego::BigInt::BigInt
BigInt()
Default constructor, initializes to zero.

rego::BigInt::BigInt
BigInt(const Location &value)
Constructs a BigInt from a Location representing a arbitrary precision integer string.

rego::BigInt::loc
const Location & loc() const
Gets the Location representing the integer string.

rego::BigInt::operator/
friend BigInt operator/(const BigInt &lhs, const BigInt &rhs)
Divides two BigInts.

rego::BigInt::decrement
BigInt decrement() const
Decrements the BigInt by one.

rego::BigInt::operator<<
friend std::ostream & operator<<(std::ostream &os, const BigInt &value)
Outputs a BigInt to a stream.

rego::BigInt::abs
BigInt abs() const
Gets the absolute value of the BigInt.

rego::BigInt::operator>=
friend bool operator>=(const BigInt &lhs, const BigInt &rhs)
Compares two BigInts for greater-than-or-equal.

rego::BuiltInsDef
Manages the set of builtins used by an interpreter to resolve built-in calls.
Definition rego.hh:870

rego::BuiltInsDef::create
static std::shared_ptr< BuiltInsDef > create()
Creates the standard builtin set.

rego::BuiltInsDef::is_builtin
bool is_builtin(const Location &name)
Determines whether the provided name refers to a built-in.

rego::BuiltInsDef::is_deprecated
bool is_deprecated(const Location &version, const Location &name) const
Determines whether the provided builtin name is deprecated in the provided version.

rego::BuiltInsDef::strict_errors
bool strict_errors() const
Whether to throw built-in errors.

rego::BuiltInsDef::call
Node call(const Location &name, const Location &version, const Nodes &args)
Calls the built-in with the provided name and arguments.

rego::BuiltInsDef::blacklist
BuiltInsDef & blacklist(const std::initializer_list< T > &forbidden)
Sets a blacklist of built-in names that are forbidden from being loaded.
Definition rego.hh:984

rego::BuiltInsDef::clear
void clear()
Called to clear any persistent state or caching.

rego::BuiltInsDef::allow_all
BuiltInsDef & allow_all()
Allow all built-ins to be loaded from the standard library.

rego::BuiltInsDef::register_builtins
BuiltInsDef & register_builtins(const T &built_ins)
Registers a set of built-ins.
Definition rego.hh:930

rego::BuiltInsDef::register_standard_builtins
BuiltInsDef & register_standard_builtins()
This method no longer needs to be called.

rego::BuiltInsDef::whitelist
BuiltInsDef & whitelist(T begin, T end)
Sets a whitelist of built-in names that are allowed to be loaded.
Definition rego.hh:968

rego::BuiltInsDef::blacklist
BuiltInsDef & blacklist(T begin, T end)
Sets a blacklist of built-in names that are forbidden from being loaded.
Definition rego.hh:1002

rego::BuiltInsDef::whitelist
BuiltInsDef & whitelist(const std::initializer_list< T > &allowed)
Sets a whitelist of built-in names that are allowed to be loaded.
Definition rego.hh:951

rego::BuiltInsDef::at
BuiltIn at(const Location &name)
Gets the built-in with the provided name.

rego::BuiltInsDef::BuiltInsDef
BuiltInsDef() noexcept
Constructor.

rego::BuiltInsDef::register_builtin
BuiltInsDef & register_builtin(const BuiltIn &built_in)
Registers a built-in.

rego::BuiltInsDef::decl
Node decl(const Location &name)
Gets the declaration node for the specified built-in.

rego::Interpreter
This class forms the main interface to the Rego library.
Definition rego.hh:1682

rego::Interpreter::query_bundle
Node query_bundle(const Bundle &bundle)
Performs a query against a bundle.

rego::Interpreter::debug_path
Interpreter & debug_path(const std::filesystem::path &prefix)
The path to the debug directory.

rego::Interpreter::query
std::string query(const std::string &query_expr)
Executes a query against the interpreter.

rego::Interpreter::add_module
Node add_module(const std::string &name, const std::string &contents)
Adds a module (i.e. virtual document) to the interpreter.

rego::Interpreter::debug_path
const std::filesystem::path & debug_path() const
Gets the debug path.

rego::Interpreter::set_input_term
Node set_input_term(const std::string &term)
Sets the input term of the interpreter.

rego::Interpreter::query
std::string query()
Executes the documents against the interpreter.

rego::Interpreter::add_data_json_file
Node add_data_json_file(const std::filesystem::path &path)
Adds a base document to the interpreter.

rego::Interpreter::stmt_limit
Interpreter & stmt_limit(size_t stmt_limit)
Sets the maximum number of statements that will execute before a timeout.

rego::Interpreter::set_input_json_file
Node set_input_json_file(const std::filesystem::path &path)
Sets the input document to the interpreter.

rego::Interpreter::entrypoints
Interpreter & entrypoints(const std::initializer_list< std::string > &entrypoints)
Sets the entrypoints to include when building a bundle.

rego::Interpreter::save_bundle
Node save_bundle(const std::filesystem::path &dir, const Node &bundle)
Saves a bundle to a directory in JSON format.

rego::Interpreter::query_bundle
Node query_bundle(const Bundle &bundle, const std::string &endpoint)
Performs a query against a bundle.

rego::Interpreter::log_level
LogLevel log_level() const
Returns the current log level of this interpreter.

rego::Interpreter::set_input_json
Node set_input_json(const std::string &json)
Sets the input document to the interpreter.

rego::Interpreter::wf_check_enabled
bool wf_check_enabled() const
Checks if well-formedness checks are enabled.

rego::Interpreter::log_level
Interpreter & log_level(LogLevel level)
Sets the log level of the interpreter.

rego::Interpreter::query_output
Output query_output(const std::string &query_expr)
Executes a query against the interpreter.

rego::Interpreter::set_input
Node set_input(const Node &node)
Sets the input document to the interpreter.

rego::Interpreter::builtins
BuiltIns builtins() const
The built-ins used by the interpreter.

rego::Interpreter::entrypoints
std::vector< std::string > & entrypoints()
Gets the entrypoints to include when building a bundle.

rego::Interpreter::output_to_string
std::string output_to_string(const Node &output) const
Converts an output node into a human-readable string.

rego::Interpreter::c_error
Interpreter & c_error(const std::string &error)
Sets the most recent error message.

rego::Interpreter::add_data_json
Node add_data_json(const std::string &json)
Adds a base document to the interpreter.

rego::Interpreter::Interpreter
Interpreter()
Constructor.

rego::Interpreter::query_output
Output query_output()
Executes a query against the interpreter.

rego::Interpreter::query_node
Node query_node()
Executes a query against the interpreter.

rego::Interpreter::log_level
Interpreter & log_level(const std::string &level)
Sets the logging level for the interpreter from a string.

rego::Interpreter::entrypoints
const std::vector< std::string > & entrypoints() const
Gets the entrypoints to include when building a bundle.

rego::Interpreter::query_node
Node query_node(const std::string &query_expr)
Executes a query against the interpreter.

rego::Interpreter::wf_check_enabled
Interpreter & wf_check_enabled(bool enabled)
Sets whether well-formedness checks are enabled.

rego::Interpreter::load_bundle
Node load_bundle(const std::filesystem::path &dir)
Loads a bundle in JSON format from a direction.

rego::Interpreter::entrypoints
Interpreter & entrypoints(const std::vector< std::string > &entrypoints)
Sets the entrypoints to include when building a bundle.

rego::Interpreter::build
Node build()
Builds a bundle from the current state of the interpreter.

rego::Interpreter::stmt_limit
size_t stmt_limit() const
Gets the maximum number of statements that will execute before a timeout.

rego::Interpreter::debug_enabled
bool debug_enabled() const
Checks if debug mode is enabled.

rego::Interpreter::add_data
Node add_data(const Node &node)
Adds a base document to the interpreter.

rego::Interpreter::debug_enabled
Interpreter & debug_enabled(bool enabled)
Sets whether debug mode is enabled.

rego::Interpreter::c_error
const std::string & c_error() const
Returns a string representing the most recent error message.

rego::Interpreter::add_module_file
Node add_module_file(const std::filesystem::path &path)
Adds a module (i.e. virtual document) file to the interpreter.

rego::Interpreter::set_query
Node set_query(const std::string &query)
Sets the query expression of the interpreter.

rego::Output
Encapsulates the output of a Rego query.
Definition rego.hh:1613

rego::Output::binding_at
Node binding_at(size_t index, const std::string &name) const
Gets the binding for the specified name at the specified result index.

rego::Output::json
const std::string & json() const
Gets the JSON representation of the output.

rego::Output::errors
std::vector< std::string > errors() const
Gets the errors in the output.

rego::Output::size
size_t size() const
Gets the number of results.

rego::Output::expressions_at
Node expressions_at(size_t index) const
Gets the expressions for the result at the specified index.

rego::Output::binding
Node binding(const std::string &name) const
Gets the binding for the specified name at the first result.

rego::Output::node
Node node() const
Gets the underlying node.

rego::Output::expressions
Node expressions() const
Gets the expressions for the first result.

rego::Output::Output
Output(Node node)
Constructor.

rego::Output::ok
bool ok() const
Whether the Output is OK (i.e., has not resulted in one or more errors)

rego::UnwrapOpt
Options for unwrapping an argument.
Definition rego.hh:416

rego::UnwrapOpt::exclude_got
bool exclude_got() const
Whether the statement indicating what was received instead of the expected type should be excluded.

rego::UnwrapOpt::func
const std::string & func() const
The name of the function. If provide, will be a prefix on the message as "<func-name>:".

rego::UnwrapOpt::type
const Token & type() const
The singular type to match against.

rego::UnwrapOpt::type
UnwrapOpt & type(const Token &value)
Sets the singular type to match against.

rego::UnwrapOpt::pre
UnwrapOpt & pre(const std::string &value)
Sets the error preamble.

rego::UnwrapOpt::exclude_got
UnwrapOpt & exclude_got(bool exclude_got)
Sets whether to exclude the "got" statement in the error message.

rego::UnwrapOpt::specify_number
UnwrapOpt & specify_number(bool specify_number)
Sets whether to specify in the error message which kind of number was received.

rego::UnwrapOpt::UnwrapOpt
UnwrapOpt(std::size_t index)
Construct an UnwrapOpt.

rego::UnwrapOpt::specify_number
bool specify_number() const
Whether to specify in the error message which kind of number was received (i.e. integer or floating p...

rego::UnwrapOpt::code
UnwrapOpt & code(const std::string &value)
Sets the error code for the error message.

rego::UnwrapOpt::pre
const std::string & pre() const
The error preamble. If omitted, a default preamble will be constructed from the operation metadata in...

rego::UnwrapOpt::code
const std::string & code() const
The error code for the error message. Default value if omitted is EvalTypeError.

rego::UnwrapOpt::message
const std::string & message() const
The full error message. If this is set, no message will be generated and instead this will be returne...

rego::UnwrapOpt::unwrap
Node unwrap(const Nodes &args) const
Unwraps an argument from the provided vector of nodes.

rego::UnwrapOpt::message
UnwrapOpt & message(const std::string &value)
Sets the full error message. If this is set, no message will be generated and instead this will be re...

rego::UnwrapOpt::func
UnwrapOpt & func(const std::string &value)
Sets the name of the function.

rego::UnwrapOpt::types
UnwrapOpt & types(const std::vector< Token > &value)
Sets the types to match against.

rego::UnwrapOpt::types
const std::vector< Token > & types() const
The types to match against. The operand must be one of the provided types or else an error node will ...

rego::VirtualMachine
This class implements a virtual machine that can execute compiled Rego bundles.
Definition rego.hh:1442

rego::VirtualMachine::builtins
BuiltIns builtins() const
Gets the built-in functions used during execution.

rego::VirtualMachine::stmt_limit
VirtualMachine & stmt_limit(size_t stmt_limit)
Sets the maximum number of statements that will execute before a timeout.

rego::VirtualMachine::bundle
VirtualMachine & bundle(Bundle bundle)
Sets the bundle to use during execution.

rego::VirtualMachine::run_query
Node run_query(Node input) const
Executes the query plan in the bundle with the provided input.

rego::VirtualMachine::bundle
Bundle bundle() const
Gets the bundle used during execution.

rego::VirtualMachine::builtins
VirtualMachine & builtins(BuiltIns builtins)
Sets the built-in functions to use during execution.

rego::VirtualMachine::stmt_limit
size_t stmt_limit() const
Gets the maximum number of statements that will execute before a timeout.

rego::VirtualMachine::run_entrypoint
Node run_entrypoint(const Location &entrypoint, Node input) const
Executes the entrypoint plan in the bundle with the provided input.

rego::bundle::OperandType
OperandType
The type of an operand.
Definition rego.hh:1111

rego::bundle::StatementType
StatementType
The type of an IR statement.
Definition rego.hh:1177

rego::bundle::Block
std::vector< Statement > Block
A block of statements.
Definition rego.hh:1217

rego
Definition rego.hh:18

rego::get_bool
bool get_bool(const Node &node)
Extracts the value of a node as a boolean.

rego::try_get_item
std::optional< Node > try_get_item(const Node &node, const std::string_view &key)
Tries to get an item within an object using its key.

rego::scalar
Node scalar()
Creates a null scalar.

rego::try_get_bool
std::optional< bool > try_get_bool(const Node &node)
Attempts to extract the value of a node as a boolean.

rego::try_get_double
std::optional< double > try_get_double(const Node &node)
Attempts to extract the value of a node as an 64-bit floating point number.

rego::null
Node null()
Creates a null scalar.

rego::to_key
std::string to_key(const trieste::Node &node, bool set_as_array=false, bool sort_arrays=false, const char *list_delim=",")
Converts a node to a unique key representation that can be used for comparison.

rego::object_item
Node object_item(const Node &key_term, const Node &val_term)
Converts the key and val terms to an object item.

rego::array
Node array(const std::initializer_list< Node > &array_members)
Converts the value to an array node.

rego::get_int
BigInt get_int(const Node &node)
Extracts the value of a node as an integer.

rego::get_double
double get_double(const Node &node)
Extracts the value of a node as an double.

rego::unwrap_arg
Node unwrap_arg(const Nodes &args, const UnwrapOpt &options)
Unwraps an argument from the provided vector of nodes.

rego::json_to_bundle
Rewriter json_to_bundle()
Rewrites an OPA bundle JSON to a Bundle AST.

rego::err
Node err(NodeRange &r, const std::string &msg, const std::string &code=UnknownError)
Generates an error node.

rego::try_get_int
std::optional< BigInt > try_get_int(const Node &node)
Attempts to extract the value of a node as an integer. In the case that the node is a double,...

rego::file_to_rego
Reader file_to_rego()
Parses Rego queries and virtual documents.

rego::bundle_to_json
Rewriter bundle_to_json()
Rewrites a Bundle AST to a JSON AST in OPA bundle JSON format.

rego::try_get_string
std::optional< std::string > try_get_string(const Node &node)
Attempts to extract the value of a node as a string.

rego::rego_to_bundle
Rewriter rego_to_bundle(BuiltIns builtins=BuiltInsDef::create())
Rewrites a Rego AST to a Bundle AST.

rego::Bundle
std::shared_ptr< BundleDef > Bundle
A pointer to a BundleDef.
Definition rego.hh:1352

rego::BuiltIn
std::shared_ptr< BuiltInDef > BuiltIn
A pointer to a BuiltInDef.
Definition rego.hh:225

rego::get_raw_string
std::string_view get_raw_string(const Node &node)
Returns the raw location of the node from the source.

rego::BuiltInBehavior
std::function< Node(const Nodes &)> BuiltInBehavior
The function pointer to the behavior of the built-in.
Definition rego.hh:228

rego::version
Node version()
Returns a node representing the version of the library.

rego::unwrap
UnwrapResult unwrap(const Node &term, const Token &type)
Attempts to unwrap a node to a specified type.

rego::log_level_from_string
LogLevel log_level_from_string(const std::string &value)
Converts a string to a log level (case insensitive).

rego::number
Node number(double value)
Converts the value to a scalar node.

rego::string
Node string(const char *value)
Converts the value to a scalar node.

rego::LogLevel
LogLevel
The logging level.
Definition rego.hh:1095

rego::rego_to_input
Rewriter rego_to_input()
Rewrites a Query AST to an input term.

rego::set
Node set(const std::initializer_list< Node > &set_members)
Converts the value to a set node.

rego::json_to_rego
Rewriter json_to_rego(bool as_term=false)
Rewrites a JSON AST to a Rego data input AST.

rego::get_string
std::string get_string(const Node &node)
Extracts the value of a node as a string.

rego::rego_to_yaml
Rewriter rego_to_yaml()
Rewrites a Rego binding term to a YAML AST.

rego::rego_to_json
Rewriter rego_to_json()
Rewrites a Rego binding term to a JSON AST.

rego::boolean
Node boolean(bool value)
Converts the value to a scalar node.

rego::object
Node object(const std::initializer_list< Node > &object_items)
Converts the value to an object node.

rego_c.h

regoEnum
uint_least32_t regoEnum
Enum type.
Definition rego_c.h:32

rego::BuiltInDef
Struct which defines a built-in function.
Definition rego.hh:789

rego::BuiltInDef::available
bool available
Whether the builtin is available.
Definition rego.hh:807

rego::BuiltInDef::decl
Node decl
The declaration node which adheres to the builtins::wf_decl well-formedness definition.
Definition rego.hh:796

rego::BuiltInDef::create
static BuiltIn create(const Location &name, size_t arity, BuiltInBehavior behavior)
Creates a new built-in.

rego::BuiltInDef::clear
virtual void clear()
Called to clear any persistent state or caching.

rego::BuiltInDef::placeholder
static BuiltIn placeholder(const Location &name, Node decl, const std::string &message)
Creates a placeholder for a built-in which is not available on this platform.

rego::BuiltInDef::BuiltInDef
BuiltInDef(Location name_, Node decl_, BuiltInBehavior behavior_, bool available_)
Constructor.

rego::BuiltInDef::behavior
BuiltInBehavior behavior
The function which will be called when the built-in is evaluated.
Definition rego.hh:804

rego::BuiltInDef::create
static BuiltIn create(const Location &name, Node decl, BuiltInBehavior behavior)
Creates a new built-in.

rego::BuiltInDef::arity
std::size_t arity
The number of expected arguments.
Definition rego.hh:801

rego::BuiltInDef::name
Location name
The name used to match against expression calls in the rego program.
Definition rego.hh:792

rego::BundleDef
Represents a compiled Rego bundle.
Definition rego.hh:1356

rego::BundleDef::name_to_plan
std::map< Location, size_t > name_to_plan
Map from function names to their indices.
Definition rego.hh:1364

rego::BundleDef::functions
std::vector< bundle::Function > functions
The functions in the bundle.
Definition rego.hh:1368

rego::BundleDef::name_to_func
std::map< Location, size_t > name_to_func
Map from plan names to their indices.
Definition rego.hh:1362

rego::BundleDef::load
static Bundle load(const std::filesystem::path &path)
Loads a bundle from a file.

rego::BundleDef::strings
std::vector< Location > strings
The string table for the bundle.
Definition rego.hh:1370

rego::BundleDef::files
std::vector< Source > files
The module source files which were compiled into the bundle.
Definition rego.hh:1372

rego::BundleDef::from_node
static Bundle from_node(Node bundle)
Constructs a bundle from an AST node.

rego::BundleDef::plans
std::vector< bundle::Plan > plans
The plans in the bundle.
Definition rego.hh:1366

rego::BundleDef::save
void save(const std::filesystem::path &path) const
Saves the bundle to a file.

rego::BundleDef::query
Source query
The query, if one was included.
Definition rego.hh:1379

rego::BundleDef::data
Node data
The merged base data document.
Definition rego.hh:1358

rego::BundleDef::find_function
std::optional< size_t > find_function(const Location &name) const
Finds a function by name.

rego::BundleDef::find_plan
std::optional< size_t > find_plan(const Location &name) const
Finds a plan by name.

rego::BundleDef::builtin_functions
std::map< Location, Node > builtin_functions
The built-in functions required by the bundle.
Definition rego.hh:1360

rego::BundleDef::load
static Bundle load(std::istream &stream)
Loads a bundle from a stream.

rego::BundleDef::local_count
size_t local_count
The number of local variables required by the bundle.
Definition rego.hh:1374

rego::BundleDef::query_plan
std::optional< size_t > query_plan
The index of the query plan, if one was included.
Definition rego.hh:1376

rego::BundleDef::is_function
bool is_function(const Location &name) const
Determines whether the provided name refers to a function.

rego::BundleDef::save
void save(std::ostream &stream) const
Saves the bundle to a stream.

rego::UnwrapResult
Result of unwrapping a node.
Definition rego.hh:391

rego::UnwrapResult::success
bool success
True if the argument was unwrapped successfully.
Definition rego.hh:396

rego::UnwrapResult::node
Node node
The unwrapped argument or nullptr (if unsuccessful).
Definition rego.hh:393

rego::bundle::CallDynamicExt
Additional information for CallDynamic statements.
Definition rego.hh:1230

rego::bundle::CallDynamicExt::ops
std::vector< Operand > ops
The arguments to the function.
Definition rego.hh:1234

rego::bundle::CallDynamicExt::path
std::vector< Operand > path
The path to the function being called.
Definition rego.hh:1232

rego::bundle::CallExt
Additional information for Call statements.
Definition rego.hh:1221

rego::bundle::CallExt::ops
std::vector< Operand > ops
The arguments to the function.
Definition rego.hh:1225

rego::bundle::CallExt::func
Location func
The function being called.
Definition rego.hh:1223

rego::bundle::Function
Represents a function in the IR.
Definition rego.hh:1331

rego::bundle::Function::parameters
std::vector< size_t > parameters
The local indices of the function parameters.
Definition rego.hh:1339

rego::bundle::Function::blocks
std::vector< Block > blocks
The blocks which make up the function.
Definition rego.hh:1343

rego::bundle::Function::name
Location name
The name of the function.
Definition rego.hh:1333

rego::bundle::Function::arity
size_t arity
The arity of the function.
Definition rego.hh:1335

rego::bundle::Function::result
size_t result
The index of the result local.
Definition rego.hh:1341

rego::bundle::Function::path
std::vector< Location > path
The path of the function (the name broken into segments)
Definition rego.hh:1337

rego::bundle::Function::cacheable
bool cacheable
Whether the function result can be cached.
Definition rego.hh:1345

rego::bundle::Operand
Represents an operand in the IR.
Definition rego.hh:1131

rego::bundle::Operand::index
size_t index
A local index (if type is Local, String, or Index).
Definition rego.hh:1139

rego::bundle::Operand::value
std::int64_t value
An integer value (if type is Value).
Definition rego.hh:1137

rego::bundle::Operand::type
OperandType type
The type of the operand.
Definition rego.hh:1133

rego::bundle::Operand::Operand
Operand()
Constructs an Operand with type None.

rego::bundle::Operand::from_op
static Operand from_op(const Node &n)
Constructs an Operand from the specified node.

rego::bundle::Operand::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Operand &op)
Writes the operand to a stream (used for debugging purposes).

rego::bundle::Operand::from_index
static Operand from_index(const Node &n)
Constructs an Operand from the specified node. Will have a type of Index.

rego::bundle::Operand::from_value
static Operand from_value(const Node &n)
Constructs an Operand from the specified node. Will have a type of Value.

rego::bundle::Plan
Represents a plan in the IR.
Definition rego.hh:1322

rego::bundle::Plan::name
Location name
The name of the plan.
Definition rego.hh:1324

rego::bundle::Plan::blocks
std::vector< Block > blocks
The blocks which make up the plan.
Definition rego.hh:1326

rego::bundle::StatementExt
Additional information for Call, CallDynamic, With, Block, Not, and Scan statements.
Definition rego.hh:1249

rego::bundle::StatementExt::with
const WithExt & with() const
Returns this extension as a WithExt.

rego::bundle::StatementExt::call_dynamic
const CallDynamicExt & call_dynamic() const
Returns this extension as a CallDynamicExt.

rego::bundle::StatementExt::contents
std::variant< CallExt, CallDynamicExt, WithExt, std::vector< Block >, Block > contents
The contents of the extension.
Definition rego.hh:1252

rego::bundle::StatementExt::StatementExt
StatementExt(CallExt &&ext)
Constructs a StatementExt from a CallExt.

rego::bundle::StatementExt::blocks
const std::vector< Block > & blocks() const
Returns this extension as a vector of Blocks.

rego::bundle::StatementExt::block
const Block & block() const
Returns this extension as a Block.

rego::bundle::StatementExt::StatementExt
StatementExt(Block &&block)
Constructs a StatementExt from a Block.

rego::bundle::StatementExt::call
const CallExt & call() const
Returns this extension as a CallExt.

rego::bundle::StatementExt::StatementExt
StatementExt(WithExt &&ext)
Constructs a StatementExt from a WithExt.

rego::bundle::StatementExt::StatementExt
StatementExt(std::vector< Block > &&blocks)
Constructs a StatementExt from a vector of Blocks.

rego::bundle::StatementExt::StatementExt
StatementExt(CallDynamicExt &&ext)
Constructs a StatementExt from a CallDynamicExt.

rego::bundle::Statement
Represents a single IR statement.
Definition rego.hh:1291

rego::bundle::Statement::target
std::int32_t target
The target of the statement.
Definition rego.hh:1304

rego::bundle::Statement::type
StatementType type
The type of statement.
Definition rego.hh:1293

rego::bundle::Statement::ext
std::shared_ptr< const StatementExt > ext
The (optional) extended information for the statement.
Definition rego.hh:1307

rego::bundle::Statement::location
Location location
The location of the statement in the source document.
Definition rego.hh:1295

rego::bundle::Statement::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Statement &stmt)
Writes the statement to a stream (used for debugging purposes)

rego::bundle::Statement::op1
Operand op1
The second operand of the statement.
Definition rego.hh:1301

rego::bundle::Statement::Statement
Statement()
Default constructor.

rego::bundle::Statement::op0
Operand op0
The first operand of the statement.
Definition rego.hh:1298

rego::bundle::WithExt
Additional information for With statements.
Definition rego.hh:1239

rego::bundle::WithExt::path
std::vector< size_t > path
The path to the value being replaced.
Definition rego.hh:1241

rego::bundle::WithExt::block
Block block
The block to execute with the replacement.
Definition rego.hh:1243