Add an example of passing an array from C to Julia.

Project.toml

@@ -1,7 +1,7 @@
 name = "DynamicallyLoadedEmbedding"
 uuid = "bb81f446-86f5-47d0-8ffc-7ac2adc264fd"
 authors = ["Gunnar Farnebäck <gunnar.farneback@contextvision.se>"]
-version = "0.1.0"
+version = "0.1.1"
 
 [deps]
 

c/julia_cfunctions.c

@@ -11,5 +11,13 @@ int load_julia_cfunctions()
     if (!mutual_fibonacci)
         return 0;
 
+    add_element_number_int = get_cfunction_pointer("add_element_number_int");
+    if (!add_element_number_int)
+        return 0;
+
+    add_element_number_float = get_cfunction_pointer("add_element_number_float");
+    if (!add_element_number_float)
+        return 0;
+
     return 1;
 }

c/julia_cfunctions.h

@@ -6,6 +6,8 @@
  */
 double (*julia_sind)(double x);
 int (*mutual_fibonacci)(int n, int (*callback)(int n));
+void (*add_element_number_int)(int *x, int n);
+void (*add_element_number_float)(float *x, int n);
 
 /* Loads the function pointers above. */
 int load_julia_cfunctions(void);

c/main.c

@@ -63,6 +63,24 @@ int main(int argc, const char **argv)
 
     printf("fibonacci(10) = %d\n", fibonacci(10));
 
+    int xi[4] = {1, 1, 1, 0};
+    float xf[3] = {0.0, 0.5, 1.0};
+
+    add_element_number_int(xi, 4);
+    add_element_number_float(xf, 3);
+
+    printf("xi =");
+    for (int i = 0; i < 4; i++) {
+        printf(" %d", xi[i]);
+    }
+    printf("\n");
+
+    printf("xf =");
+    for (int i = 0; i < 3; i++) {
+        printf(" %3.1f", xf[i]);
+    }
+    printf("\n");
+
     /* Test that exceptions are handled gracefully. */
     julia_eval_string("function this_function_has_no_methods end; this_function_has_no_methods()", "Exception test: ");
     fflush(stdout);

src/julia_cfunctions.jl

@@ -12,3 +12,20 @@ function mutual_fibonacci(n::Cint, callback::Ptr{Cvoid})::Cint
 end
 
 const mutual_fibonacci_ptr = @cfunction(mutual_fibonacci, Cint, (Cint, Ptr{Cvoid}))
+
+# Example of receiving an array of data. This function adds 1 to the
+# first element, 2 to the second, and so on.
+function add_element_number(x::Ptr, n::Integer)
+    for i = 1:n
+        element = unsafe_load(x, i)
+        unsafe_store!(x, element + i, i)
+    end
+    return
+end
+
+# @cfunction can instantiate pointers to multiple specializations of
+# the function for different argument types.
+const add_element_number_int = @cfunction(add_element_number, Cvoid,
+                                          (Ptr{Cint}, Cint))
+const add_element_number_float = @cfunction(add_element_number, Cvoid,
+                                            (Ptr{Cfloat}, Cint))

test/runtests.jl

@@ -42,6 +42,8 @@ expected_stdout =
     Julia version $(version_string)
     0.5
     fibonacci(10) = 55
+    xi = 2 3 4 4
+    xf = 1.0 2.5 4.0
     """
 
 expected_stderr =