Handle indexed assignment of string arrays

Synchronize the indexed assignment function for string arrays to match
the other types. Also refactored the code shared by indexed assignment
and allocation functions. This fixes ticket:4705.

Belonging to [master]:
  - #2102

Author: sjoelund

SimulationRuntime/c/util/base_array.c

@@ -375,3 +375,67 @@ void clone_reverse_base_array_spec(const base_array_t* source, base_array_t* des
         dest->dim_size[i] = source->dim_size[dest->ndims - 1 - i];
     }
 }
+
+void index_alloc_base_array_size(const real_array_t * source,
+                                 const index_spec_t* source_spec,
+                                 base_array_t* dest)
+{
+    int i;
+    int j;
+
+    omc_assert_macro(base_array_ok(source));
+    omc_assert_macro(index_spec_ok(source_spec));
+    omc_assert_macro(index_spec_fit_base_array(source_spec, source));
+
+    for(i = 0, j = 0; i < source_spec->ndims; ++i) {
+         if(source_spec->dim_size[i] != 0) { /* is 'W' or 'A' */
+           ++j;
+         }
+    }
+    dest->ndims = j;
+    dest->dim_size = size_alloc(dest->ndims);
+
+    for(i = 0, j = 0; i < source_spec->ndims; ++i) {
+        if(source_spec->dim_size[i] != 0) { /* is 'W' or 'A' */
+            if(source_spec->index[i] != NULL) { /* is 'A' */
+                dest->dim_size[j] = source_spec->dim_size[i];
+            } else { /* is 'W' */
+                dest->dim_size[j] = source->dim_size[i];
+            }
+
+            ++j;
+        }
+    }
+}
+
+void indexed_assign_base_array_size_alloc(const base_array_t *source, base_array_t *dest, const index_spec_t *dest_spec, _index_t** _idx_vec1, _index_t** _idx_size)
+{
+    _index_t* idx_vec1;
+    _index_t* idx_size;
+    int i, j;
+    omc_assert_macro(base_array_ok(source));
+    omc_assert_macro(base_array_ok(dest));
+    omc_assert_macro(index_spec_ok(dest_spec));
+    omc_assert_macro(index_spec_fit_base_array(dest_spec, dest));
+    for(i = 0,j = 0; i < dest_spec->ndims; ++i) {
+        if(dest_spec->dim_size[i] != 0) {
+            ++j;
+        }
+    }
+    omc_assert_macro(j == source->ndims);
+
+    idx_vec1 = size_alloc(dest->ndims);
+    idx_size = size_alloc(dest_spec->ndims);
+
+    for(i = 0; i < dest_spec->ndims; ++i) {
+        idx_vec1[i] = 0;
+
+        if(dest_spec->index[i] != NULL) { /* is 'S' or 'A' */
+            idx_size[i] = imax(dest_spec->dim_size[i],1);
+        } else { /* is 'W' */
+            idx_size[i] = dest->dim_size[i];
+        }
+    }
+    *_idx_vec1 = idx_vec1;
+    *_idx_size = idx_size;
+}

SimulationRuntime/c/util/base_array.h

@@ -104,4 +104,9 @@ size_t calc_base_index_dims_subs(int ndims,...);
 
 int index_spec_fit_base_array(const index_spec_t *s, const base_array_t *a);
 
+/* Helper function for index_alloc_TYPE_array; allocates the ndims and dim_size */
+void index_alloc_base_array_size(const base_array_t * source, const index_spec_t* source_spec, base_array_t* dest);
+/* Helper function for indexed_assign_TYPE_array; allocates the ndims and dim_size */
+void indexed_assign_base_array_size_alloc(const base_array_t *source, base_array_t *dest, const index_spec_t *dest_spec, _index_t** _idx_vec1, _index_t** _idx_size);
+
 #endif /* BASE_ARRAY_H_ */

SimulationRuntime/c/util/boolean_array.c

@@ -31,6 +31,7 @@
 
 #include "boolean_array.h"
 #include "gc/omc_gc.h"
+#include "omc_error.h"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -306,44 +307,20 @@ void simple_indexed_assign_boolean_array2(const boolean_array_t* source,
 void indexed_assign_boolean_array(const boolean_array_t source, boolean_array_t* dest,
                                   const index_spec_t* dest_spec)
 {
-    _index_t* idx_vec1;
-    _index_t* idx_size;
-    int i,j;
-
-    assert(base_array_ok(&source));
-    assert(base_array_ok(dest));
-    assert(index_spec_ok(dest_spec));
-    assert(index_spec_fit_base_array(dest_spec, dest));
-    for(i = 0,j = 0; i < dest_spec->ndims; ++i) {
-        if(dest_spec->dim_size[i] != 0) {
-            ++j;
-        }
-    }
-    assert(j == source.ndims);
-
-    idx_vec1 = size_alloc(dest->ndims);
-    idx_size = size_alloc(dest_spec->ndims);
-
-    for(i = 0; i < dest_spec->ndims; ++i) {
-        idx_vec1[i] = 0;
-
-        if(dest_spec->index[i] != NULL) { /* is 'S' or 'A' */
-            idx_size[i] = imax(dest_spec->dim_size[i],1);
-        } else { /* is 'W' */
-            idx_size[i] = dest->dim_size[i];
-        }
-    }
+    _index_t* idx_vec1, idx_size;
+    int j;
+    indexed_assign_base_array_size_alloc(&source, dest, dest_spec, &idx_vec1, &idx_size);
 
     j = 0;
     do {
         boolean_set(dest,
-                    calc_base_index_spec(dest->ndims, idx_vec1, dest, dest_spec),
-                    boolean_get(source, j));
+                 calc_base_index_spec(dest->ndims, idx_vec1, dest, dest_spec),
+                 boolean_get(source, j));
         j++;
 
     } while(0 == next_index(dest_spec->ndims, idx_vec1, idx_size));
 
-    assert(j == base_array_nr_of_elements(source));
+    omc_assert_macro(j == base_array_nr_of_elements(source));
 }
 
 /*
@@ -428,33 +405,7 @@ void index_alloc_boolean_array(const boolean_array_t* source,
                                const index_spec_t* source_spec,
                                boolean_array_t* dest)
 {
-    int i;
-    int j;
-
-    assert(base_array_ok(source));
-    assert(index_spec_ok(source_spec));
-    assert(index_spec_fit_base_array(source_spec, source));
-
-    for(i = 0, j = 0; i < source_spec->ndims; ++i) {
-         if(source_spec->dim_size[i] != 0) { /* is 'W' or 'A' */
-           ++j;
-         }
-    }
-    dest->ndims = j;
-    dest->dim_size = size_alloc(dest->ndims);
-
-    for(i = 0, j = 0; i < source_spec->ndims; ++i) {
-        if(source_spec->dim_size[i] != 0) { /* is 'W' or 'A' */
-            if(source_spec->index[i] != NULL) { /* is 'A' */
-                dest->dim_size[j] = source_spec->dim_size[i];
-            } else { /* is 'W' */
-                dest->dim_size[j] = source->dim_size[i];
-            }
-
-            ++j;
-        }
-    }
-
+    index_alloc_base_array_size(source, source_spec, dest);
     alloc_boolean_array_data(dest);
     index_boolean_array(source, source_spec, dest);
 }

SimulationRuntime/c/util/integer_array.c

@@ -302,33 +302,9 @@ void simple_indexed_assign_integer_array2(const integer_array_t * source,
 void indexed_assign_integer_array(const integer_array_t source, integer_array_t* dest,
                                   const index_spec_t* dest_spec)
 {
-    _index_t* idx_vec1;
-    _index_t* idx_size;
-    int i,j;
-
-    omc_assert_macro(base_array_ok(&source));
-    omc_assert_macro(base_array_ok(dest));
-    omc_assert_macro(index_spec_ok(dest_spec));
-    omc_assert_macro(index_spec_fit_base_array(dest_spec, dest));
-    for(i = 0,j = 0; i < dest_spec->ndims; ++i) {
-        if(dest_spec->dim_size[i] != 0) {
-            ++j;
-        }
-    }
-    omc_assert_macro(j == source.ndims);
-
-    idx_vec1 = size_alloc(dest->ndims);
-    idx_size = size_alloc(dest_spec->ndims);
-
-    for(i = 0; i < dest_spec->ndims; ++i) {
-        idx_vec1[i] = 0;
-
-        if(dest_spec->index[i] != NULL) { /* is 'S' or 'A' */
-            idx_size[i] = imax(dest_spec->dim_size[i],1);
-        } else { /* is 'W' */
-            idx_size[i] = dest->dim_size[i];
-        }
-    }
+    _index_t* idx_vec1, idx_size;
+    int j;
+    indexed_assign_base_array_size_alloc(&source, dest, dest_spec, &idx_vec1, &idx_size);
 
     j = 0;
     do {
@@ -424,34 +400,7 @@ void index_alloc_integer_array(const integer_array_t * source,
              const index_spec_t* source_spec,
              integer_array_t* dest)
 {
-    int i;
-    int j;
-
-    omc_assert_macro(base_array_ok(source));
-    omc_assert_macro(index_spec_ok(source_spec));
-    omc_assert_macro(index_spec_fit_base_array(source_spec,source));
-
-
-    for(i = 0, j = 0; i < source_spec->ndims; ++i) {
-         if(source_spec->dim_size[i] != 0) { /* is 'W' or 'A' */
-           ++j;
-         }
-    }
-    dest->ndims = j;
-    dest->dim_size = size_alloc(dest->ndims);
-
-    for(i = 0, j = 0; i < source_spec->ndims; ++i) {
-        if(source_spec->dim_size[i] != 0) { /* is 'W' or 'A' */
-            if(source_spec->index[i] != NULL) { /* is 'A' */
-                dest->dim_size[j] = source_spec->dim_size[i];
-            } else { /* is 'W' */
-                dest->dim_size[j] = source->dim_size[i];
-            }
-
-            ++j;
-        }
-    }
-
+    index_alloc_base_array_size(source, source_spec, dest);
     alloc_integer_array_data(dest);
     index_integer_array(source, source_spec, dest);
 }

SimulationRuntime/c/util/real_array.c

@@ -279,33 +279,9 @@ void simple_indexed_assign_real_array2(const real_array_t * source,
 void indexed_assign_real_array(const real_array_t source, real_array_t* dest,
                                const index_spec_t* dest_spec)
 {
-    _index_t* idx_vec1;
-    _index_t* idx_size;
-    int i,j;
-
-    omc_assert_macro(base_array_ok(&source));
-    omc_assert_macro(base_array_ok(dest));
-    omc_assert_macro(index_spec_ok(dest_spec));
-    omc_assert_macro(index_spec_fit_base_array(dest_spec, dest));
-    for(i = 0,j = 0; i < dest_spec->ndims; ++i) {
-        if(dest_spec->dim_size[i] != 0) {
-            ++j;
-        }
-    }
-    omc_assert_macro(j == source.ndims);
-
-    idx_vec1 = size_alloc(dest->ndims);
-    idx_size = size_alloc(dest_spec->ndims);
-
-    for(i = 0; i < dest_spec->ndims; ++i) {
-        idx_vec1[i] = 0;
-
-        if(dest_spec->index[i] != NULL) { /* is 'S' or 'A' */
-            idx_size[i] = imax(dest_spec->dim_size[i],1);
-        } else { /* is 'W' */
-            idx_size[i] = dest->dim_size[i];
-        }
-    }
+    _index_t* idx_vec1, idx_size;
+    int j;
+    indexed_assign_base_array_size_alloc(&source, dest, dest_spec, &idx_vec1, &idx_size);
 
     j = 0;
     do {
@@ -413,33 +389,7 @@ void index_alloc_real_array(const real_array_t * source,
                             const index_spec_t* source_spec,
                             real_array_t* dest)
 {
-    int i;
-    int j;
-
-    omc_assert_macro(base_array_ok(source));
-    omc_assert_macro(index_spec_ok(source_spec));
-    omc_assert_macro(index_spec_fit_base_array(source_spec, source));
-
-    for(i = 0, j = 0; i < source_spec->ndims; ++i) {
-         if(source_spec->dim_size[i] != 0) { /* is 'W' or 'A' */
-           ++j;
-         }
-    }
-    dest->ndims = j;
-    dest->dim_size = size_alloc(dest->ndims);
-
-    for(i = 0, j = 0; i < source_spec->ndims; ++i) {
-        if(source_spec->dim_size[i] != 0) { /* is 'W' or 'A' */
-            if(source_spec->index[i] != NULL) { /* is 'A' */
-                dest->dim_size[j] = source_spec->dim_size[i];
-            } else { /* is 'W' */
-                dest->dim_size[j] = source->dim_size[i];
-            }
-
-            ++j;
-        }
-    }
-
+    index_alloc_base_array_size(source, source_spec, dest);
     alloc_real_array_data(dest);
     index_real_array(source, source_spec, dest);
 }