openinterfaces 0.6.2__tar.gz → 0.7.0__tar.gz

{openinterfaces-0.6.2 → openinterfaces-0.7.0}/CMakeLists.txt

@@ -1,14 +1,19 @@
 cmake_minimum_required(VERSION 3.18)
 
 project(
-  oif-toy-example
-  LANGUAGES C CXX
-  VERSION 0.6.2)
+  open-interfaces
+  VERSION 0.7.0
+  # SPDX_LICENSE BSD-2-Clause -- Available in CMake 4.2+
+  DESCRIPTION "Improving interoperability in scientific computing"
+  HOMEPAGE_URL https://github.com/MaRDI4NFDI/open-interfaces
+  LANGUAGES C CXX)
 
 option(OIF_OPTION_VERBOSE_DEBUG_INFO
        "Enable verbose debug info in Debug builds" OFF)
 
-option(OIF_OPTION_SANITIZE "Enable sanitizers in Debug builds" OFF)
+option(OIF_OPTION_SANITIZE "Enable sanitizers, only in Debug builds" OFF)
+
+option(OIF_OPTION_COVERAGE "Enable test coverage, only in Debug builds" OFF)
 
 # Enforce using `-std=c11`, without any extensions like `gnu11`.
 set(CMAKE_C_STANDARD 11)
@@ -26,8 +31,12 @@ if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     add_compile_definitions(OIF_OPTION_VERBOSE_DEBUG_INFO)
   endif()
   if(OIF_OPTION_SANITIZE)
-    add_compile_options(-fno-omit-frame-pointer -fsanitize=address)
-    add_link_options(-fno-omit-frame-pointer -fsanitize=address)
+    add_compile_options(-fno-omit-frame-pointer -fsanitize=address,undefined)
+    add_link_options(-fno-omit-frame-pointer -fsanitize=address,undefined)
+  endif()
+  if(OIF_OPTION_COVERAGE)
+    add_compile_options(--coverage)
+    add_link_options(--coverage)
   endif()
 endif()
 
@@ -60,14 +69,16 @@ add_subdirectory(vendor)
 add_subdirectory(common)
 add_subdirectory(dispatch)
 
-add_subdirectory(lang_julia)
-add_subdirectory(lang_python)
+if(IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/lang_c")
+  add_subdirectory(lang_c)
+endif()
 
-if(IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/oif")
-  add_subdirectory(oif)
+if(IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/lang_julia")
+  add_subdirectory(lang_julia)
 endif()
-if(IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/oif_impl")
-  add_subdirectory(oif_impl)
+
+if(IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/lang_python")
+  add_subdirectory(lang_python)
 endif()
 
 if(EXISTS examples/CMakeLists.txt)

{openinterfaces-0.6.2 → openinterfaces-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openinterfaces
-Version: 0.6.2
+Version: 0.7.0
 Summary: Open Interfaces for improving Interoperability in Scientific Computing
 Author-Email: "Dmitry I. Kabanov" <dmitry.kabanov@uni-muenster.de>, Stephan Rave <stephan.rave@uni-muenster.de>, Mario Ohlberger <mario.ohlberger@uni-muenster.de>
 License-File: LICENSE
@@ -54,9 +54,15 @@ marshalling between different languages and a set of interfaces for typical
 numerical problems such as integration of differential equations and
 optimization.
 
-| Traditional pairwise bindings-----|   | Decoupled bindings via _Open Interfaces_ |
-|:----------------------------------|---|-----------------------------------------:|
-| ![](assets/pairwise_bindings.png) |   | ![](assets/oif_bindings.png)             |
+<p align="center">
+    <img src="https://media.githubusercontent.com/media/MaRDI4NFDI/open-interfaces/refs/heads/main/assets/pairwise_bindings.png" />
+    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+    <img src="https://media.githubusercontent.com/media/MaRDI4NFDI/open-interfaces/refs/heads/main/assets/oif_bindings.png" />
+    <br />
+    <strong>A</strong>&nbsp;Traditional pairwise bindings
+    <br />
+    <strong>B</strong>&nbsp;Decoupled bindings via <em>Open Interfaces</em>
+</p>
 
 This project is the part of the [_Mathematical Research Data Initiative
 (MaRDI)_](https://mardi4nfdi.de).
@@ -76,6 +82,29 @@ Please use the
 for bug reports and feature requests and asking questions.
 
 
+## License
+
+[![License](https://img.shields.io/badge/License-BSD_2--Clause-orange.svg)](https://opensource.org/licenses/BSD-2-Clause)
+
+
+## Citing
+
+If you _MaRDI Open Interfaces_, please consider citing
+[this paper](https://openresearchsoftware.metajnl.com/articles/10.5334/jors.569):
+```bibtex
+@Article{KabanovEtAl2025,
+  author    = {Kabanov, Dmitry I. and Rave, Stephan and Ohlberger, Mario},
+  journal   = {Journal of Open Research Software},
+  title     = {Improving Interoperability in Scientific Computing via {MaRDI Open Interfaces}},
+  year      = {2025},
+  issn      = {2049-9647},
+  volume    = {13},
+  doi       = {10.5334/jors.569},
+  publisher = {Ubiquity Press, Ltd.},
+}
+```
+
+
 ## Funding
 
 This work is funded by the _Deutsche Forschungsgemeinschaft_ (DFG, _German

{openinterfaces-0.6.2 → openinterfaces-0.7.0}/README.md

@@ -25,9 +25,15 @@ marshalling between different languages and a set of interfaces for typical
 numerical problems such as integration of differential equations and
 optimization.
 
-| Traditional pairwise bindings-----|   | Decoupled bindings via _Open Interfaces_ |
-|:----------------------------------|---|-----------------------------------------:|
-| ![](assets/pairwise_bindings.png) |   | ![](assets/oif_bindings.png)             |
+<p align="center">
+    <img src="https://media.githubusercontent.com/media/MaRDI4NFDI/open-interfaces/refs/heads/main/assets/pairwise_bindings.png" />
+    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+    <img src="https://media.githubusercontent.com/media/MaRDI4NFDI/open-interfaces/refs/heads/main/assets/oif_bindings.png" />
+    <br />
+    <strong>A</strong>&nbsp;Traditional pairwise bindings
+    <br />
+    <strong>B</strong>&nbsp;Decoupled bindings via <em>Open Interfaces</em>
+</p>
 
 This project is the part of the [_Mathematical Research Data Initiative
 (MaRDI)_](https://mardi4nfdi.de).
@@ -47,6 +53,29 @@ Please use the
 for bug reports and feature requests and asking questions.
 
 
+## License
+
+[![License](https://img.shields.io/badge/License-BSD_2--Clause-orange.svg)](https://opensource.org/licenses/BSD-2-Clause)
+
+
+## Citing
+
+If you _MaRDI Open Interfaces_, please consider citing
+[this paper](https://openresearchsoftware.metajnl.com/articles/10.5334/jors.569):
+```bibtex
+@Article{KabanovEtAl2025,
+  author    = {Kabanov, Dmitry I. and Rave, Stephan and Ohlberger, Mario},
+  journal   = {Journal of Open Research Software},
+  title     = {Improving Interoperability in Scientific Computing via {MaRDI Open Interfaces}},
+  year      = {2025},
+  issn      = {2049-9647},
+  volume    = {13},
+  doi       = {10.5334/jors.569},
+  publisher = {Ubiquity Press, Ltd.},
+}
+```
+
+
 ## Funding
 
 This work is funded by the _Deutsche Forschungsgemeinschaft_ (DFG, _German

{openinterfaces-0.6.2 → openinterfaces-0.7.0}/common/oif_config_dict.c

@@ -31,6 +31,8 @@ static size_t SIZE_ = 65;
 #define MAX_KEY_LENGTH_ 1024
 #define BUF_SIZE_ 128
 
+static char prefix_[] = "oif_config_dict";
+
 static char *
 copy_key_(const char *key)
 {
@@ -67,7 +69,7 @@ oif_config_dict_init(void)
     OIFConfigDict *dict = oif_util_malloc(sizeof(OIFConfigDict));
     assert(dict != NULL);
 
-    dict->type = OIF_CONFIG_DICT;
+    dict->type = OIF_TYPE_CONFIG_DICT;
     dict->src = OIF_LANG_C;
     dict->size = 0;
     dict->buffer = NULL;
@@ -86,7 +88,7 @@ oif_config_dict_free(void *_dict)
         return;
     }
     OIFConfigDict *dict = _dict;
-    assert(dict->type == OIF_CONFIG_DICT);
+    assert(dict->type == OIF_TYPE_CONFIG_DICT);
     const char *key;
     OIFConfigEntry *entry;
     hashmap_foreach(key, entry, &dict->map)
@@ -113,7 +115,7 @@ oif_config_dict_add_int(OIFConfigDict *dict, const char *key, int value)
         fprintf(stderr, "Could not add an entry to the config dictionary\n");
         exit(1);
     }
-    entry->type = OIF_INT;
+    entry->type = OIF_TYPE_INT;
     entry->value = oif_util_malloc(sizeof(int));
     if (entry->value == NULL) {
         fprintf(stderr, "Could not allocate memory for adding an int entry\n");
@@ -135,7 +137,7 @@ oif_config_dict_add_double(OIFConfigDict *dict, const char *key, double value)
         fprintf(stderr, "Could not add an entry to the config dictionary\n");
         exit(1);
     }
-    entry->type = OIF_FLOAT64;
+    entry->type = OIF_TYPE_F64;
     entry->value = oif_util_malloc(sizeof(double));
     if (entry->value == NULL) {
         fprintf(stderr, "Could not allocate memory for adding a double entry\n");
@@ -157,7 +159,7 @@ oif_config_dict_add_str(OIFConfigDict *dict, const char *key, const char *value)
         fprintf(stderr, "Could not add an entry to the config dictionary\n");
         exit(1);
     }
-    entry->type = OIF_STR;
+    entry->type = OIF_TYPE_STRING;
     entry->value = oif_util_str_duplicate(value);
     if (entry->value == NULL) {
         fprintf(stderr, "Could not allocate memory for adding a string entry\n");
@@ -216,7 +218,7 @@ oif_config_dict_get_int(OIFConfigDict *dict, const char *key)
         exit(1);
     }
 
-    assert(entry->type == OIF_INT);
+    assert(entry->type == OIF_TYPE_INT);
     int int_value = *(int *)entry->value;
     return int_value;
 }
@@ -230,7 +232,7 @@ oif_config_dict_get_double(OIFConfigDict *dict, const char *key)
         exit(1);
     }
 
-    assert(entry->type == OIF_FLOAT64);
+    assert(entry->type == OIF_TYPE_F64);
     double double_value = *(double *)entry->value;
     return double_value;
 }
@@ -247,13 +249,13 @@ oif_config_dict_print(OIFConfigDict *dict)
     else {
         hashmap_foreach(key, entry, &dict->map)
         {
-            if (entry->type == OIF_INT) {
+            if (entry->type == OIF_TYPE_INT) {
                 printf("Key = '%s', value = '%d'\n", key, *(int *)entry->value);
             }
-            else if (entry->type == OIF_FLOAT64) {
+            else if (entry->type == OIF_TYPE_F64) {
                 printf("Key = '%s', value = '%f'\n", key, *(double *)entry->value);
             }
-            else if (entry->type == OIF_STR) {
+            else if (entry->type == OIF_TYPE_STRING) {
                 printf("Key = '%s', value = '%s'\n", key, (char *)entry->value);
             }
             else {
@@ -280,6 +282,18 @@ oif_config_dict_print(OIFConfigDict *dict)
 void
 oif_config_dict_serialize(OIFConfigDict *dict)
 {
+    if (dict == NULL) {
+        logerr(prefix_, "Serialization is possible only for non-NULL dict");
+        exit(1);
+    }
+
+    // Probably, not the best solution, as multiple invocation of serialization
+    // should be possible, but I just want to rectify a memory leak for now.
+    if (dict->pc != NULL) {
+        logerr(prefix_, "Serialization was already done");
+        exit(1);
+    }
+
     cw_pack_context *pc = oif_util_malloc(sizeof(*pc));
     if (pc == NULL) {
         fprintf(stderr,
@@ -307,14 +321,14 @@ oif_config_dict_serialize(OIFConfigDict *dict)
         {
             cw_pack_str(pc, key, oif_util_u32_from_size_t(strlen(key)));
 
-            if (entry->type == OIF_INT) {
+            if (entry->type == OIF_TYPE_INT) {
                 int64_t i64_value = *(int *)entry->value;
                 cw_pack_signed(pc, i64_value);
             }
-            else if (entry->type == OIF_FLOAT64) {
+            else if (entry->type == OIF_TYPE_F64) {
                 cw_pack_double(pc, *(double *)entry->value);
             }
-            else if (entry->type == OIF_STR) {
+            else if (entry->type == OIF_TYPE_STRING) {
                 cw_pack_str(pc, (char *)entry->value,
                             oif_util_u32_from_size_t(strlen(entry->value)));
             }
@@ -471,7 +485,8 @@ oif_config_dict_copy_serialization(OIFConfigDict *to, const OIFConfigDict *from)
     }
     memcpy(to->buffer, from->buffer, from->buffer_length);
     to->buffer_length = from->buffer_length;
-    to->buffer[to->buffer_length] = '\0';  // Ensure null-termination.
+    // We put nul-terminator to be able to print out the buffer as a string.
+    to->buffer[to->buffer_length] = '\0';
     return 0;
 }
 

{openinterfaces-0.6.2 → openinterfaces-0.7.0}/common/util.c

@@ -182,6 +182,41 @@ oif_util_str_contains(const char **arr, const char *s)
     return false;
 }
 
+char *
+oif_util_make_string(const char *fmt, ...)
+{
+    // Number of required bytes for the string *excluding* the null byte.
+    int nbytes_required = 0;
+    // Number of allocated bytes for the string *including* the null byte.
+    size_t str_length;
+
+    va_list args;
+
+    va_start(args, fmt);
+    // `snprintf` with an empty destination string provides
+    // the information about the required number of bytes.
+    nbytes_required = vsnprintf(NULL, 0, fmt, args);
+    va_end(args);
+    if (nbytes_required < 0) {
+        fprintf(stderr, "[oif_util] Could not make a string\n");
+        return NULL;
+    }
+
+    str_length = (size_t)nbytes_required + 1;
+    char *s = oif_util_malloc(str_length * sizeof(*s));
+
+    va_start(args, fmt);
+    int nbytes_written = vsnprintf(s, str_length, fmt, args);
+    va_end(args);
+    if (nbytes_written + 1 != str_length) {
+        fprintf(stderr, "[oif_util] Could not make a string\n");
+        oif_util_free(s);
+        return NULL;
+    }
+
+    return s;
+}
+
 int
 logwarn(const char *prefix, const char *fmt, ...)
 {

{openinterfaces-0.6.2 → openinterfaces-0.7.0}/dispatch/dispatch.c

@@ -103,13 +103,8 @@ load_interface_impl(const char *interface, const char *impl, size_t version_majo
     /* One must be a pessimist, while programming in C. */
     ImplHandle retval = OIF_IMPL_INIT_ERROR;
 
-    char conf_filename_fixed_part[512] = {'\0'};
-    strcat(conf_filename_fixed_part, interface);
-    strcat(conf_filename_fixed_part, "/");
-    strcat(conf_filename_fixed_part, impl);
-    strcat(conf_filename_fixed_part, "/");
-    strcat(conf_filename_fixed_part, impl);
-    strcat(conf_filename_fixed_part, ".conf");
+    char *conf_filename_fixed_part =
+        oif_util_make_string("%s/%s/%s.conf", interface, impl, impl);
 
     // We cannot tokenize OIF_IMPL_PATH because `strtok`
     // modifies the original string during tokenization
@@ -118,33 +113,29 @@ load_interface_impl(const char *interface, const char *impl, size_t version_majo
     // OIF_IMPL_PATH will not have the original value.
     char *oif_impl_path_dup = oif_util_str_duplicate(OIF_IMPL_PATH);
     char *path = strtok((char *)oif_impl_path_dup, ":");
-    char conf_filename[1024] = "";
-    char *conf_filename_p = conf_filename;
+    char *conf_filename = NULL;
     while (path) {
-        strcat(conf_filename_p, path);
-        strcat(conf_filename_p, "/");
-        strcat(conf_filename_p, conf_filename_fixed_part);
-
+        conf_filename = oif_util_make_string("%s/%s", path, conf_filename_fixed_part);
         conf_file = fopen(conf_filename, "re");
         if (conf_file != NULL) {
             break;
         }
+        oif_util_free(conf_filename);
         path = strtok(NULL, ":");
-        conf_filename_p = conf_filename;
-        conf_filename_p[0] = '\0';
     }
 
     if (conf_file == NULL) {
         logerr(prefix_,
                "Cannot open conf file '%s'\n"
-               "\tSearch was done in the following paths: %s\n",
-               conf_filename_fixed_part, oif_impl_path_dup);
+               "\tSearch was done in the following paths: '%s'\n",
+               conf_filename_fixed_part, OIF_IMPL_PATH);
         oif_util_free(oif_impl_path_dup);
         perror("Error message is: ");
         return -1;
     }
     else {
         fprintf(stderr, "[%s] Configuration file: %s\n", prefix_, conf_filename);
+        oif_util_free(conf_filename);
     }
     oif_util_free(oif_impl_path_dup);
 
@@ -262,6 +253,8 @@ cleanup:
         fclose(conf_file);
     }
 
+    oif_util_free(conf_filename_fixed_part);
+
     return retval;
 }
 
@@ -321,36 +314,44 @@ unload_interface_impl(ImplHandle implh)
 }
 
 int
-call_interface_impl(ImplHandle implh, const char *method, OIFArgs *in_args, OIFArgs *out_args)
+call_interface_impl(ImplHandle implh, const char *method, OIFArgs *in_args, OIFArgs *out_args,
+                    OIFArgs *return_args)
 {
     int status;
 
     ImplInfo *impl_info = hashmap_get(&IMPL_MAP, &implh);
+    if (impl_info == NULL) {
+        logerr(prefix_,
+               "Cannot find implementation with id '%d' in the list of loaded implementations",
+               implh);
+        return -1;
+    }
+
     DispatchHandle dh = impl_info->dh;
     if (OIF_DISPATCH_HANDLES[dh] == NULL) {
         logerr(prefix_,
                "Cannot call interface implementation "
                "for language '%s'\n",
                OIF_LANG_FROM_LANG_ID[dh]);
-        exit(EXIT_FAILURE);
+        return -2;
     }
-    void *lib_handle = OIF_DISPATCH_HANDLES[dh];
 
-    int (*call_impl_fn)(ImplInfo *, const char *, OIFArgs *, OIFArgs *);
+    void *lib_handle = OIF_DISPATCH_HANDLES[dh];
+    int (*call_impl_fn)(ImplInfo *, const char *, OIFArgs *, OIFArgs *, OIFArgs *);
     call_impl_fn = dlsym(lib_handle, "call_impl");
     if (call_impl_fn == NULL) {
         logerr(prefix_,
                "Could not load function 'call_impl' "
-               "for language '%s'\n",
+               "for language '%s'",
                OIF_LANG_FROM_LANG_ID[dh]);
-        return -1;
+        return -3;
     }
-    status = call_impl_fn(impl_info, method, in_args, out_args);
+    status = call_impl_fn(impl_info, method, in_args, out_args, return_args);
 
     if (status) {
         logerr(prefix_,
                "During execution of the function "
-               "'%s::%s' an error occurred\n",
+               "'%s::%s' an error occurred",
                impl_info->interface, method);
     }
     return status;

{openinterfaces-0.6.2 → openinterfaces-0.7.0}/include/oif/api.h

@@ -7,6 +7,11 @@ extern "C" {
 
 #include <stddef.h>
 #include <stdint.h>
+#include <sys/types.h>
+
+#include <oif/_platform.h>
+
+static_assert(sizeof(intptr_t) == sizeof(ssize_t), "We expect a 64-bit platform");
 
 // Handle to an instantiated implementation.
 typedef int ImplHandle;
@@ -21,15 +26,33 @@ enum {
 };
 
 typedef enum {
-    OIF_INT = 1,
-    // OIF_FLOAT32 = 2,
-    OIF_FLOAT64 = 3,
-    // OIF_FLOAT32_P = 4,
-    OIF_ARRAY_F64 = 5,
-    OIF_STR = 6,
-    OIF_CALLBACK = 7,
-    OIF_USER_DATA = 8,
-    OIF_CONFIG_DICT = 9,
+    OIF_TYPE_BOOL = 1,
+
+    OIF_TYPE_CHAR = 2,
+    OIF_TYPE_I8 = 2,
+    OIF_TYPE_UCHAR = 3,
+    OIF_TYPE_U8 = 3,
+
+    OIF_TYPE_I32 = 4,
+    OIF_TYPE_INT = 4,  // Use int as an alias to int32
+    OIF_TYPE_U32 = 5,
+    OIF_TYPE_UINT = 5,  // Use uint as an alias to uint32
+
+    OIF_TYPE_I64 = 6,
+    OIF_TYPE_U64 = 7,
+
+    OIF_TYPE_F32 = 8,
+    OIF_TYPE_F64 = 9,
+
+    OIF_TYPE_ARRAY_F32 = 10,
+    OIF_TYPE_ARRAY_F64 = 11,
+
+    OIF_TYPE_STRING = 12,
+    OIF_TYPE_CALLBACK = 13,
+    OIF_USER_DATA = 14,
+    OIF_TYPE_USER_DATA = 14,
+    OIF_TYPE_POINTER = 14,
+    OIF_TYPE_CONFIG_DICT = 15,
 } OIFArgType;
 
 enum {
@@ -57,7 +80,7 @@ typedef struct {
     // Number of dimensions in the array.
     int nd;
     // Size of each axis, i = 0, .., nd-1.
-    intptr_t *dimensions;
+    ssize_t *dimensions;
     // Pointer to actual data.
     double *data;
     // Flags that describe the array: things like row-major order, etc.
@@ -72,10 +95,13 @@ typedef struct {
 
 // This structure is used for callback functions.
 typedef struct {
-    int src;        // Language of the function (one of OIF_LANG_* constants)
-    void *fn_p_c;   // Function pointer in C
-    void *fn_p_jl;  // Function pointer in Julia
-    void *fn_p_py;  // Function pointer in Python
+    int src;             // Language of the function (one of OIF_LANG_* constants)
+    void *fn_p_c;        // Function pointer in C
+    void *fn_p_jl;       // Function pointer in Julia
+    void *fn_p_py;       // Function pointer in Python
+    unsigned int nargs;  // Number of arguments
+    OIFArgType *arg_types;
+    OIFArgType restype;
 } OIFCallback;
 
 /**

{openinterfaces-0.6.2 → openinterfaces-0.7.0}/include/oif/internal/bridge_api.h

@@ -30,7 +30,8 @@ ImplInfo *
 load_impl(const char *impl_details, size_t version_major, size_t version_minor);
 
 int
-call_impl(ImplInfo *impl_info, const char *method, OIFArgs *in_args, OIFArgs *out_args);
+call_impl(ImplInfo *impl_info, const char *method, OIFArgs *in_args, OIFArgs *out_args,
+          OIFArgs *return_args);
 
 int
 unload_impl(ImplInfo *impl_info);

{openinterfaces-0.6.2 → openinterfaces-0.7.0}/include/oif/internal/dispatch.h

@@ -39,11 +39,13 @@ unload_interface_impl(ImplHandle implh);
  * @param implh Implementat handle that identifies the implementation
  * @param method Name of the method (function) to invoke
  * @param in_args Array of input arguments
- * @param out_args Array of output arguments
+ * @param out_args Array of output (mutable) arguments
+ * @param return_args Array of return arguments
  * @return status code that signals about an error if non-zero
  */
 int
-call_interface_impl(ImplHandle implh, const char *method, OIFArgs *in_args, OIFArgs *out_args);
+call_interface_impl(ImplHandle implh, const char *method, OIFArgs *in_args, OIFArgs *out_args,
+                    OIFArgs *return_args);
 
 #ifdef __cplusplus
 }

{openinterfaces-0.6.2 → openinterfaces-0.7.0}/include/oif/util.h

@@ -80,6 +80,14 @@ oif_strcmp_nocase(const char *s1, const char *s2);
 bool
 oif_util_str_contains(const char **arr, const char *s);
 
+/**
+ * Make a string from given format and data and pass it to caller.
+ *
+ * @return Allocated string or NULL on failure
+ */
+char *
+oif_util_make_string(const char *fmt, ...);
+
 /**
  * Log a warning message to stderr.
  *

openinterfaces-0.7.0/lang_c/CMakeLists.txt

@@ -0,0 +1,2 @@
+add_subdirectory(oif)
+add_subdirectory(oif_impl)

openinterfaces-0.7.0/lang_c/oif/CMakeLists.txt

@@ -0,0 +1,12 @@
+# User-facing C library that allows to interact with Open Interfaces.
+add_library(
+  oif_c SHARED
+  c_bindings.c ${PROJECT_SOURCE_DIR}/lang_c/oif_interfaces/src/qeq.c
+  ${PROJECT_SOURCE_DIR}/lang_c/oif_interfaces/src/linsolve.c
+  ${PROJECT_SOURCE_DIR}/lang_c/oif_interfaces/src/ivp.c)
+target_include_directories(oif_c PUBLIC ${PROJECT_SOURCE_DIR}/include)
+target_include_directories(
+  oif_c PUBLIC ${PROJECT_SOURCE_DIR}/lang_c/oif_interfaces/include/)
+target_link_libraries(oif_c PUBLIC oif_common_data_structures)
+target_link_libraries(oif_c PUBLIC oif_common_util)
+target_link_libraries(oif_c PRIVATE oif_dispatch)

{openinterfaces-0.6.2 → openinterfaces-0.7.0}/lang_python/oif/_convert.c

@@ -80,15 +80,15 @@ python_types_from_oif_types(PyObject *py_args, PyObject *c_args, PyObject *arg_t
         PyObject *py_type = PyTuple_GET_ITEM(arg_types, i);
         long c_type = PyLong_AsLong(py_type);
         PyObject *py_cur_arg = PyTuple_GET_ITEM(c_args, i);
-        if (c_type == OIF_INT) {
+        if (c_type == OIF_TYPE_INT) {
             cur_arg = py_cur_arg;
         }
-        else if (c_type == OIF_FLOAT64) {
+        else if (c_type == OIF_TYPE_F64) {
             cur_arg = py_cur_arg;
         }
-        else if (c_type == OIF_ARRAY_F64) {
+        else if (c_type == OIF_TYPE_ARRAY_F64) {
             if (!PyObject_HasAttrString(py_cur_arg, "contents")) {
-                fprintf(stderr, "[_convert] Pass OIF_ARRAY_F64 is not ctypes object\n");
+                fprintf(stderr, "[_convert] Passed OIF_TYPE_ARRAY_F64 is not ctypes object\n");
                 exit(EXIT_FAILURE);
             }
 
@@ -162,13 +162,13 @@ c_wrapper_over_py_callable(void *py_fn, OIFArgs *args)
     for (size_t i = 0; i < num_args; ++i) {
         void *c_arg = args->arg_values[i];
         switch (args->arg_types[i]) {
-            case OIF_INT:
+            case OIF_TYPE_INT:
                 cur_arg = PyLong_FromLong(*(int *)c_arg);
                 break;
-            case OIF_FLOAT64:
+            case OIF_TYPE_F64:
                 cur_arg = PyFloat_FromDouble(*(double *)c_arg);
                 break;
-            case OIF_ARRAY_F64:
+            case OIF_TYPE_ARRAY_F64:
                 arr = *(OIFArrayF64 **)c_arg;
                 assert(arr->nd == 1);
                 cur_arg = PyArray_SimpleNewFromData(arr->nd, arr->dimensions, NPY_FLOAT64,

{openinterfaces-0.6.2 → openinterfaces-0.7.0}/lang_python/oif/openinterfaces/CMakeLists.txt

@@ -5,9 +5,7 @@ pkg_check_modules(FFI REQUIRED IMPORTED_TARGET libffi)
 
 add_library(oif_python_conversion MODULE _conversion.c)
 target_include_directories(
-  oif_python_conversion
-  PRIVATE ${CMAKE_SOURCE_DIR}/include
-  PRIVATE ${FFI_INCLUDE_DIRS})
+  oif_python_conversion PRIVATE ${CMAKE_SOURCE_DIR}/include ${FFI_INCLUDE_DIRS})
 target_link_libraries(oif_python_conversion PRIVATE Python::Python)
 target_link_libraries(oif_python_conversion PRIVATE Python::NumPy)
 target_link_libraries(oif_python_conversion PRIVATE PkgConfig::FFI)