max/nix-super
1
0
Fork 0
mirror of https://github.com/privatevoid-net/nix-super.git synced 2024-11-10 00:08:07 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

C API: reformat according to proposed clang-format file

Browse source
This commit is contained in:
Yorick van Pelt 2023-08-28 16:45:02 +02:00 committed by José Luis Lafuente
parent 91e53de7d3
commit e1bb799da9
No known key found for this signature in database
GPG key ID: 8A3455EBE455489A
13 changed files with 1115 additions and 1078 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

225
src/libexpr/c/nix_api_expr.cc
View file

@ -21,147 +21,158 @@
#include "gc_cpp.h"
#endif
nix_err nix_libexpr_init(nix_c_context *context) {
if (context)
context->last_err_code = NIX_OK;
{
auto ret = nix_libutil_init(context);
if (ret != NIX_OK)
return ret;
}
{
auto ret = nix_libstore_init(context);
if (ret != NIX_OK)
return ret;
}
try {
nix::initGC();
}
NIXC_CATCH_ERRS
nix_err nix_libexpr_init(nix_c_context * context)
{
if (context)
context->last_err_code = NIX_OK;
{
auto ret = nix_libutil_init(context);
if (ret != NIX_OK)
return ret;
}
{
auto ret = nix_libstore_init(context);
if (ret != NIX_OK)
return ret;
}
try {
nix::initGC();
}
NIXC_CATCH_ERRS
}
nix_err nix_expr_eval_from_string(nix_c_context *context, State *state,
const char *expr, const char *path,
Value *value) {
if (context)
context->last_err_code = NIX_OK;
try {
nix::Expr *parsedExpr = state->state.parseExprFromString(
expr, state->state.rootPath(nix::CanonPath(path)));
state->state.eval(parsedExpr, *(nix::Value *)value);
state->state.forceValue(*(nix::Value *)value, nix::noPos);
}
NIXC_CATCH_ERRS
nix_err
nix_expr_eval_from_string(nix_c_context * context, State * state, const char * expr, const char * path, Value * value)
{
if (context)
context->last_err_code = NIX_OK;
try {
nix::Expr * parsedExpr = state->state.parseExprFromString(expr, state->state.rootPath(nix::CanonPath(path)));
state->state.eval(parsedExpr, *(nix::Value *) value);
state->state.forceValue(*(nix::Value *) value, nix::noPos);
}
NIXC_CATCH_ERRS
}
nix_err nix_value_call(nix_c_context *context, State *state, Value *fn,
Value *arg, Value *value) {
if (context)
context->last_err_code = NIX_OK;
try {
state->state.callFunction(*(nix::Value *)fn, *(nix::Value *)arg,
*(nix::Value *)value, nix::noPos);
state->state.forceValue(*(nix::Value *)value, nix::noPos);
}
NIXC_CATCH_ERRS
nix_err nix_value_call(nix_c_context * context, State * state, Value * fn, Value * arg, Value * value)
{
if (context)
context->last_err_code = NIX_OK;
try {
state->state.callFunction(*(nix::Value *) fn, *(nix::Value *) arg, *(nix::Value *) value, nix::noPos);
state->state.forceValue(*(nix::Value *) value, nix::noPos);
}
NIXC_CATCH_ERRS
}
nix_err nix_value_force(nix_c_context *context, State *state, Value *value) {
if (context)
context->last_err_code = NIX_OK;
try {
state->state.forceValue(*(nix::Value *)value, nix::noPos);
}
NIXC_CATCH_ERRS
nix_err nix_value_force(nix_c_context * context, State * state, Value * value)
{
if (context)
context->last_err_code = NIX_OK;
try {
state->state.forceValue(*(nix::Value *) value, nix::noPos);
}
NIXC_CATCH_ERRS
}
nix_err nix_value_force_deep(nix_c_context *context, State *state,
Value *value) {
if (context)
context->last_err_code = NIX_OK;
try {
state->state.forceValueDeep(*(nix::Value *)value);
}
NIXC_CATCH_ERRS
nix_err nix_value_force_deep(nix_c_context * context, State * state, Value * value)
{
if (context)
context->last_err_code = NIX_OK;
try {
state->state.forceValueDeep(*(nix::Value *) value);
}
NIXC_CATCH_ERRS
}
State *nix_state_create(nix_c_context *context, const char **searchPath_c,
Store *store) {
if (context)
context->last_err_code = NIX_OK;
try {
nix::Strings searchPath;
if (searchPath_c != nullptr)
for (size_t i = 0; searchPath_c[i] != nullptr; i++)
searchPath.push_back(searchPath_c[i]);
State * nix_state_create(nix_c_context * context, const char ** searchPath_c, Store * store)
{
if (context)
context->last_err_code = NIX_OK;
try {
nix::Strings searchPath;
if (searchPath_c != nullptr)
for (size_t i = 0; searchPath_c[i] != nullptr; i++)
searchPath.push_back(searchPath_c[i]);
return new State{
nix::EvalState(nix::SearchPath::parse(searchPath), store->ptr)};
}
NIXC_CATCH_ERRS_NULL
return new State{nix::EvalState(nix::SearchPath::parse(searchPath), store->ptr)};
}
NIXC_CATCH_ERRS_NULL
}
void nix_state_free(State *state) { delete state; }
void nix_state_free(State * state)
{
delete state;
}
#ifdef HAVE_BOEHMGC
std::unordered_map<
const void *, unsigned int, std::hash<const void *>,
const void *,
unsigned int,
std::hash<const void *>,
std::equal_to<const void *>,
traceable_allocator<std::pair<const void *const, unsigned int>>>
traceable_allocator<std::pair<const void * const, unsigned int>>>
nix_refcounts;
std::mutex nix_refcount_lock;
nix_err nix_gc_incref(nix_c_context *context, const void *p) {
if (context)
context->last_err_code = NIX_OK;
try {
std::scoped_lock lock(nix_refcount_lock);
auto f = nix_refcounts.find(p);
if (f != nix_refcounts.end()) {
f->second++;
} else {
nix_refcounts[p] = 1;
nix_err nix_gc_incref(nix_c_context * context, const void * p)
{
if (context)
context->last_err_code = NIX_OK;
try {
std::scoped_lock lock(nix_refcount_lock);
auto f = nix_refcounts.find(p);
if (f != nix_refcounts.end()) {
f->second++;
} else {
nix_refcounts[p] = 1;
}
}
}
NIXC_CATCH_ERRS
NIXC_CATCH_ERRS
}
nix_err nix_gc_decref(nix_c_context *context, const void *p) {
nix_err nix_gc_decref(nix_c_context * context, const void * p)
{
if (context)
context->last_err_code = NIX_OK;
try {
std::scoped_lock lock(nix_refcount_lock);
auto f = nix_refcounts.find(p);
if (f != nix_refcounts.end()) {
if (--f->second == 0)
nix_refcounts.erase(f);
} else
throw std::runtime_error("nix_gc_decref: object was not referenced");
}
NIXC_CATCH_ERRS
if (context)
context->last_err_code = NIX_OK;
try {
std::scoped_lock lock(nix_refcount_lock);
auto f = nix_refcounts.find(p);
if (f != nix_refcounts.end()) {
if (--f->second == 0)
nix_refcounts.erase(f);
} else
throw std::runtime_error("nix_gc_decref: object was not referenced");
}
NIXC_CATCH_ERRS
}
void nix_gc_now() { GC_gcollect(); }
void nix_gc_now()
{
GC_gcollect();
}
#else
void nix_gc_incref(nix_c_context *context, const void *) {
if (context)
context->last_err_code = NIX_OK;
return NIX_OK;
void nix_gc_incref(nix_c_context * context, const void *)
{
if (context)
context->last_err_code = NIX_OK;
return NIX_OK;
}
void nix_gc_decref(nix_c_context *context, const void *) {
if (context)
context->last_err_code = NIX_OK;
return NIX_OK;
void nix_gc_decref(nix_c_context * context, const void *)
{
if (context)
context->last_err_code = NIX_OK;
return NIX_OK;
}
void nix_gc_now() {}
#endif
void nix_gc_register_finalizer(void *obj, void *cd,
void (*finalizer)(void *obj, void *cd)) {
void nix_gc_register_finalizer(void * obj, void * cd, void (*finalizer)(void * obj, void * cd))
{
#ifdef HAVE_BOEHMGC
GC_REGISTER_FINALIZER(obj, finalizer, cd, 0, 0);
GC_REGISTER_FINALIZER(obj, finalizer, cd, 0, 0);
#endif
}

30
src/libexpr/c/nix_api_expr.h
View file

@ -66,7 +66,7 @@ typedef void Value; // nix::Value
* @param[out] context Optional, stores error information
* @return NIX_OK if the initialization was successful, an error code otherwise.
*/
nix_err nix_libexpr_init(nix_c_context *context);
nix_err nix_libexpr_init(nix_c_context * context);
/**
* @brief Parses and evaluates a Nix expression from a string.
@ -75,14 +75,14 @@ nix_err nix_libexpr_init(nix_c_context *context);
* @param[in] state The state of the evaluation.
* @param[in] expr The Nix expression to parse.
* @param[in] path The file path to associate with the expression.
* This is required for expressions that contain relative paths (such as `./.`) that are resolved relative to the given directory.
* This is required for expressions that contain relative paths (such as `./.`) that are resolved relative to the given
* directory.
* @param[out] value The result of the evaluation. You should allocate this
* yourself.
* @return NIX_OK if the evaluation was successful, an error code otherwise.
*/
nix_err nix_expr_eval_from_string(nix_c_context *context, State *state,
const char *expr, const char *path,
Value *value);
nix_err
nix_expr_eval_from_string(nix_c_context * context, State * state, const char * expr, const char * path, Value * value);
/**
* @brief Calls a Nix function with an argument.
@ -94,8 +94,7 @@ nix_err nix_expr_eval_from_string(nix_c_context *context, State *state,
* @param[out] value The result of the function call.
* @return NIX_OK if the function call was successful, an error code otherwise.
*/
nix_err nix_value_call(nix_c_context *context, State *state, Value *fn,
Value *arg, Value *value);
nix_err nix_value_call(nix_c_context * context, State * state, Value * fn, Value * arg, Value * value);
/**
* @brief Forces the evaluation of a Nix value.
@ -117,7 +116,7 @@ nix_err nix_value_call(nix_c_context *context, State *state, Value *fn,
* @return NIX_OK if the force operation was successful, an error code
* otherwise.
*/
nix_err nix_value_force(nix_c_context *context, State *state, Value *value);
nix_err nix_value_force(nix_c_context * context, State * state, Value * value);
/**
* @brief Forces the deep evaluation of a Nix value.
@ -133,8 +132,7 @@ nix_err nix_value_force(nix_c_context *context, State *state, Value *value);
* @return NIX_OK if the deep force operation was successful, an error code
* otherwise.
*/
nix_err nix_value_force_deep(nix_c_context *context, State *state,
Value *value);
nix_err nix_value_force_deep(nix_c_context * context, State * state, Value * value);
/**
* @brief Create a new Nix language evaluator state.
@ -144,8 +142,7 @@ nix_err nix_value_force_deep(nix_c_context *context, State *state,
* @param[in] store The Nix store to use.
* @return A new Nix state or NULL on failure.
*/
State *nix_state_create(nix_c_context *context, const char **searchPath,
Store *store);
State * nix_state_create(nix_c_context * context, const char ** searchPath, Store * store);
/**
* @brief Frees a Nix state.
@ -154,7 +151,7 @@ State *nix_state_create(nix_c_context *context, const char **searchPath,
*
* @param[in] state The state to free.
*/
void nix_state_free(State *state);
void nix_state_free(State * state);
/** @addtogroup GC
* @brief Reference counting and garbage collector operations
@ -178,14 +175,14 @@ void nix_state_free(State *state);
* @param[out] context Optional, stores error information
* @param[in] object The object to keep alive
*/
nix_err nix_gc_incref(nix_c_context *context, const void *object);
nix_err nix_gc_incref(nix_c_context * context, const void * object);
/**
* @brief Decrement the garbage collector reference counter for the given object
*
* @param[out] context Optional, stores error information
* @param[in] object The object to stop referencing
*/
nix_err nix_gc_decref(nix_c_context *context, const void *object);
nix_err nix_gc_decref(nix_c_context * context, const void * object);
/**
* @brief Trigger the garbage collector manually
@ -203,8 +200,7 @@ void nix_gc_now();
* @param[in] cd the data to pass to the finalizer
* @param[in] finalizer the callback function, called with obj and cd
*/
void nix_gc_register_finalizer(void *obj, void *cd,
void (*finalizer)(void *obj, void *cd));
void nix_gc_register_finalizer(void * obj, void * cd, void (*finalizer)(void * obj, void * cd));
/** @} */
// cffi end

10
src/libexpr/c/nix_api_expr_internal.h
View file

@ -4,12 +4,14 @@
#include "eval.hh"
#include "attr-set.hh"
struct State {
nix::EvalState state;
struct State
{
nix::EvalState state;
};
struct BindingsBuilder {
nix::BindingsBuilder builder;
struct BindingsBuilder
{
nix::BindingsBuilder builder;
};
#endif // NIX_API_EXPR_INTERNAL_H

301
src/libexpr/c/nix_api_external.cc
View file

@ -20,178 +20,189 @@
#include "gc_cpp.h"
#endif
struct nix_string_return {
std::string str;
struct nix_string_return
{
std::string str;
};
struct nix_printer {
std::ostream &s;
struct nix_printer
{
std::ostream & s;
};
struct nix_string_context {
nix::NixStringContext &ctx;
struct nix_string_context
{
nix::NixStringContext & ctx;
};
void nix_set_string_return(nix_string_return *str, const char *c) {
str->str = c;
void nix_set_string_return(nix_string_return * str, const char * c)
{
str->str = c;
}
nix_err nix_external_print(nix_c_context *context, nix_printer *printer,
const char *c) {
if (context)
context->last_err_code = NIX_OK;
try {
printer->s << c;
}
NIXC_CATCH_ERRS
nix_err nix_external_print(nix_c_context * context, nix_printer * printer, const char * c)
{
if (context)
context->last_err_code = NIX_OK;
try {
printer->s << c;
}
NIXC_CATCH_ERRS
}
nix_err nix_external_add_string_context(nix_c_context *context,
nix_string_context *ctx,
const char *c) {
if (context)
context->last_err_code = NIX_OK;
try {
auto r = nix::NixStringContextElem::parse(c);
ctx->ctx.insert(r);
}
NIXC_CATCH_ERRS
nix_err nix_external_add_string_context(nix_c_context * context, nix_string_context * ctx, const char * c)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto r = nix::NixStringContextElem::parse(c);
ctx->ctx.insert(r);
}
NIXC_CATCH_ERRS
}
class NixCExternalValue : public nix::ExternalValueBase {
NixCExternalValueDesc &desc;
void *v;
class NixCExternalValue : public nix::ExternalValueBase
{
NixCExternalValueDesc & desc;
void * v;
public:
NixCExternalValue(NixCExternalValueDesc &desc, void *v) : desc(desc), v(v){};
void *get_ptr() { return v; }
/**
* Print out the value
*/
virtual std::ostream &print(std::ostream &str) const override {
nix_printer p{str};
desc.print(v, &p);
return str;
}
/**
* Return a simple string describing the type
*/
virtual std::string showType() const override {
nix_string_return res;
desc.showType(v, &res);
return std::move(res.str);
}
/**
* Return a string to be used in builtins.typeOf
*/
virtual std::string typeOf() const override {
nix_string_return res;
desc.typeOf(v, &res);
return std::move(res.str);
}
/**
* Coerce the value to a string.
*/
virtual std::string coerceToString(const nix::Pos &pos,
nix::NixStringContext &context,
bool copyMore,
bool copyToStore) const override {
if (!desc.coerceToString) {
return nix::ExternalValueBase::coerceToString(pos, context, copyMore,
copyToStore);
NixCExternalValue(NixCExternalValueDesc & desc, void * v)
: desc(desc)
, v(v){};
void * get_ptr()
{
return v;
}
nix_string_context ctx{context};
nix_string_return res{""};
// todo: pos, errors
desc.coerceToString(v, &ctx, copyMore, copyToStore, &res);
if (res.str.empty()) {
return nix::ExternalValueBase::coerceToString(pos, context, copyMore,
copyToStore);
/**
* Print out the value
*/
virtual std::ostream & print(std::ostream & str) const override
{
nix_printer p{str};
desc.print(v, &p);
return str;
}
return std::move(res.str);
}
/**
* Compare to another value of the same type.
*/
virtual bool operator==(const ExternalValueBase &b) const override {
if (!desc.equal) {
return false;
/**
* Return a simple string describing the type
*/
virtual std::string showType() const override
{
nix_string_return res;
desc.showType(v, &res);
return std::move(res.str);
}
auto r = dynamic_cast<const NixCExternalValue *>(&b);
if (!r)
return false;
return desc.equal(v, r->v);
}
/**
* Print the value as JSON.
*/
virtual nlohmann::json
printValueAsJSON(nix::EvalState &state, bool strict,
nix::NixStringContext &context,
bool copyToStore = true) const override {
if (!desc.printValueAsJSON) {
return nix::ExternalValueBase::printValueAsJSON(state, strict, context,
copyToStore);
/**
* Return a string to be used in builtins.typeOf
*/
virtual std::string typeOf() const override
{
nix_string_return res;
desc.typeOf(v, &res);
return std::move(res.str);
}
nix_string_context ctx{context};
nix_string_return res{""};
desc.printValueAsJSON(v, (State *)&state, strict, &ctx, copyToStore, &res);
if (res.str.empty()) {
return nix::ExternalValueBase::printValueAsJSON(state, strict, context,
copyToStore);
}
return nlohmann::json::parse(res.str);
}
/**
* Print the value as XML.
*/
virtual void printValueAsXML(nix::EvalState &state, bool strict,
bool location, nix::XMLWriter &doc,
nix::NixStringContext &context,
nix::PathSet &drvsSeen,
const nix::PosIdx pos) const override {
if (!desc.printValueAsXML) {
return nix::ExternalValueBase::printValueAsXML(
state, strict, location, doc, context, drvsSeen, pos);
/**
* Coerce the value to a string.
*/
virtual std::string coerceToString(
const nix::Pos & pos, nix::NixStringContext & context, bool copyMore, bool copyToStore) const override
{
if (!desc.coerceToString) {
return nix::ExternalValueBase::coerceToString(pos, context, copyMore, copyToStore);
}
nix_string_context ctx{context};
nix_string_return res{""};
// todo: pos, errors
desc.coerceToString(v, &ctx, copyMore, copyToStore, &res);
if (res.str.empty()) {
return nix::ExternalValueBase::coerceToString(pos, context, copyMore, copyToStore);
}
return std::move(res.str);
}
nix_string_context ctx{context};
desc.printValueAsXML(v, (State *)&state, strict, location, &doc, &ctx,
&drvsSeen, *reinterpret_cast<const uint32_t *>(&pos));
}
virtual ~NixCExternalValue() override{};
/**
* Compare to another value of the same type.
*/
virtual bool operator==(const ExternalValueBase & b) const override
{
if (!desc.equal) {
return false;
}
auto r = dynamic_cast<const NixCExternalValue *>(&b);
if (!r)
return false;
return desc.equal(v, r->v);
}
/**
* Print the value as JSON.
*/
virtual nlohmann::json printValueAsJSON(
nix::EvalState & state, bool strict, nix::NixStringContext & context, bool copyToStore = true) const override
{
if (!desc.printValueAsJSON) {
return nix::ExternalValueBase::printValueAsJSON(state, strict, context, copyToStore);
}
nix_string_context ctx{context};
nix_string_return res{""};
desc.printValueAsJSON(v, (State *) &state, strict, &ctx, copyToStore, &res);
if (res.str.empty()) {
return nix::ExternalValueBase::printValueAsJSON(state, strict, context, copyToStore);
}
return nlohmann::json::parse(res.str);
}
/**
* Print the value as XML.
*/
virtual void printValueAsXML(
nix::EvalState & state,
bool strict,
bool location,
nix::XMLWriter & doc,
nix::NixStringContext & context,
nix::PathSet & drvsSeen,
const nix::PosIdx pos) const override
{
if (!desc.printValueAsXML) {
return nix::ExternalValueBase::printValueAsXML(state, strict, location, doc, context, drvsSeen, pos);
}
nix_string_context ctx{context};
desc.printValueAsXML(
v, (State *) &state, strict, location, &doc, &ctx, &drvsSeen, *reinterpret_cast<const uint32_t *>(&pos));
}
virtual ~NixCExternalValue() override{};
};
ExternalValue *nix_create_external_value(nix_c_context *context,
NixCExternalValueDesc *desc, void *v) {
if (context)
context->last_err_code = NIX_OK;
try {
auto ret = new
ExternalValue * nix_create_external_value(nix_c_context * context, NixCExternalValueDesc * desc, void * v)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto ret = new
#ifdef HAVE_BOEHMGC
(GC)
(GC)
#endif
NixCExternalValue(*desc, v);
nix_gc_incref(nullptr, ret);
return (ExternalValue *)ret;
}
NIXC_CATCH_ERRS_NULL
NixCExternalValue(*desc, v);
nix_gc_incref(nullptr, ret);
return (ExternalValue *) ret;
}
NIXC_CATCH_ERRS_NULL
}
void *nix_get_external_value_content(nix_c_context *context, ExternalValue *b) {
if (context)
context->last_err_code = NIX_OK;
try {
auto r = dynamic_cast<NixCExternalValue *>((nix::ExternalValueBase *)b);
if (r)
return r->get_ptr();
return nullptr;
}
NIXC_CATCH_ERRS_NULL
void * nix_get_external_value_content(nix_c_context * context, ExternalValue * b)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto r = dynamic_cast<NixCExternalValue *>((nix::ExternalValueBase *) b);
if (r)
return r->get_ptr();
return nullptr;
}
NIXC_CATCH_ERRS_NULL
}

179
src/libexpr/c/nix_api_external.h
View file

@ -42,7 +42,7 @@ typedef struct nix_string_context nix_string_context;
* @param[out] str the nix_string_return to write to
* @param[in] c The string to copy
*/
void nix_set_string_return(nix_string_return *str, const char *c);
void nix_set_string_return(nix_string_return * str, const char * c);
/**
* Print to the nix_printer
@ -52,8 +52,7 @@ void nix_set_string_return(nix_string_return *str, const char *c);
* @param[in] str The string to print
* @returns NIX_OK if everything worked
*/
nix_err nix_external_print(nix_c_context *context, nix_printer *printer,
const char *str);
nix_err nix_external_print(nix_c_context * context, nix_printer * printer, const char * str);
/**
* Add string context to the nix_string_context object
@ -62,9 +61,7 @@ nix_err nix_external_print(nix_c_context *context, nix_printer *printer,
* @param[in] c The context string to add
* @returns NIX_OK if everything worked
*/
nix_err nix_external_add_string_context(nix_c_context *context,
nix_string_context *string_context,
const char *c);
nix_err nix_external_add_string_context(nix_c_context * context, nix_string_context * string_context, const char * c);
/**
* @brief Definition for a class of external values
@ -76,89 +73,88 @@ nix_err nix_external_add_string_context(nix_c_context *context,
*
* @see nix_create_external_value
*/
typedef struct NixCExternalValueDesc {
/**
* @brief Called when printing the external value
*
* @param[in] self the void* passed to nix_create_external_value
* @param[out] printer The printer to print to, pass to nix_external_print
*/
void (*print)(void *self, nix_printer *printer);
/**
* @brief Called on :t
* @param[in] self the void* passed to nix_create_external_value
* @param[out] res the return value
*/
void (*showType)(void *self, nix_string_return *res);
/**
* @brief Called on `builtins.typeOf`
* @param self the void* passed to nix_create_external_value
* @param[out] res the return value
*/
void (*typeOf)(void *self, nix_string_return *res);
/**
* @brief Called on "${str}" and builtins.toString.
*
* The latter with coerceMore=true
* Optional, the default is to throw an error.
* @param[in] self the void* passed to nix_create_external_value
* @param[out] c writable string context for the resulting string
* @param[in] coerceMore boolean, try to coerce to strings in more cases
* instead of throwing an error
* @param[in] copyToStore boolean, whether to copy referenced paths to store
* or keep them as-is
* @param[out] res the return value. Not touching this, or setting it to the
* empty string, will make the conversion throw an error.
*/
void (*coerceToString)(void *self, nix_string_context *c, int coerceMore,
int copyToStore, nix_string_return *res);
/**
* @brief Try to compare two external values
*
* Optional, the default is always false.
* If the other object was not a Nix C external value, this comparison will
* also return false
* @param[in] self the void* passed to nix_create_external_value
* @param[in] other the void* passed to the other object's
* nix_create_external_value
* @returns true if the objects are deemed to be equal
*/
int (*equal)(void *self, void *other);
/**
* @brief Convert the external value to json
*
* Optional, the default is to throw an error
* @param[in] self the void* passed to nix_create_external_value
* @param[in] state The evaluator state
* @param[in] strict boolean Whether to force the value before printing
* @param[out] c writable string context for the resulting string
* @param[in] copyToStore whether to copy referenced paths to store or keep
* them as-is
* @param[out] res the return value. Gets parsed as JSON. Not touching this,
* or setting it to the empty string, will make the conversion throw an error.
*/
void (*printValueAsJSON)(void *self, State *, int strict,
nix_string_context *c, bool copyToStore,
nix_string_return *res);
/**
* @brief Convert the external value to XML
*
* Optional, the default is to throw an error
* @todo The mechanisms for this call are incomplete. There are no C
* bindings to work with XML, pathsets and positions.
* @param[in] self the void* passed to nix_create_external_value
* @param[in] state The evaluator state
* @param[in] strict boolean Whether to force the value before printing
* @param[in] location boolean Whether to include position information in the
* xml
* @param[out] doc XML document to output to
* @param[out] c writable string context for the resulting string
* @param[in,out] drvsSeen a path set to avoid duplicating derivations
* @param[in] pos The position of the call.
*/
void (*printValueAsXML)(void *self, State *, int strict, int location,
void *doc, nix_string_context *c, void *drvsSeen,
int pos);
typedef struct NixCExternalValueDesc
{
/**
* @brief Called when printing the external value
*
* @param[in] self the void* passed to nix_create_external_value
* @param[out] printer The printer to print to, pass to nix_external_print
*/
void (*print)(void * self, nix_printer * printer);
/**
* @brief Called on :t
* @param[in] self the void* passed to nix_create_external_value
* @param[out] res the return value
*/
void (*showType)(void * self, nix_string_return * res);
/**
* @brief Called on `builtins.typeOf`
* @param self the void* passed to nix_create_external_value
* @param[out] res the return value
*/
void (*typeOf)(void * self, nix_string_return * res);
/**
* @brief Called on "${str}" and builtins.toString.
*
* The latter with coerceMore=true
* Optional, the default is to throw an error.
* @param[in] self the void* passed to nix_create_external_value
* @param[out] c writable string context for the resulting string
* @param[in] coerceMore boolean, try to coerce to strings in more cases
* instead of throwing an error
* @param[in] copyToStore boolean, whether to copy referenced paths to store
* or keep them as-is
* @param[out] res the return value. Not touching this, or setting it to the
* empty string, will make the conversion throw an error.
*/
void (*coerceToString)(
void * self, nix_string_context * c, int coerceMore, int copyToStore, nix_string_return * res);
/**
* @brief Try to compare two external values
*
* Optional, the default is always false.
* If the other object was not a Nix C external value, this comparison will
* also return false
* @param[in] self the void* passed to nix_create_external_value
* @param[in] other the void* passed to the other object's
* nix_create_external_value
* @returns true if the objects are deemed to be equal
*/
int (*equal)(void * self, void * other);
/**
* @brief Convert the external value to json
*
* Optional, the default is to throw an error
* @param[in] self the void* passed to nix_create_external_value
* @param[in] state The evaluator state
* @param[in] strict boolean Whether to force the value before printing
* @param[out] c writable string context for the resulting string
* @param[in] copyToStore whether to copy referenced paths to store or keep
* them as-is
* @param[out] res the return value. Gets parsed as JSON. Not touching this,
* or setting it to the empty string, will make the conversion throw an error.
*/
void (*printValueAsJSON)(
void * self, State *, int strict, nix_string_context * c, bool copyToStore, nix_string_return * res);
/**
* @brief Convert the external value to XML
*
* Optional, the default is to throw an error
* @todo The mechanisms for this call are incomplete. There are no C
* bindings to work with XML, pathsets and positions.
* @param[in] self the void* passed to nix_create_external_value
* @param[in] state The evaluator state
* @param[in] strict boolean Whether to force the value before printing
* @param[in] location boolean Whether to include position information in the
* xml
* @param[out] doc XML document to output to
* @param[out] c writable string context for the resulting string
* @param[in,out] drvsSeen a path set to avoid duplicating derivations
* @param[in] pos The position of the call.
*/
void (*printValueAsXML)(
void * self, State *, int strict, int location, void * doc, nix_string_context * c, void * drvsSeen, int pos);
} NixCExternalValueDesc;
/**
@ -173,8 +169,7 @@ typedef struct NixCExternalValueDesc {
* @returns external value, owned by the garbage collector
* @see nix_set_external
*/
ExternalValue *nix_create_external_value(nix_c_context *context,
NixCExternalValueDesc *desc, void *v);
ExternalValue * nix_create_external_value(nix_c_context * context, NixCExternalValueDesc * desc, void * v);
/**
* @brief Extract the pointer from a nix c external value.
@ -183,7 +178,7 @@ ExternalValue *nix_create_external_value(nix_c_context *context,
* @returns The pointer, or null if the external value was not from nix c.
* @see nix_get_external
*/
void *nix_get_external_value_content(nix_c_context *context, ExternalValue *b);
void * nix_get_external_value_content(nix_c_context * context, ExternalValue * b);
// cffi end
#ifdef __cplusplus

782
src/libexpr/c/nix_api_value.cc
View file

@ -18,437 +18,457 @@
#endif
// Helper function to throw an exception if value is null
static const nix::Value &check_value_not_null(const Value *value) {
if (!value) {
throw std::runtime_error("Value is null");
}
return *((const nix::Value *)value);
static const nix::Value & check_value_not_null(const Value * value)
{
if (!value) {
throw std::runtime_error("Value is null");
}
return *((const nix::Value *) value);
}
static nix::Value &check_value_not_null(Value *value) {
if (!value) {
throw std::runtime_error("Value is null");
}
return *((nix::Value *)value);
static nix::Value & check_value_not_null(Value * value)
{
if (!value) {
throw std::runtime_error("Value is null");
}
return *((nix::Value *) value);
}
PrimOp *nix_alloc_primop(nix_c_context *context, PrimOpFun fun, int arity,
const char *name, const char **args, const char *doc) {
if (context)
context->last_err_code = NIX_OK;
try {
auto fun2 = (nix::PrimOpFun)fun;
auto p = new
PrimOp * nix_alloc_primop(
nix_c_context * context, PrimOpFun fun, int arity, const char * name, const char ** args, const char * doc)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto fun2 = (nix::PrimOpFun) fun;
auto p = new
#ifdef HAVE_BOEHMGC
(GC)
(GC)
#endif
nix::PrimOp{.name = name,
.args = {},
.arity = (size_t)arity,
.doc = doc,
.fun = fun2};
if (args)
for (size_t i = 0; args[i]; i++)
p->args.emplace_back(*args);
nix_gc_incref(nullptr, p);
return (PrimOp *)p;
}
NIXC_CATCH_ERRS_NULL
}
nix_err nix_register_primop(nix_c_context *context, PrimOp *primOp) {
if (context)
context->last_err_code = NIX_OK;
try {
nix::RegisterPrimOp r(std::move(*((nix::PrimOp *)primOp)));
}
NIXC_CATCH_ERRS
}
Value *nix_alloc_value(nix_c_context *context, State *state) {
if (context)
context->last_err_code = NIX_OK;
try {
Value *res = state->state.allocValue();
nix_gc_incref(nullptr, res);
return res;
}
NIXC_CATCH_ERRS_NULL
}
ValueType nix_get_type(nix_c_context *context, const Value *value) {
if (context)
context->last_err_code = NIX_OK;
try {
auto &v = check_value_not_null(value);
using namespace nix;
switch (v.type()) {
case nThunk:
return NIX_TYPE_THUNK;
case nInt:
return NIX_TYPE_INT;
case nFloat:
return NIX_TYPE_FLOAT;
case nBool:
return NIX_TYPE_BOOL;
case nString:
return NIX_TYPE_STRING;
case nPath:
return NIX_TYPE_PATH;
case nNull:
return NIX_TYPE_NULL;
case nAttrs:
return NIX_TYPE_ATTRS;
case nList:
return NIX_TYPE_LIST;
case nFunction:
return NIX_TYPE_FUNCTION;
case nExternal:
return NIX_TYPE_EXTERNAL;
nix::PrimOp{.name = name, .args = {}, .arity = (size_t) arity, .doc = doc, .fun = fun2};
if (args)
for (size_t i = 0; args[i]; i++)
p->args.emplace_back(*args);
nix_gc_incref(nullptr, p);
return (PrimOp *) p;
}
return NIX_TYPE_NULL;
}
NIXC_CATCH_ERRS_RES(NIX_TYPE_NULL);
NIXC_CATCH_ERRS_NULL
}
const char *nix_get_typename(nix_c_context *context, const Value *value) {
if (context)
context->last_err_code = NIX_OK;
try {
auto &v = check_value_not_null(value);
auto s = nix::showType(v);
return strdup(s.c_str());
}
NIXC_CATCH_ERRS_NULL
}
bool nix_get_bool(nix_c_context *context, const Value *value) {
if (context)
context->last_err_code = NIX_OK;
try {
auto &v = check_value_not_null(value);
assert(v.type() == nix::nBool);
return v.boolean;
}
NIXC_CATCH_ERRS_RES(false);
}
const char *nix_get_string(nix_c_context *context, const Value *value) {
if (context)
context->last_err_code = NIX_OK;
try {
auto &v = check_value_not_null(value);
assert(v.type() == nix::nString);
return v.string.s;
}
NIXC_CATCH_ERRS_NULL
}
const char *nix_get_path_string(nix_c_context *context, const Value *value) {
if (context)
context->last_err_code = NIX_OK;
try {
auto &v = check_value_not_null(value);
assert(v.type() == nix::nPath);
return v._path;
}
NIXC_CATCH_ERRS_NULL
}
unsigned int nix_get_list_size(nix_c_context *context, const Value *value) {
if (context)
context->last_err_code = NIX_OK;
try {
auto &v = check_value_not_null(value);
assert(v.type() == nix::nList);
return v.listSize();
}
NIXC_CATCH_ERRS_RES(0);
}
unsigned int nix_get_attrs_size(nix_c_context *context, const Value *value) {
if (context)
context->last_err_code = NIX_OK;
try {
auto &v = check_value_not_null(value);
assert(v.type() == nix::nAttrs);
return v.attrs->size();
}
NIXC_CATCH_ERRS_RES(0);
}
double nix_get_float(nix_c_context *context, const Value *value) {
if (context)
context->last_err_code = NIX_OK;
try {
auto &v = check_value_not_null(value);
assert(v.type() == nix::nFloat);
return v.fpoint;
}
NIXC_CATCH_ERRS_RES(NAN);
}
int64_t nix_get_int(nix_c_context *context, const Value *value) {
if (context)
context->last_err_code = NIX_OK;
try {
auto &v = check_value_not_null(value);
assert(v.type() == nix::nInt);
return v.integer;
}
NIXC_CATCH_ERRS_RES(0);
}
ExternalValue *nix_get_external(nix_c_context *context, Value *value) {
if (context)
context->last_err_code = NIX_OK;
try {
auto &v = check_value_not_null(value);
assert(v.type() == nix::nExternal);
return (ExternalValue *)v.external;
}
NIXC_CATCH_ERRS_NULL;
}
Value *nix_get_list_byidx(nix_c_context *context, const Value *value,
State *state, unsigned int ix) {
if (context)
context->last_err_code = NIX_OK;
try {
auto &v = check_value_not_null(value);
assert(v.type() == nix::nList);
auto *p = v.listElems()[ix];
nix_gc_incref(nullptr, p);
state->state.forceValue(*p, nix::noPos);
return (Value *)p;
}
NIXC_CATCH_ERRS_NULL
}
Value *nix_get_attr_byname(nix_c_context *context, const Value *value,
State *state, const char *name) {
if (context)
context->last_err_code = NIX_OK;
try {
auto &v = check_value_not_null(value);
assert(v.type() == nix::nAttrs);
nix::Symbol s = state->state.symbols.create(name);
auto attr = v.attrs->get(s);
if (attr) {
nix_gc_incref(nullptr, attr->value);
state->state.forceValue(*attr->value, nix::noPos);
return attr->value;
nix_err nix_register_primop(nix_c_context * context, PrimOp * primOp)
{
if (context)
context->last_err_code = NIX_OK;
try {
nix::RegisterPrimOp r(std::move(*((nix::PrimOp *) primOp)));
}
nix_set_err_msg(context, NIX_ERR_KEY, "missing attribute");
return nullptr;
}
NIXC_CATCH_ERRS_NULL
NIXC_CATCH_ERRS
}
bool nix_has_attr_byname(nix_c_context *context, const Value *value,
State *state, const char *name) {
if (context)
context->last_err_code = NIX_OK;
try {
auto &v = check_value_not_null(value);
assert(v.type() == nix::nAttrs);
nix::Symbol s = state->state.symbols.create(name);
auto attr = v.attrs->get(s);
if (attr)
return true;
return false;
}
NIXC_CATCH_ERRS_RES(false);
Value * nix_alloc_value(nix_c_context * context, State * state)
{
if (context)
context->last_err_code = NIX_OK;
try {
Value * res = state->state.allocValue();
nix_gc_incref(nullptr, res);
return res;
}
NIXC_CATCH_ERRS_NULL
}
Value *nix_get_attr_byidx(nix_c_context *context, const Value *value,
State *state, unsigned int i, const char **name) {
if (context)
context->last_err_code = NIX_OK;
try {
auto &v = check_value_not_null(value);
const nix::Attr &a = (*v.attrs)[i];
*name = ((const std::string &)(state->state.symbols[a.name])).c_str();
nix_gc_incref(nullptr, a.value);
state->state.forceValue(*a.value, nix::noPos);
return a.value;
}
NIXC_CATCH_ERRS_NULL
ValueType nix_get_type(nix_c_context * context, const Value * value)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto & v = check_value_not_null(value);
using namespace nix;
switch (v.type()) {
case nThunk:
return NIX_TYPE_THUNK;
case nInt:
return NIX_TYPE_INT;
case nFloat:
return NIX_TYPE_FLOAT;
case nBool:
return NIX_TYPE_BOOL;
case nString:
return NIX_TYPE_STRING;
case nPath:
return NIX_TYPE_PATH;
case nNull:
return NIX_TYPE_NULL;
case nAttrs:
return NIX_TYPE_ATTRS;
case nList:
return NIX_TYPE_LIST;
case nFunction:
return NIX_TYPE_FUNCTION;
case nExternal:
return NIX_TYPE_EXTERNAL;
}
return NIX_TYPE_NULL;
}
NIXC_CATCH_ERRS_RES(NIX_TYPE_NULL);
}
const char *nix_get_attr_name_byidx(nix_c_context *context, const Value *value,
State *state, unsigned int i) {
if (context)
context->last_err_code = NIX_OK;
try {
auto &v = check_value_not_null(value);
const nix::Attr &a = (*v.attrs)[i];
return ((const std::string &)(state->state.symbols[a.name])).c_str();
}
NIXC_CATCH_ERRS_NULL
const char * nix_get_typename(nix_c_context * context, const Value * value)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto & v = check_value_not_null(value);
auto s = nix::showType(v);
return strdup(s.c_str());
}
NIXC_CATCH_ERRS_NULL
}
nix_err nix_set_bool(nix_c_context *context, Value *value, bool b) {
if (context)
context->last_err_code = NIX_OK;
try {
auto &v = check_value_not_null(value);
v.mkBool(b);
}
NIXC_CATCH_ERRS
bool nix_get_bool(nix_c_context * context, const Value * value)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto & v = check_value_not_null(value);
assert(v.type() == nix::nBool);
return v.boolean;
}
NIXC_CATCH_ERRS_RES(false);
}
const char * nix_get_string(nix_c_context * context, const Value * value)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto & v = check_value_not_null(value);
assert(v.type() == nix::nString);
return v.string.s;
}
NIXC_CATCH_ERRS_NULL
}
const char * nix_get_path_string(nix_c_context * context, const Value * value)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto & v = check_value_not_null(value);
assert(v.type() == nix::nPath);
return v._path;
}
NIXC_CATCH_ERRS_NULL
}
unsigned int nix_get_list_size(nix_c_context * context, const Value * value)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto & v = check_value_not_null(value);
assert(v.type() == nix::nList);
return v.listSize();
}
NIXC_CATCH_ERRS_RES(0);
}
unsigned int nix_get_attrs_size(nix_c_context * context, const Value * value)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto & v = check_value_not_null(value);
assert(v.type() == nix::nAttrs);
return v.attrs->size();
}
NIXC_CATCH_ERRS_RES(0);
}
double nix_get_float(nix_c_context * context, const Value * value)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto & v = check_value_not_null(value);
assert(v.type() == nix::nFloat);
return v.fpoint;
}
NIXC_CATCH_ERRS_RES(NAN);
}
int64_t nix_get_int(nix_c_context * context, const Value * value)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto & v = check_value_not_null(value);
assert(v.type() == nix::nInt);
return v.integer;
}
NIXC_CATCH_ERRS_RES(0);
}
ExternalValue * nix_get_external(nix_c_context * context, Value * value)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto & v = check_value_not_null(value);
assert(v.type() == nix::nExternal);
return (ExternalValue *) v.external;
}
NIXC_CATCH_ERRS_NULL;
}
Value * nix_get_list_byidx(nix_c_context * context, const Value * value, State * state, unsigned int ix)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto & v = check_value_not_null(value);
assert(v.type() == nix::nList);
auto * p = v.listElems()[ix];
nix_gc_incref(nullptr, p);
state->state.forceValue(*p, nix::noPos);
return (Value *) p;
}
NIXC_CATCH_ERRS_NULL
}
Value * nix_get_attr_byname(nix_c_context * context, const Value * value, State * state, const char * name)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto & v = check_value_not_null(value);
assert(v.type() == nix::nAttrs);
nix::Symbol s = state->state.symbols.create(name);
auto attr = v.attrs->get(s);
if (attr) {
nix_gc_incref(nullptr, attr->value);
state->state.forceValue(*attr->value, nix::noPos);
return attr->value;
}
nix_set_err_msg(context, NIX_ERR_KEY, "missing attribute");
return nullptr;
}
NIXC_CATCH_ERRS_NULL
}
bool nix_has_attr_byname(nix_c_context * context, const Value * value, State * state, const char * name)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto & v = check_value_not_null(value);
assert(v.type() == nix::nAttrs);
nix::Symbol s = state->state.symbols.create(name);
auto attr = v.attrs->get(s);
if (attr)
return true;
return false;
}
NIXC_CATCH_ERRS_RES(false);
}
Value *
nix_get_attr_byidx(nix_c_context * context, const Value * value, State * state, unsigned int i, const char ** name)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto & v = check_value_not_null(value);
const nix::Attr & a = (*v.attrs)[i];
*name = ((const std::string &) (state->state.symbols[a.name])).c_str();
nix_gc_incref(nullptr, a.value);
state->state.forceValue(*a.value, nix::noPos);
return a.value;
}
NIXC_CATCH_ERRS_NULL
}
const char * nix_get_attr_name_byidx(nix_c_context * context, const Value * value, State * state, unsigned int i)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto & v = check_value_not_null(value);
const nix::Attr & a = (*v.attrs)[i];
return ((const std::string &) (state->state.symbols[a.name])).c_str();
}
NIXC_CATCH_ERRS_NULL
}
nix_err nix_set_bool(nix_c_context * context, Value * value, bool b)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto & v = check_value_not_null(value);
v.mkBool(b);
}
NIXC_CATCH_ERRS
}
// todo string context
nix_err nix_set_string(nix_c_context *context, Value *value, const char *str) {
if (context)
context->last_err_code = NIX_OK;
try {
auto &v = check_value_not_null(value);
v.mkString(std::string_view(str));
}
NIXC_CATCH_ERRS
nix_err nix_set_string(nix_c_context * context, Value * value, const char * str)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto & v = check_value_not_null(value);
v.mkString(std::string_view(str));
}
NIXC_CATCH_ERRS
}
nix_err nix_set_path_string(nix_c_context *context, Value *value,
const char *str) {
if (context)
context->last_err_code = NIX_OK;
try {
auto &v = check_value_not_null(value);
v.mkPath(std::string_view(str));
}
NIXC_CATCH_ERRS
nix_err nix_set_path_string(nix_c_context * context, Value * value, const char * str)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto & v = check_value_not_null(value);
v.mkPath(std::string_view(str));
}
NIXC_CATCH_ERRS
}
nix_err nix_set_float(nix_c_context *context, Value *value, double d) {
if (context)
context->last_err_code = NIX_OK;
try {
auto &v = check_value_not_null(value);
v.mkFloat(d);
}
NIXC_CATCH_ERRS
nix_err nix_set_float(nix_c_context * context, Value * value, double d)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto & v = check_value_not_null(value);
v.mkFloat(d);
}
NIXC_CATCH_ERRS
}
nix_err nix_set_int(nix_c_context *context, Value *value, int64_t i) {
if (context)
context->last_err_code = NIX_OK;
try {
auto &v = check_value_not_null(value);
v.mkInt(i);
}
NIXC_CATCH_ERRS
nix_err nix_set_int(nix_c_context * context, Value * value, int64_t i)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto & v = check_value_not_null(value);
v.mkInt(i);
}
NIXC_CATCH_ERRS
}
nix_err nix_set_null(nix_c_context *context, Value *value) {
if (context)
context->last_err_code = NIX_OK;
try {
auto &v = check_value_not_null(value);
v.mkNull();
}
NIXC_CATCH_ERRS
nix_err nix_set_null(nix_c_context * context, Value * value)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto & v = check_value_not_null(value);
v.mkNull();
}
NIXC_CATCH_ERRS
}
nix_err nix_set_external(nix_c_context *context, Value *value,
ExternalValue *val) {
if (context)
context->last_err_code = NIX_OK;
try {
auto &v = check_value_not_null(value);
auto r = (nix::ExternalValueBase *)val;
v.mkExternal(r);
}
NIXC_CATCH_ERRS
nix_err nix_set_external(nix_c_context * context, Value * value, ExternalValue * val)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto & v = check_value_not_null(value);
auto r = (nix::ExternalValueBase *) val;
v.mkExternal(r);
}
NIXC_CATCH_ERRS
}
nix_err nix_make_list(nix_c_context *context, State *s, Value *value,
unsigned int size) {
if (context)
context->last_err_code = NIX_OK;
try {
auto &v = check_value_not_null(value);
s->state.mkList(v, size);
}
NIXC_CATCH_ERRS
nix_err nix_make_list(nix_c_context * context, State * s, Value * value, unsigned int size)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto & v = check_value_not_null(value);
s->state.mkList(v, size);
}
NIXC_CATCH_ERRS
}
nix_err nix_set_list_byidx(nix_c_context *context, Value *value,
unsigned int ix, Value *elem) {
if (context)
context->last_err_code = NIX_OK;
try {
// todo: assert that this is a list
auto &v = check_value_not_null(value);
auto &e = check_value_not_null(elem);
v.listElems()[ix] = &e;
}
NIXC_CATCH_ERRS
nix_err nix_set_list_byidx(nix_c_context * context, Value * value, unsigned int ix, Value * elem)
{
if (context)
context->last_err_code = NIX_OK;
try {
// todo: assert that this is a list
auto & v = check_value_not_null(value);
auto & e = check_value_not_null(elem);
v.listElems()[ix] = &e;
}
NIXC_CATCH_ERRS
}
nix_err nix_set_primop(nix_c_context *context, Value *value, PrimOp *p) {
if (context)
context->last_err_code = NIX_OK;
try {
auto &v = check_value_not_null(value);
v.mkPrimOp((nix::PrimOp *)p);
}
NIXC_CATCH_ERRS
nix_err nix_set_primop(nix_c_context * context, Value * value, PrimOp * p)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto & v = check_value_not_null(value);
v.mkPrimOp((nix::PrimOp *) p);
}
NIXC_CATCH_ERRS
}
nix_err nix_copy_value(nix_c_context *context, Value *value, Value *source) {
if (context)
context->last_err_code = NIX_OK;
try {
auto &v = check_value_not_null(value);
auto &s = check_value_not_null(source);
v = s;
}
NIXC_CATCH_ERRS
nix_err nix_copy_value(nix_c_context * context, Value * value, Value * source)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto & v = check_value_not_null(value);
auto & s = check_value_not_null(source);
v = s;
}
NIXC_CATCH_ERRS
}
nix_err nix_make_attrs(nix_c_context *context, Value *value,
BindingsBuilder *b) {
if (context)
context->last_err_code = NIX_OK;
try {
auto &v = check_value_not_null(value);
v.mkAttrs(b->builder);
}
NIXC_CATCH_ERRS
nix_err nix_make_attrs(nix_c_context * context, Value * value, BindingsBuilder * b)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto & v = check_value_not_null(value);
v.mkAttrs(b->builder);
}
NIXC_CATCH_ERRS
}
BindingsBuilder *nix_make_bindings_builder(nix_c_context *context, State *state,
size_t capacity) {
if (context)
context->last_err_code = NIX_OK;
try {
auto bb = state->state.buildBindings(capacity);
return new
BindingsBuilder * nix_make_bindings_builder(nix_c_context * context, State * state, size_t capacity)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto bb = state->state.buildBindings(capacity);
return new
#if HAVE_BOEHMGC
(NoGC)
(NoGC)
#endif
BindingsBuilder{std::move(bb)};
}
NIXC_CATCH_ERRS_NULL
BindingsBuilder{std::move(bb)};
}
NIXC_CATCH_ERRS_NULL
}
nix_err nix_bindings_builder_insert(nix_c_context *context, BindingsBuilder *b,
const char *name, Value *value) {
if (context)
context->last_err_code = NIX_OK;
try {
auto &v = check_value_not_null(value);
nix::Symbol s = b->builder.state.symbols.create(name);
b->builder.insert(s, &v);
}
NIXC_CATCH_ERRS
nix_err nix_bindings_builder_insert(nix_c_context * context, BindingsBuilder * b, const char * name, Value * value)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto & v = check_value_not_null(value);
nix::Symbol s = b->builder.state.symbols.create(name);
b->builder.insert(s, &v);
}
NIXC_CATCH_ERRS
}
void nix_bindings_builder_free(BindingsBuilder *bb) {
void nix_bindings_builder_free(BindingsBuilder * bb)
{
#if HAVE_BOEHMGC
GC_FREE((nix::BindingsBuilder *)bb);
GC_FREE((nix::BindingsBuilder *) bb);
#else
delete (nix::BindingsBuilder *)bb;
delete (nix::BindingsBuilder *) bb;
#endif
}

110
src/libexpr/c/nix_api_value.h
View file

@ -20,17 +20,17 @@ extern "C" {
// Type definitions
typedef enum {
NIX_TYPE_THUNK,
NIX_TYPE_INT,
NIX_TYPE_FLOAT,
NIX_TYPE_BOOL,
NIX_TYPE_STRING,
NIX_TYPE_PATH,
NIX_TYPE_NULL,
NIX_TYPE_ATTRS,
NIX_TYPE_LIST,
NIX_TYPE_FUNCTION,
NIX_TYPE_EXTERNAL
NIX_TYPE_THUNK,
NIX_TYPE_INT,
NIX_TYPE_FLOAT,
NIX_TYPE_BOOL,
NIX_TYPE_STRING,
NIX_TYPE_PATH,
NIX_TYPE_NULL,
NIX_TYPE_ATTRS,
NIX_TYPE_LIST,
NIX_TYPE_FUNCTION,
NIX_TYPE_EXTERNAL
} ValueType;
// forward declarations
@ -67,11 +67,12 @@ typedef struct ExternalValue ExternalValue;
/** @brief Function pointer for primops
* @param[in] state Evaluator state
* @param[in] pos Call position, opaque index into the state's position table.
* @param[in] args list of arguments. Note that these can be thunks and should be forced using nix_value_force before use.
* @param[in] args list of arguments. Note that these can be thunks and should be forced using nix_value_force before
* use.
* @param[out] ret return value
* @see nix_alloc_primop, nix_set_primop
*/
typedef void (*PrimOpFun)(State *state, int pos, Value **args, Value *ret);
typedef void (*PrimOpFun)(State * state, int pos, Value ** args, Value * ret);
/** @brief Allocate a PrimOp
*
@ -87,8 +88,8 @@ typedef void (*PrimOpFun)(State *state, int pos, Value **args, Value *ret);
* @return primop, or null in case of errors
* @see nix_set_primop
*/
PrimOp *nix_alloc_primop(nix_c_context *context, PrimOpFun fun, int arity,
const char *name, const char **args, const char *doc);
PrimOp * nix_alloc_primop(
nix_c_context * context, PrimOpFun fun, int arity, const char * name, const char ** args, const char * doc);
/** @brief add a primop to the `builtins` attribute set
*
@ -102,7 +103,7 @@ PrimOp *nix_alloc_primop(nix_c_context *context, PrimOpFun fun, int arity,
* @return primop, or null in case of errors
*
*/
nix_err nix_register_primop(nix_c_context *context, PrimOp *primOp);
nix_err nix_register_primop(nix_c_context * context, PrimOp * primOp);
/** @} */
// Function prototypes
@ -115,7 +116,7 @@ nix_err nix_register_primop(nix_c_context *context, PrimOp *primOp);
* @return value, or null in case of errors
*
*/
Value *nix_alloc_value(nix_c_context *context, State *state);
Value * nix_alloc_value(nix_c_context * context, State * state);
/** @addtogroup value_manip Manipulating values
* @brief Functions to inspect and change Nix language values, represented by Value.
* @{
@ -128,65 +129,65 @@ Value *nix_alloc_value(nix_c_context *context, State *state);
* @param[in] value Nix value to inspect
* @return type of nix value
*/
ValueType nix_get_type(nix_c_context *context, const Value *value);
ValueType nix_get_type(nix_c_context * context, const Value * value);
/** @brief Get type name of value as defined in the evaluator
* @param[out] context Optional, stores error information
* @param[in] value Nix value to inspect
* @return type name, owned string
* @todo way to free the result
*/
const char *nix_get_typename(nix_c_context *context, const Value *value);
const char * nix_get_typename(nix_c_context * context, const Value * value);
/** @brief Get boolean value
* @param[out] context Optional, stores error information
* @param[in] value Nix value to inspect
* @return true or false, error info via context
*/
bool nix_get_bool(nix_c_context *context, const Value *value);
bool nix_get_bool(nix_c_context * context, const Value * value);
/** @brief Get string
* @param[out] context Optional, stores error information
* @param[in] value Nix value to inspect
* @return string
* @return NULL in case of error.
*/
const char *nix_get_string(nix_c_context *context, const Value *value);
const char * nix_get_string(nix_c_context * context, const Value * value);
/** @brief Get path as string
* @param[out] context Optional, stores error information
* @param[in] value Nix value to inspect
* @return string
* @return NULL in case of error.
*/
const char *nix_get_path_string(nix_c_context *context, const Value *value);
const char * nix_get_path_string(nix_c_context * context, const Value * value);
/** @brief Get the length of a list
* @param[out] context Optional, stores error information
* @param[in] value Nix value to inspect
* @return length of list, error info via context
*/
unsigned int nix_get_list_size(nix_c_context *context, const Value *value);
unsigned int nix_get_list_size(nix_c_context * context, const Value * value);
/** @brief Get the element count of an attrset
* @param[out] context Optional, stores error information
* @param[in] value Nix value to inspect
* @return attrset element count, error info via context
*/
unsigned int nix_get_attrs_size(nix_c_context *context, const Value *value);
unsigned int nix_get_attrs_size(nix_c_context * context, const Value * value);
/** @brief Get float value in 64 bits
* @param[out] context Optional, stores error information
* @param[in] value Nix value to inspect
* @return float contents, error info via context
*/
double nix_get_float(nix_c_context *context, const Value *value);
double nix_get_float(nix_c_context * context, const Value * value);
/** @brief Get int value
* @param[out] context Optional, stores error information
* @param[in] value Nix value to inspect
* @return int contents, error info via context
*/
int64_t nix_get_int(nix_c_context *context, const Value *value);
int64_t nix_get_int(nix_c_context * context, const Value * value);
/** @brief Get external reference
* @param[out] context Optional, stores error information
* @param[in] value Nix value to inspect
* @return reference to external, NULL in case of error
*/
ExternalValue *nix_get_external(nix_c_context *context, Value *);
ExternalValue * nix_get_external(nix_c_context * context, Value *);
/** @brief Get the ix'th element of a list
*
@ -197,8 +198,7 @@ ExternalValue *nix_get_external(nix_c_context *context, Value *);
* @param[in] ix list element to get
* @return value, NULL in case of errors
*/
Value *nix_get_list_byidx(nix_c_context *context, const Value *value,
State *state, unsigned int ix);
Value * nix_get_list_byidx(nix_c_context * context, const Value * value, State * state, unsigned int ix);
/** @brief Get an attr by name
*
* Owned by the GC. Use nix_gc_decref when you're done with the pointer
@ -208,8 +208,7 @@ Value *nix_get_list_byidx(nix_c_context *context, const Value *value,
* @param[in] name attribute name
* @return value, NULL in case of errors
*/
Value *nix_get_attr_byname(nix_c_context *context, const Value *value,
State *state, const char *name);
Value * nix_get_attr_byname(nix_c_context * context, const Value * value, State * state, const char * name);
/** @brief Check if an attribute name exists on a value
* @param[out] context Optional, stores error information
@ -218,8 +217,7 @@ Value *nix_get_attr_byname(nix_c_context *context, const Value *value,
* @param[in] name attribute name
* @return value, error info via context
*/
bool nix_has_attr_byname(nix_c_context *context, const Value *value,
State *state, const char *name);
bool nix_has_attr_byname(nix_c_context * context, const Value * value, State * state, const char * name);
/** @brief Get an attribute by index in the sorted bindings
*
@ -233,8 +231,8 @@ bool nix_has_attr_byname(nix_c_context *context, const Value *value,
* @param[out] name will store a pointer to the attribute name
* @return value, NULL in case of errors
*/
Value *nix_get_attr_byidx(nix_c_context *context, const Value *value,
State *state, unsigned int i, const char **name);
Value *
nix_get_attr_byidx(nix_c_context * context, const Value * value, State * state, unsigned int i, const char ** name);
/** @brief Get an attribute name by index in the sorted bindings
*
@ -247,8 +245,7 @@ Value *nix_get_attr_byidx(nix_c_context *context, const Value *value,
* @param[in] i attribute index
* @return name, NULL in case of errors
*/
const char *nix_get_attr_name_byidx(nix_c_context *context, const Value *value,
State *state, unsigned int i);
const char * nix_get_attr_name_byidx(nix_c_context * context, const Value * value, State * state, unsigned int i);
/**@}*/
/** @name Setters
*/
@ -259,58 +256,55 @@ const char *nix_get_attr_name_byidx(nix_c_context *context, const Value *value,
* @param[in] b the boolean value
* @return error code, NIX_OK on success.
*/
nix_err nix_set_bool(nix_c_context *context, Value *value, bool b);
nix_err nix_set_bool(nix_c_context * context, Value * value, bool b);
/** @brief Set a string
* @param[out] context Optional, stores error information
* @param[out] value Nix value to modify
* @param[in] str the string, copied
* @return error code, NIX_OK on success.
*/
nix_err nix_set_string(nix_c_context *context, Value *value, const char *str);
nix_err nix_set_string(nix_c_context * context, Value * value, const char * str);
/** @brief Set a path
* @param[out] context Optional, stores error information
* @param[out] value Nix value to modify
* @param[in] str the path string, copied
* @return error code, NIX_OK on success.
*/
nix_err nix_set_path_string(nix_c_context *context, Value *value,
const char *str);
nix_err nix_set_path_string(nix_c_context * context, Value * value, const char * str);
/** @brief Set a float
* @param[out] context Optional, stores error information
* @param[out] value Nix value to modify
* @param[in] d the float, 64-bits
* @return error code, NIX_OK on success.
*/
nix_err nix_set_float(nix_c_context *context, Value *value, double d);
nix_err nix_set_float(nix_c_context * context, Value * value, double d);
/** @brief Set an int
* @param[out] context Optional, stores error information
* @param[out] value Nix value to modify
* @param[in] i the int
* @return error code, NIX_OK on success.
*/
nix_err nix_set_int(nix_c_context *context, Value *value, int64_t i);
nix_err nix_set_int(nix_c_context * context, Value * value, int64_t i);
/** @brief Set null
* @param[out] context Optional, stores error information
* @param[out] value Nix value to modify
* @return error code, NIX_OK on success.
*/
nix_err nix_set_null(nix_c_context *context, Value *value);
nix_err nix_set_null(nix_c_context * context, Value * value);
/** @brief Set an external value
* @param[out] context Optional, stores error information
* @param[out] value Nix value to modify
* @param[in] val the external value to set. Will be GC-referenced by the value.
* @return error code, NIX_OK on success.
*/
nix_err nix_set_external(nix_c_context *context, Value *value,
ExternalValue *val);
nix_err nix_set_external(nix_c_context * context, Value * value, ExternalValue * val);
/** @brief Allocate a list
* @param[out] context Optional, stores error information
* @param[out] value Nix value to modify
* @param[in] size size of list
* @return error code, NIX_OK on success.
*/
nix_err nix_make_list(nix_c_context *context, State *s, Value *value,
unsigned int size);
nix_err nix_make_list(nix_c_context * context, State * s, Value * value, unsigned int size);
/** @brief Manipulate a list by index
*
* Don't do this mid-computation.
@ -321,16 +315,14 @@ nix_err nix_make_list(nix_c_context *context, State *s, Value *value,
* @param[in] elem the value to set, will be gc-referenced by the value
* @return error code, NIX_OK on success.
*/
nix_err nix_set_list_byidx(nix_c_context *context, Value *value,
unsigned int ix, Value *elem);
nix_err nix_set_list_byidx(nix_c_context * context, Value * value, unsigned int ix, Value * elem);
/** @brief Create an attribute set from a bindings builder
* @param[out] context Optional, stores error information
* @param[out] value Nix value to modify
* @param[in] b bindings builder to use. Make sure to unref this afterwards.
* @return error code, NIX_OK on success.
*/
nix_err nix_make_attrs(nix_c_context *context, Value *value,
BindingsBuilder *b);
nix_err nix_make_attrs(nix_c_context * context, Value * value, BindingsBuilder * b);
/** @brief Set primop
* @param[out] context Optional, stores error information
* @param[out] value Nix value to modify
@ -338,14 +330,14 @@ nix_err nix_make_attrs(nix_c_context *context, Value *value,
* @see nix_alloc_primop
* @return error code, NIX_OK on success.
*/
nix_err nix_set_primop(nix_c_context *context, Value *value, PrimOp *op);
nix_err nix_set_primop(nix_c_context * context, Value * value, PrimOp * op);
/** @brief Copy from another value
* @param[out] context Optional, stores error information
* @param[out] value Nix value to modify
* @param[in] source value to copy from
* @return error code, NIX_OK on success.
*/
nix_err nix_copy_value(nix_c_context *context, Value *value, Value *source);
nix_err nix_copy_value(nix_c_context * context, Value * value, Value * source);
/**@}*/
/** @brief Create a bindings builder
@ -356,8 +348,7 @@ nix_err nix_copy_value(nix_c_context *context, Value *value, Value *source);
* @return owned reference to a bindings builder. Make sure to unref when you're
done.
*/
BindingsBuilder *nix_make_bindings_builder(nix_c_context *context, State *state,
size_t capacity);
BindingsBuilder * nix_make_bindings_builder(nix_c_context * context, State * state, size_t capacity);
/** @brief Insert bindings into a builder
* @param[out] context Optional, stores error information
* @param[in] builder BindingsBuilder to insert into
@ -365,15 +356,14 @@ BindingsBuilder *nix_make_bindings_builder(nix_c_context *context, State *state,
* @param[in] value value to give the binding
* @return error code, NIX_OK on success.
*/
nix_err nix_bindings_builder_insert(nix_c_context *context,
BindingsBuilder *builder, const char *name,
Value *value);
nix_err
nix_bindings_builder_insert(nix_c_context * context, BindingsBuilder * builder, const char * name, Value * value);
/** @brief Free a bindings builder
*
* Does not fail.
* @param[in] builder the builder to free
*/
void nix_bindings_builder_free(BindingsBuilder *builder);
void nix_bindings_builder_free(BindingsBuilder * builder);
/**@}*/
// cffi end

224
src/libstore/c/nix_api_store.cc
View file

@ -7,122 +7,132 @@
#include "globals.hh"
struct StorePath {
nix::StorePath path;
struct StorePath
{
nix::StorePath path;
};
nix_err nix_libstore_init(nix_c_context *context) {
if (context)
context->last_err_code = NIX_OK;
try {
nix::initLibStore();
}
NIXC_CATCH_ERRS
}
nix_err nix_init_plugins(nix_c_context *context) {
if (context)
context->last_err_code = NIX_OK;
try {
nix::initPlugins();
}
NIXC_CATCH_ERRS
}
Store *nix_store_open(nix_c_context *context, const char *uri,
const char ***params) {
if (context)
context->last_err_code = NIX_OK;
try {
if (!uri) {
return new Store{nix::openStore()};
} else {
std::string uri_str = uri;
if (!params)
return new Store{nix::openStore(uri_str)};
nix::Store::Params params_map;
for (size_t i = 0; params[i] != nullptr; i++) {
params_map[params[i][0]] = params[i][1];
}
return new Store{nix::openStore(uri_str, params_map)};
nix_err nix_libstore_init(nix_c_context * context)
{
if (context)
context->last_err_code = NIX_OK;
try {
nix::initLibStore();
}
}
NIXC_CATCH_ERRS_NULL
NIXC_CATCH_ERRS
}
void nix_store_unref(Store *store) { delete store; }
nix_err nix_store_get_uri(nix_c_context *context, Store *store, char *dest,
unsigned int n) {
if (context)
context->last_err_code = NIX_OK;
try {
auto res = store->ptr->getUri();
return nix_export_std_string(context, res, dest, n);
}
NIXC_CATCH_ERRS
}
nix_err nix_store_get_version(nix_c_context *context, Store *store, char *dest,
unsigned int n) {
if (context)
context->last_err_code = NIX_OK;
try {
auto res = store->ptr->getVersion();
if (res) {
return nix_export_std_string(context, *res, dest, n);
} else {
return nix_set_err_msg(context, NIX_ERR_UNKNOWN,
"store does not have a version");
nix_err nix_init_plugins(nix_c_context * context)
{
if (context)
context->last_err_code = NIX_OK;
try {
nix::initPlugins();
}
}
NIXC_CATCH_ERRS
NIXC_CATCH_ERRS
}
bool nix_store_is_valid_path(nix_c_context *context, Store *store,
StorePath *path) {
if (context)
context->last_err_code = NIX_OK;
try {
return store->ptr->isValidPath(path->path);
}
NIXC_CATCH_ERRS_RES(false);
}
Store * nix_store_open(nix_c_context * context, const char * uri, const char *** params)
{
if (context)
context->last_err_code = NIX_OK;
try {
if (!uri) {
return new Store{nix::openStore()};
} else {
std::string uri_str = uri;
if (!params)
return new Store{nix::openStore(uri_str)};
StorePath *nix_store_parse_path(nix_c_context *context, Store *store,
const char *path) {
if (context)
context->last_err_code = NIX_OK;
try {
nix::StorePath s = store->ptr->parseStorePath(path);
return new StorePath{std::move(s)};
}
NIXC_CATCH_ERRS_NULL
}
nix_err nix_store_build(nix_c_context *context, Store *store, StorePath *path,
void *userdata,
void (*callback)(void *userdata, const char *,
const char *)) {
if (context)
context->last_err_code = NIX_OK;
try {
store->ptr->buildPaths({
nix::DerivedPath::Built{
.drvPath = path->path,
.outputs = nix::OutputsSpec::All{},
},
});
if (callback) {
for (auto &[outputName, outputPath] :
store->ptr->queryDerivationOutputMap(path->path)) {
auto op = store->ptr->printStorePath(outputPath);
callback(userdata, outputName.c_str(), op.c_str());
}
nix::Store::Params params_map;
for (size_t i = 0; params[i] != nullptr; i++) {
params_map[params[i][0]] = params[i][1];
}
return new Store{nix::openStore(uri_str, params_map)};
}
}
}
NIXC_CATCH_ERRS
NIXC_CATCH_ERRS_NULL
}
void nix_store_path_free(StorePath *sp) { delete sp; }
void nix_store_unref(Store * store)
{
delete store;
}
nix_err nix_store_get_uri(nix_c_context * context, Store * store, char * dest, unsigned int n)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto res = store->ptr->getUri();
return nix_export_std_string(context, res, dest, n);
}
NIXC_CATCH_ERRS
}
nix_err nix_store_get_version(nix_c_context * context, Store * store, char * dest, unsigned int n)
{
if (context)
context->last_err_code = NIX_OK;
try {
auto res = store->ptr->getVersion();
if (res) {
return nix_export_std_string(context, *res, dest, n);
} else {
return nix_set_err_msg(context, NIX_ERR_UNKNOWN, "store does not have a version");
}
}
NIXC_CATCH_ERRS
}
bool nix_store_is_valid_path(nix_c_context * context, Store * store, StorePath * path)
{
if (context)
context->last_err_code = NIX_OK;
try {
return store->ptr->isValidPath(path->path);
}
NIXC_CATCH_ERRS_RES(false);
}
StorePath * nix_store_parse_path(nix_c_context * context, Store * store, const char * path)
{
if (context)
context->last_err_code = NIX_OK;
try {
nix::StorePath s = store->ptr->parseStorePath(path);
return new StorePath{std::move(s)};
}
NIXC_CATCH_ERRS_NULL
}
nix_err nix_store_build(
nix_c_context * context,
Store * store,
StorePath * path,
void * userdata,
void (*callback)(void * userdata, const char *, const char *))
{
if (context)
context->last_err_code = NIX_OK;
try {
store->ptr->buildPaths({
nix::DerivedPath::Built{
.drvPath = path->path,
.outputs = nix::OutputsSpec::All{},
},
});
if (callback) {
for (auto & [outputName, outputPath] : store->ptr->queryDerivationOutputMap(path->path)) {
auto op = store->ptr->printStorePath(outputPath);
callback(userdata, outputName.c_str(), op.c_str());
}
}
}
NIXC_CATCH_ERRS
}
void nix_store_path_free(StorePath * sp)
{
delete sp;
}

35
src/libstore/c/nix_api_store.h
View file

@ -33,7 +33,7 @@ typedef struct StorePath StorePath;
* @param[out] context Optional, stores error information
* @return NIX_OK if the initialization was successful, an error code otherwise.
*/
nix_err nix_libstore_init(nix_c_context *context);
nix_err nix_libstore_init(nix_c_context * context);
/**
* @brief Loads the plugins specified in Nix's plugin-files setting.
@ -44,7 +44,7 @@ nix_err nix_libstore_init(nix_c_context *context);
* @param[out] context Optional, stores error information
* @return NIX_OK if the initialization was successful, an error code otherwise.
*/
nix_err nix_init_plugins(nix_c_context *context);
nix_err nix_init_plugins(nix_c_context * context);
/**
* @brief Open a nix store
@ -55,7 +55,7 @@ nix_err nix_init_plugins(nix_c_context *context);
* @return ref-counted Store pointer, NULL in case of errors
* @see nix_store_unref
*/
Store *nix_store_open(nix_c_context *, const char *uri, const char ***params);
Store * nix_store_open(nix_c_context *, const char * uri, const char *** params);
/**
* @brief Unref a nix store
@ -64,7 +64,7 @@ Store *nix_store_open(nix_c_context *, const char *uri, const char ***params);
* It'll be closed and deallocated when all references are gone.
* @param[in] builder the store to unref
*/
void nix_store_unref(Store *store);
void nix_store_unref(Store * store);
/**
* @brief get the URI of a nix store
@ -74,8 +74,7 @@ void nix_store_unref(Store *store);
* @param[in] n Maximum size of the returned string.
* @return error code, NIX_OK on success.
*/
nix_err nix_store_get_uri(nix_c_context *context, Store *store, char *dest,
unsigned int n);
nix_err nix_store_get_uri(nix_c_context * context, Store * store, char * dest, unsigned int n);
// returns: owned StorePath*
/**
@ -87,25 +86,24 @@ nix_err nix_store_get_uri(nix_c_context *context, Store *store, char *dest,
* @param[in] path Path string to parse, copied
* @return owned store path, NULL on error
*/
StorePath *nix_store_parse_path(nix_c_context *context, Store *store,
const char *path);
StorePath * nix_store_parse_path(nix_c_context * context, Store * store, const char * path);
/** @brief Deallocate a StorePath
*
* Does not fail.
* @param[in] p the path to free
*/
void nix_store_path_free(StorePath *p);
void nix_store_path_free(StorePath * p);
/**
* @brief Check if a StorePath is valid (i.e. that corresponding store object and its closure of references exists in the store)
* @brief Check if a StorePath is valid (i.e. that corresponding store object and its closure of references exists in
* the store)
* @param[out] context Optional, stores error information
* @param[in] store Nix Store reference
* @param[in] path Path to check
* @return true or false, error info in context
*/
bool nix_store_is_valid_path(nix_c_context *context, Store *store,
StorePath *path);
bool nix_store_is_valid_path(nix_c_context * context, Store * store, StorePath * path);
// nix_err nix_store_ensure(Store*, const char*);
// nix_err nix_store_build_paths(Store*);
/**
@ -119,10 +117,12 @@ bool nix_store_is_valid_path(nix_c_context *context, Store *store,
* @param[in] userdata data to pass to every callback invocation
* @param[in] callback called for every realised output
*/
nix_err nix_store_build(nix_c_context *context, Store *store, StorePath *path,
void *userdata,
void (*callback)(void *userdata, const char *outname,
const char *out));
nix_err nix_store_build(
nix_c_context * context,
Store * store,
StorePath * path,
void * userdata,
void (*callback)(void * userdata, const char * outname, const char * out));
/**
* @brief get the version of a nix store
@ -132,8 +132,7 @@ nix_err nix_store_build(nix_c_context *context, Store *store, StorePath *path,
* @param[in] n Maximum size of the returned string.
* @return error code, NIX_OK on success.
*/
nix_err nix_store_get_version(nix_c_context *, Store *store, char *dest,
unsigned int n);
nix_err nix_store_get_version(nix_c_context *, Store * store, char * dest, unsigned int n);
// cffi end
#ifdef __cplusplus

5
src/libstore/c/nix_api_store_internal.h
View file

@ -2,7 +2,8 @@
#define NIX_API_STORE_INTERNAL_H
#include "store-api.hh"
struct Store {
nix::ref<nix::Store> ptr;
struct Store
{
nix::ref<nix::Store> ptr;
};
#endif

226
src/libutil/c/nix_api_util.cc
View file

@ -7,139 +7,145 @@
#include <cxxabi.h>
#include <typeinfo>
nix_c_context *nix_c_context_create() { return new nix_c_context(); }
nix_c_context * nix_c_context_create()
{
return new nix_c_context();
}
void nix_c_context_free(nix_c_context *context) { delete context; }
void nix_c_context_free(nix_c_context * context)
{
delete context;
}
nix_err nix_context_error(nix_c_context *context) {
if (context == nullptr) {
throw;
}
try {
throw;
} catch (nix::Error &e) {
/* Storing this exception is annoying, take what we need here */
context->last_err = e.what();
context->info = e.info();
int status;
const char *demangled =
abi::__cxa_demangle(typeid(e).name(), 0, 0, &status);
if (demangled) {
context->name = demangled;
// todo: free(demangled);
} else {
context->name = typeid(e).name();
nix_err nix_context_error(nix_c_context * context)
{
if (context == nullptr) {
throw;
}
context->last_err_code = NIX_ERR_NIX_ERROR;
return context->last_err_code;
} catch (const std::exception &e) {
context->last_err = e.what();
context->last_err_code = NIX_ERR_UNKNOWN;
return context->last_err_code;
}
// unreachable
try {
throw;
} catch (nix::Error & e) {
/* Storing this exception is annoying, take what we need here */
context->last_err = e.what();
context->info = e.info();
int status;
const char * demangled = abi::__cxa_demangle(typeid(e).name(), 0, 0, &status);
if (demangled) {
context->name = demangled;
// todo: free(demangled);
} else {
context->name = typeid(e).name();
}
context->last_err_code = NIX_ERR_NIX_ERROR;
return context->last_err_code;
} catch (const std::exception & e) {
context->last_err = e.what();
context->last_err_code = NIX_ERR_UNKNOWN;
return context->last_err_code;
}
// unreachable
}
nix_err nix_set_err_msg(nix_c_context *context, nix_err err, const char *msg) {
if (context == nullptr) {
// todo last_err_code
throw nix::Error("Nix C api error: %s", msg);
}
context->last_err_code = err;
context->last_err = msg;
return err;
nix_err nix_set_err_msg(nix_c_context * context, nix_err err, const char * msg)
{
if (context == nullptr) {
// todo last_err_code
throw nix::Error("Nix C api error: %s", msg);
}
context->last_err_code = err;
context->last_err = msg;
return err;
}
const char *nix_version_get() { return PACKAGE_VERSION; }
const char * nix_version_get()
{
return PACKAGE_VERSION;
}
// Implementations
nix_err nix_setting_get(nix_c_context *context, const char *key, char *value,
int n) {
if (context)
context->last_err_code = NIX_OK;
try {
std::map<std::string, nix::AbstractConfig::SettingInfo> settings;
nix::globalConfig.getSettings(settings);
if (settings.contains(key))
return nix_export_std_string(context, settings[key].value, value, n);
else {
return nix_set_err_msg(context, NIX_ERR_KEY, "Setting not found");
nix_err nix_setting_get(nix_c_context * context, const char * key, char * value, int n)
{
if (context)
context->last_err_code = NIX_OK;
try {
std::map<std::string, nix::AbstractConfig::SettingInfo> settings;
nix::globalConfig.getSettings(settings);
if (settings.contains(key))
return nix_export_std_string(context, settings[key].value, value, n);
else {
return nix_set_err_msg(context, NIX_ERR_KEY, "Setting not found");
}
}
}
NIXC_CATCH_ERRS
NIXC_CATCH_ERRS
}
nix_err nix_setting_set(nix_c_context *context, const char *key,
const char *value) {
if (context)
context->last_err_code = NIX_OK;
if (nix::globalConfig.set(key, value))
return NIX_OK;
else {
return nix_set_err_msg(context, NIX_ERR_KEY, "Setting not found");
}
nix_err nix_setting_set(nix_c_context * context, const char * key, const char * value)
{
if (context)
context->last_err_code = NIX_OK;
if (nix::globalConfig.set(key, value))
return NIX_OK;
else {
return nix_set_err_msg(context, NIX_ERR_KEY, "Setting not found");
}
}
nix_err nix_libutil_init(nix_c_context *context) {
if (context)
context->last_err_code = NIX_OK;
try {
nix::initLibUtil();
return NIX_OK;
}
NIXC_CATCH_ERRS
nix_err nix_libutil_init(nix_c_context * context)
{
if (context)
context->last_err_code = NIX_OK;
try {
nix::initLibUtil();
return NIX_OK;
}
NIXC_CATCH_ERRS
}
const char *nix_err_msg(nix_c_context *context,
const nix_c_context *read_context, unsigned int *n) {
if (context)
context->last_err_code = NIX_OK;
if (read_context->last_err) {
if (n)
*n = read_context->last_err->size();
return read_context->last_err->c_str();
}
nix_set_err_msg(context, NIX_ERR_UNKNOWN, "No error message");
return nullptr;
const char * nix_err_msg(nix_c_context * context, const nix_c_context * read_context, unsigned int * n)
{
if (context)
context->last_err_code = NIX_OK;
if (read_context->last_err) {
if (n)
*n = read_context->last_err->size();
return read_context->last_err->c_str();
}
nix_set_err_msg(context, NIX_ERR_UNKNOWN, "No error message");
return nullptr;
}
nix_err nix_err_name(nix_c_context *context, const nix_c_context *read_context,
char *value, int n) {
if (context)
context->last_err_code = NIX_OK;
if (read_context->last_err_code != NIX_ERR_NIX_ERROR) {
return nix_set_err_msg(context, NIX_ERR_UNKNOWN,
"Last error was not a nix error");
}
return nix_export_std_string(context, read_context->name, value, n);
nix_err nix_err_name(nix_c_context * context, const nix_c_context * read_context, char * value, int n)
{
if (context)
context->last_err_code = NIX_OK;
if (read_context->last_err_code != NIX_ERR_NIX_ERROR) {
return nix_set_err_msg(context, NIX_ERR_UNKNOWN, "Last error was not a nix error");
}
return nix_export_std_string(context, read_context->name, value, n);
}
nix_err nix_err_info_msg(nix_c_context *context,
const nix_c_context *read_context, char *value,
int n) {
if (context)
context->last_err_code = NIX_OK;
if (read_context->last_err_code != NIX_ERR_NIX_ERROR) {
return nix_set_err_msg(context, NIX_ERR_UNKNOWN,
"Last error was not a nix error");
}
return nix_export_std_string(context, read_context->info->msg.str(), value,
n);
nix_err nix_err_info_msg(nix_c_context * context, const nix_c_context * read_context, char * value, int n)
{
if (context)
context->last_err_code = NIX_OK;
if (read_context->last_err_code != NIX_ERR_NIX_ERROR) {
return nix_set_err_msg(context, NIX_ERR_UNKNOWN, "Last error was not a nix error");
}
return nix_export_std_string(context, read_context->info->msg.str(), value, n);
}
nix_err nix_err_code(const nix_c_context *read_context) {
return read_context->last_err_code;
nix_err nix_err_code(const nix_c_context * read_context)
{
return read_context->last_err_code;
}
// internal
nix_err nix_export_std_string(nix_c_context *context,
const std::string_view str, char *dest,
unsigned int n) {
size_t i = str.copy(dest, n - 1);
dest[i] = 0;
if (i == n - 1) {
return nix_set_err_msg(context, NIX_ERR_OVERFLOW,
"Provided buffer too short");
} else
return NIX_OK;
nix_err nix_export_std_string(nix_c_context * context, const std::string_view str, char * dest, unsigned int n)
{
size_t i = str.copy(dest, n - 1);
dest[i] = 0;
if (i == n - 1) {
return nix_set_err_msg(context, NIX_ERR_OVERFLOW, "Provided buffer too short");
} else
return NIX_OK;
}

25
src/libutil/c/nix_api_util.h
View file

@ -127,12 +127,12 @@ typedef struct nix_c_context nix_c_context;
* @return allocated nix_c_context, owned by the caller. Free using
* `nix_c_context_free`.
*/
nix_c_context *nix_c_context_create();
nix_c_context * nix_c_context_create();
/**
* @brief Free a nix_c_context. Does not fail.
* @param[out] context The context to free, mandatory.
*/
void nix_c_context_free(nix_c_context *context);
void nix_c_context_free(nix_c_context * context);
/**
* @}
*/
@ -147,7 +147,7 @@ void nix_c_context_free(nix_c_context *context);
* @return NIX_OK if the initialization is successful, or an error code
* otherwise.
*/
nix_err nix_libutil_init(nix_c_context *context);
nix_err nix_libutil_init(nix_c_context * context);
/** @defgroup settings
* @{
@ -167,8 +167,7 @@ nix_err nix_libutil_init(nix_c_context *context);
* provided buffer is too short, or NIX_OK if the setting was retrieved
* successfully.
*/
nix_err nix_setting_get(nix_c_context *context, const char *key, char *value,
int n);
nix_err nix_setting_get(nix_c_context * context, const char * key, char * value, int n);
/**
* @brief Sets a setting in the nix global configuration.
@ -184,8 +183,7 @@ nix_err nix_setting_get(nix_c_context *context, const char *key, char *value,
* @return NIX_ERR_KEY if the setting is unknown, or NIX_OK if the setting was
* set successfully.
*/
nix_err nix_setting_set(nix_c_context *context, const char *key,
const char *value);
nix_err nix_setting_set(nix_c_context * context, const char * key, const char * value);
/**
* @}
@ -198,7 +196,7 @@ nix_err nix_setting_set(nix_c_context *context, const char *key,
* Does not fail.
* @return A static string representing the version of the nix library.
*/
const char *nix_version_get();
const char * nix_version_get();
/** @addtogroup errors
* @{
@ -217,8 +215,7 @@ const char *nix_version_get();
* @return nullptr if no error message was ever set,
* a borrowed pointer to the error message otherwise.
*/
const char *nix_err_msg(nix_c_context *context, const nix_c_context *ctx,
unsigned int *n);
const char * nix_err_msg(nix_c_context * context, const nix_c_context * ctx, unsigned int * n);
/**
* @brief Retrieves the error message from errorInfo in a context.
@ -235,8 +232,7 @@ const char *nix_err_msg(nix_c_context *context, const nix_c_context *ctx,
* @param[in] n Maximum size of the returned string.
* @return NIX_OK if there were no errors, an error code otherwise.
*/
nix_err nix_err_info_msg(nix_c_context *context,
const nix_c_context *read_context, char *value, int n);
nix_err nix_err_info_msg(nix_c_context * context, const nix_c_context * read_context, char * value, int n);
/**
* @brief Retrieves the error name from a context.
@ -253,8 +249,7 @@ nix_err nix_err_info_msg(nix_c_context *context,
* @param[in] n Maximum size of the returned string.
* @return NIX_OK if there were no errors, an error code otherwise.
*/
nix_err nix_err_name(nix_c_context *context, const nix_c_context *read_context,
char *value, int n);
nix_err nix_err_name(nix_c_context * context, const nix_c_context * read_context, char * value, int n);
/**
* @brief Retrieves the most recent error code from a nix_c_context
@ -266,7 +261,7 @@ nix_err nix_err_name(nix_c_context *context, const nix_c_context *read_context,
* @param[in] read_context the context to retrieve the error message from
* @return most recent error code stored in the context.
*/
nix_err nix_err_code(const nix_c_context *read_context);
nix_err nix_err_code(const nix_c_context * read_context);
/**
* @}

41
src/libutil/c/nix_api_util_internal.h
View file

@ -7,14 +7,15 @@
#include "error.hh"
#include "nix_api_util.h"
struct nix_c_context {
nix_err last_err_code = NIX_OK;
std::optional<std::string> last_err = {};
std::optional<nix::ErrorInfo> info = {};
std::string name = "";
struct nix_c_context
{
nix_err last_err_code = NIX_OK;
std::optional<std::string> last_err = {};
std::optional<nix::ErrorInfo> info = {};
std::string name = "";
};
nix_err nix_context_error(nix_c_context *context);
nix_err nix_context_error(nix_c_context * context);
/**
* Internal use only.
@ -26,7 +27,7 @@ nix_err nix_context_error(nix_c_context *context);
* @param msg The error message to set.
* @returns the error code set
*/
nix_err nix_set_err_msg(nix_c_context *context, nix_err err, const char *msg);
nix_err nix_set_err_msg(nix_c_context * context, nix_err err, const char * msg);
/**
* Internal use only.
@ -40,21 +41,21 @@ nix_err nix_set_err_msg(nix_c_context *context, nix_err err, const char *msg);
* @return NIX_OK if there were no errors, NIX_ERR_OVERFLOW if the string length
* exceeds `n`.
*/
nix_err nix_export_std_string(nix_c_context *context,
const std::string_view str, char *dest,
unsigned int n);
nix_err nix_export_std_string(nix_c_context * context, const std::string_view str, char * dest, unsigned int n);
#define NIXC_CATCH_ERRS \
catch (...) { \
return nix_context_error(context); \
} \
return NIX_OK;
#define NIXC_CATCH_ERRS \
catch (...) \
{ \
return nix_context_error(context); \
} \
return NIX_OK;
#define NIXC_CATCH_ERRS_RES(def) \
catch (...) { \
nix_context_error(context); \
return def; \
}
#define NIXC_CATCH_ERRS_RES(def) \
catch (...) \
{ \
nix_context_error(context); \
return def; \
}
#define NIXC_CATCH_ERRS_NULL NIXC_CATCH_ERRS_RES(nullptr)
#endif // NIX_API_UTIL_INTERNAL_H