From e1bb799da9e7a5cef5856952ed35a7bd965ca9c1 Mon Sep 17 00:00:00 2001 From: Yorick van Pelt Date: Mon, 28 Aug 2023 16:45:02 +0200 Subject: [PATCH] C API: reformat according to proposed clang-format file --- src/libexpr/c/nix_api_expr.cc | 225 +++---- src/libexpr/c/nix_api_expr.h | 30 +- src/libexpr/c/nix_api_expr_internal.h | 10 +- src/libexpr/c/nix_api_external.cc | 301 ++++----- src/libexpr/c/nix_api_external.h | 179 +++--- src/libexpr/c/nix_api_value.cc | 782 ++++++++++++------------ src/libexpr/c/nix_api_value.h | 110 ++-- src/libstore/c/nix_api_store.cc | 224 +++---- src/libstore/c/nix_api_store.h | 35 +- src/libstore/c/nix_api_store_internal.h | 5 +- src/libutil/c/nix_api_util.cc | 226 +++---- src/libutil/c/nix_api_util.h | 25 +- src/libutil/c/nix_api_util_internal.h | 41 +- 13 files changed, 1115 insertions(+), 1078 deletions(-) diff --git a/src/libexpr/c/nix_api_expr.cc b/src/libexpr/c/nix_api_expr.cc index a1c6d1acb..dc114c777 100644 --- a/src/libexpr/c/nix_api_expr.cc +++ b/src/libexpr/c/nix_api_expr.cc @@ -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 *, + unsigned int, + std::hash, std::equal_to, - traceable_allocator>> + traceable_allocator>> 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 } diff --git a/src/libexpr/c/nix_api_expr.h b/src/libexpr/c/nix_api_expr.h index a6b902f96..8cc6c916c 100644 --- a/src/libexpr/c/nix_api_expr.h +++ b/src/libexpr/c/nix_api_expr.h @@ -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 diff --git a/src/libexpr/c/nix_api_expr_internal.h b/src/libexpr/c/nix_api_expr_internal.h index bae50cf59..c9906dd3a 100644 --- a/src/libexpr/c/nix_api_expr_internal.h +++ b/src/libexpr/c/nix_api_expr_internal.h @@ -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 diff --git a/src/libexpr/c/nix_api_external.cc b/src/libexpr/c/nix_api_external.cc index a927a4037..a2d776a47 100644 --- a/src/libexpr/c/nix_api_external.cc +++ b/src/libexpr/c/nix_api_external.cc @@ -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(&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(&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(&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(&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((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((nix::ExternalValueBase *) b); + if (r) + return r->get_ptr(); + return nullptr; + } + NIXC_CATCH_ERRS_NULL } diff --git a/src/libexpr/c/nix_api_external.h b/src/libexpr/c/nix_api_external.h index 3dc9d79de..00eaa4460 100644 --- a/src/libexpr/c/nix_api_external.h +++ b/src/libexpr/c/nix_api_external.h @@ -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 diff --git a/src/libexpr/c/nix_api_value.cc b/src/libexpr/c/nix_api_value.cc index dae50352b..608a625cb 100644 --- a/src/libexpr/c/nix_api_value.cc +++ b/src/libexpr/c/nix_api_value.cc @@ -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 } diff --git a/src/libexpr/c/nix_api_value.h b/src/libexpr/c/nix_api_value.h index f4d9c9584..21647552b 100644 --- a/src/libexpr/c/nix_api_value.h +++ b/src/libexpr/c/nix_api_value.h @@ -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 diff --git a/src/libstore/c/nix_api_store.cc b/src/libstore/c/nix_api_store.cc index 7b5391034..4ee97c8a1 100644 --- a/src/libstore/c/nix_api_store.cc +++ b/src/libstore/c/nix_api_store.cc @@ -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; +} diff --git a/src/libstore/c/nix_api_store.h b/src/libstore/c/nix_api_store.h index 43ded1860..91abdb201 100644 --- a/src/libstore/c/nix_api_store.h +++ b/src/libstore/c/nix_api_store.h @@ -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 diff --git a/src/libstore/c/nix_api_store_internal.h b/src/libstore/c/nix_api_store_internal.h index 59524ea8e..ef5edc788 100644 --- a/src/libstore/c/nix_api_store_internal.h +++ b/src/libstore/c/nix_api_store_internal.h @@ -2,7 +2,8 @@ #define NIX_API_STORE_INTERNAL_H #include "store-api.hh" -struct Store { - nix::ref ptr; +struct Store +{ + nix::ref ptr; }; #endif diff --git a/src/libutil/c/nix_api_util.cc b/src/libutil/c/nix_api_util.cc index 874ccdbb5..100e3b21d 100644 --- a/src/libutil/c/nix_api_util.cc +++ b/src/libutil/c/nix_api_util.cc @@ -7,139 +7,145 @@ #include #include -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 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 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; } diff --git a/src/libutil/c/nix_api_util.h b/src/libutil/c/nix_api_util.h index 4a7f6c4cd..de029ba10 100644 --- a/src/libutil/c/nix_api_util.h +++ b/src/libutil/c/nix_api_util.h @@ -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); /** * @} diff --git a/src/libutil/c/nix_api_util_internal.h b/src/libutil/c/nix_api_util_internal.h index 013d3bbbb..1aaf328c1 100644 --- a/src/libutil/c/nix_api_util_internal.h +++ b/src/libutil/c/nix_api_util_internal.h @@ -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 last_err = {}; - std::optional info = {}; - std::string name = ""; +struct nix_c_context +{ + nix_err last_err_code = NIX_OK; + std::optional last_err = {}; + std::optional 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