rego_c.h

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
 
 
#ifndef _REGO_C_H_
#define _REGO_C_H_
 
#include "version.h"
 
#include <stdint.h>
 
typedef void regoInterpreter;
 
typedef void regoNode;
 
typedef void regoOutput;
 
typedef void regoBundle;
 
typedef void regoInput;
 
typedef uint_least8_t regoBoolean;
 
typedef uint_least32_t regoEnum;
 
typedef uint_least32_t regoSize;
 
typedef int_least64_t regoInt;
 
typedef uint_least32_t regoType;
 
// error codes
#define REGO_OK 0
#define REGO_ERROR 1
#define REGO_ERROR_BUFFER_TOO_SMALL 2
#define REGO_ERROR_INVALID_LOG_LEVEL 3
// #define REGO_ERROR_MANUAL_TZDATA_NOT_SUPPORTED 4 deprecated
#define REGO_ERROR_INPUT_NULL 5
#define REGO_ERROR_INPUT_MISSING_ARGUMENTS 6
#define REGO_ERROR_INPUT_OBJECT_ITEM 7
 
// term node types
#define REGO_NODE_BINDING 1000
#define REGO_NODE_VAR 1001
#define REGO_NODE_TERM 1002
#define REGO_NODE_SCALAR 1003
#define REGO_NODE_ARRAY 1004
#define REGO_NODE_SET 1005
#define REGO_NODE_OBJECT 1006
#define REGO_NODE_OBJECT_ITEM 1007
#define REGO_NODE_INT 1008
#define REGO_NODE_FLOAT 1009
#define REGO_NODE_STRING 1010
#define REGO_NODE_TRUE 1011
#define REGO_NODE_FALSE 1012
#define REGO_NODE_NULL 1013
#define REGO_NODE_UNDEFINED 1014
#define REGO_NODE_TERMS 1015
#define REGO_NODE_BINDINGS 1016
#define REGO_NODE_RESULTS 1017
#define REGO_NODE_RESULT 1018
 
#define REGO_NODE_ERROR 1800
#define REGO_NODE_ERROR_MESSAGE 1801
#define REGO_NODE_ERROR_AST 1802
#define REGO_NODE_ERROR_CODE 1803
#define REGO_NODE_ERROR_SEQ 1804
 
#define REGO_NODE_INTERNAL 1999
 
// log levels
#define REGO_LOG_LEVEL_NONE 0
#define REGO_LOG_LEVEL_ERROR 1
#define REGO_LOG_LEVEL_OUTPUT 2
#define REGO_LOG_LEVEL_WARN 3
#define REGO_LOG_LEVEL_INFO 4
#define REGO_LOG_LEVEL_DEBUG 5
#define REGO_LOG_LEVEL_TRACE 6
#define REGO_LOG_LEVEL_UNSUPPORTED 7
 
#define REGO_BUILD_INFO \
  (REGOCPP_VERSION " (" REGOCPP_BUILD_NAME ", " REGOCPP_BUILD_DATE \
                   ") " REGOCPP_BUILD_TOOLCHAIN " on " REGOCPP_PLATFORM)
 
 
#if defined(REGO_SHARED) && defined(WIN32)
#define REGO_API(x) __declspec(dllexport) x __cdecl
#else
#define REGO_API(x) x
#endif
 
#ifdef __cplusplus
extern "C"
{
#endif
  // ----- Interpreter functions ------ //
 
  REGO_API(regoSize) regoBuildInfoSize(void);
 
  REGO_API(regoEnum) regoBuildInfo(char* buffer, regoSize size);
 
  REGO_API(regoSize) regoVersionSize(void);
 
  REGO_API(regoEnum) regoVersion(char* buffer, regoSize size);
 
  REGO_API(regoEnum) regoLogLevelFromString(const char* level);
 
  REGO_API(regoEnum) regoSetLogLevel(regoInterpreter* rego, regoEnum level);
 
  REGO_API(regoEnum) regoSetDefaultLogLevel(regoEnum level);
 
  REGO_API(regoEnum) regoGetLogLevel(regoInterpreter* rego);
 
  REGO_API(regoInterpreter*) regoNew(void);
 
  REGO_API(void) regoFree(regoInterpreter* rego);
 
  REGO_API(regoEnum) regoAddModuleFile(regoInterpreter* rego, const char* path);
 
  REGO_API(regoEnum)
  regoAddModule(regoInterpreter* rego, const char* name, const char* contents);
 
  REGO_API(regoEnum)
  regoAddDataJSONFile(regoInterpreter* rego, const char* path);
 
  REGO_API(regoEnum)
  regoAddDataJSON(regoInterpreter* rego, const char* contents);
 
  REGO_API(regoEnum)
  regoSetInputJSONFile(regoInterpreter* rego, const char* path);
 
  REGO_API(regoEnum)
  regoSetInputTerm(regoInterpreter* rego, const char* contents);
 
  REGO_API(regoEnum)
  regoSetInput(regoInterpreter* rego, regoInput* input);
 
  REGO_API(void)
  regoSetDebugEnabled(regoInterpreter* rego, regoBoolean enabled);
 
  // /@return Whether debug mode is enabled.
  REGO_API(regoBoolean) regoGetDebugEnabled(regoInterpreter* rego);
 
  REGO_API(regoEnum) regoSetDebugPath(regoInterpreter* rego, const char* path);
 
  REGO_API(void)
  regoSetWellFormedChecksEnabled(regoInterpreter* rego, regoBoolean enabled);
 
  REGO_API(regoBoolean) regoGetWellFormedChecksEnabled(regoInterpreter* rego);
 
  REGO_API(regoOutput*)
  regoQuery(regoInterpreter* rego, const char* query_expr);
 
  REGO_API(void)
  regoSetStrictBuiltInErrors(regoInterpreter* rego, regoBoolean enabled);
 
  REGO_API(regoBoolean) regoGetStrictBuiltInErrors(regoInterpreter* rego);
 
  REGO_API(regoBoolean)
  regoIsAvailableBuiltIn(regoInterpreter* rego, const char* name);
 
  REGO_API(regoSize) regoErrorSize(regoInterpreter* rego);
 
  REGO_API(regoEnum)
  regoError(regoInterpreter* rego, char* buffer, regoSize size);
 
  REGO_API(regoEnum)
  regoSetQuery(regoInterpreter* rego, const char* query_expr);
 
  REGO_API(regoEnum)
  regoAddEntrypoint(regoInterpreter* rego, const char* entrypoint);
 
  REGO_API(regoBundle*) regoBuild(regoInterpreter* rego);
 
  REGO_API(regoBundle*) regoBundleLoad(regoInterpreter* rego, const char* dir);
 
  REGO_API(regoBundle*)
  regoBundleLoadBinary(regoInterpreter* rego, const char* path);
 
  REGO_API(regoEnum)
  regoBundleSave(regoInterpreter* rego, const char* dir, regoBundle* bundle);
 
  REGO_API(regoEnum)
  regoBundleSaveBinary(
    regoInterpreter* rego, const char* path, regoBundle* bundle);
 
  REGO_API(regoOutput*)
  regoBundleQuery(regoInterpreter* rego, regoBundle* bundle);
 
  REGO_API(regoOutput*)
  regoBundleQueryEntrypoint(
    regoInterpreter* rego, regoBundle* bundle, const char* endpoint);
 
  // -------- Output functions -------- //
 
  REGO_API(regoBoolean) regoOutputOk(regoOutput* output);
 
  REGO_API(regoSize) regoOutputSize(regoOutput* output);
 
  REGO_API(regoNode*)
  regoOutputExpressionsAtIndex(regoOutput* output, regoSize index);
 
  REGO_API(regoNode*) regoOutputExpressions(regoOutput* output);
 
  REGO_API(regoNode*) regoOutputNode(regoOutput* output);
 
  REGO_API(regoNode*)
  regoOutputBindingAtIndex(
    regoOutput* output, regoSize index, const char* name);
 
  REGO_API(regoNode*) regoOutputBinding(regoOutput* output, const char* name);
 
  REGO_API(regoSize) regoOutputJSONSize(regoOutput* output);
 
  REGO_API(regoEnum)
  regoOutputJSON(regoOutput* output, char* buffer, regoSize size);
 
  REGO_API(void) regoFreeOutput(regoOutput* output);
 
  // --------- Node functions --------- //
 
  // clang-format off
 
  REGO_API(regoType) regoNodeType(regoNode* node);
 
  // clang-format on
 
  REGO_API(regoEnum) regoNodeTypeNameSize(regoNode* node);
 
  REGO_API(regoEnum)
  regoNodeTypeName(regoNode* node, char* buffer, regoSize size);
 
  REGO_API(regoSize) regoNodeValueSize(regoNode* node);
 
  REGO_API(regoEnum) regoNodeValue(regoNode* node, char* buffer, regoSize size);
 
  REGO_API(regoSize) regoNodeSize(regoNode* node);
 
  REGO_API(regoNode*) regoNodeGet(regoNode* node, regoSize index);
 
  REGO_API(regoSize) regoNodeJSONSize(regoNode* node);
 
  REGO_API(regoEnum) regoNodeJSON(regoNode* node, char* buffer, regoSize size);
 
  // --------- Input functions --------- //
 
  // clang-format off
 
  REGO_API(regoInput*) regoNewInput();
 
  // clang-format on
 
  REGO_API(regoEnum) regoInputInt(regoInput* input, regoInt value);
 
  REGO_API(regoEnum) regoInputFloat(regoInput* input, double value);
 
  REGO_API(regoEnum) regoInputString(regoInput* input, const char* value);
 
  REGO_API(regoEnum) regoInputBoolean(regoInput* input, regoBoolean value);
 
  REGO_API(regoEnum) regoInputNull(regoInput* input);
 
  REGO_API(regoEnum) regoInputObjectItem(regoInput* input);
 
  REGO_API(regoEnum) regoInputObject(regoInput* input, regoSize count);
 
  REGO_API(regoEnum) regoInputArray(regoInput* input, regoSize count);
 
  REGO_API(regoEnum) regoInputSet(regoInput* input, regoSize count);
 
  REGO_API(regoEnum) regoInputValidate(regoInput* input);
 
  REGO_API(regoNode*) regoInputNode(regoInput* input);
 
  REGO_API(regoSize) regoInputSize(regoInput* input);
 
  REGO_API(void) regoFreeInput(regoInput* input);
 
  // --------- Bundle functions --------- //
 
  REGO_API(regoBoolean) regoBundleOk(regoBundle* bundle);
 
  REGO_API(regoNode*) regoBundleNode(regoBundle* bundle);
 
  REGO_API(void) regoFreeBundle(regoBundle* bundle);
 
#ifdef __cplusplus
}
#endif
 
#endif