COMMON: cleanup array handling

Author: chrisws

src/common/blib.c

@@ -121,6 +121,62 @@ void cmd_packed_let() {
   }
 }
 
+unsigned get_dimensions(int32_t **lbound, int32_t **ubound) {
+  unsigned count = 0;
+  if (code_peek() == kwTYPE_LEVEL_BEGIN) {
+    code_skipnext();
+    while (code_peek() != kwTYPE_LEVEL_END && !prog_error) {
+      if (count == MAXDIM) {
+        err_matdim();
+        break;
+      }
+      var_t arg;
+      v_init(&arg);
+      eval(&arg);
+      if (prog_error) {
+        break;
+      }
+      int dim = v_getint(&arg);
+      v_free(&arg);
+
+      if (count) {
+        // allocate for extra dimension
+        *lbound = (int32_t *)realloc(*lbound, (sizeof(int32_t) * (count + 1)));
+        *ubound = (int32_t *)realloc(*ubound, (sizeof(int32_t) * (count + 1)));
+      } else {
+        // allocate for first dimension
+        *lbound = (int32_t *)malloc(sizeof(int32_t));
+        *ubound = (int32_t *)malloc(sizeof(int32_t));
+      }
+
+      if (code_peek() == kwTO) {
+        (*lbound)[count] = dim;
+        code_skipnext();
+        eval(&arg);
+        (*ubound)[count] = v_getint(&arg);
+        v_free(&arg);
+      } else {
+        (*lbound)[count] = opt_base;
+        (*ubound)[count] = dim;
+      }
+
+      count++;
+
+      // skip separator
+      if (code_peek() == kwTYPE_SEP) {
+        code_skipnext();
+        if (code_getnext() != ',') {
+          err_missing_comma();
+          break;
+        }
+      }
+    }
+    // skip end separator
+    code_skipnext();
+  }
+  return count;
+}
+
 /**
  *  DIM var([lower TO] uppper [, ...])
  */
@@ -131,95 +187,51 @@ void cmd_dim(int preserve) {
     byte code = code_peek();
     if (code == kwTYPE_LINE || code == kwTYPE_EOC) {
       exitf = 1;
-    } else {
-      var_t array;
-      array.v.a.maxdim = 0;
-      if (code_peek() == kwTYPE_SEP) {
-        code_skipnext();
-        if (code_getnext() != ',') {
-          err_missing_comma();
-        }
+      break;
+    }
+    if (code_peek() == kwTYPE_SEP) {
+      code_skipnext();
+      if (code_getnext() != ',') {
+        err_missing_comma();
+        return;
       }
+    }
 
-      var_t *var_p = code_getvarptr_parens(1);
-      byte zero_length = 1;
+    var_t *var_p = code_getvarptr_parens(1);
+    if (prog_error) {
+      break;
+    }
 
-      if (!prog_error) {
-        if (code_peek() == kwTYPE_LEVEL_BEGIN) {
-          code_skipnext();
-          while (code_peek() != kwTYPE_LEVEL_END) {
-            zero_length = 0;
-            var_t arg;
-            v_init(&arg);
-            eval(&arg);
-            if (prog_error) {
-              return;
-            }
-            if (code_peek() == kwTO) {
-              array.v.a.lbound[array.v.a.maxdim] = v_getint(&arg);
-              code_skipnext();
-              eval(&arg);
-              if (prog_error) {
-                return;
-              }
-              array.v.a.ubound[array.v.a.maxdim] = v_getint(&arg);
-            } else {
-              array.v.a.lbound[array.v.a.maxdim] = opt_base;
-              array.v.a.ubound[array.v.a.maxdim] = v_getint(&arg);
-            }
-            v_free(&arg);
-            array.v.a.maxdim++;
-
-            // skip separator
-            if (code_peek() == kwTYPE_SEP) {
-              code_skipnext();
-              if (code_getnext() != ',') {
-                err_missing_comma();
-              }
-            }
-          }
-          // skip end separator
-          code_skipnext();
-        } else {
-          zero_length = 1;
-        }
+    int32_t *lbound = NULL;
+    int32_t *ubound = NULL;
+    unsigned dimensions = get_dimensions(&lbound, &ubound);
+    if (!prog_error) {
+      if (!dimensions) {
+        v_toarray1(var_p, 0);
       } else {
-        rt_raise(ERR_SYNTAX);
-      }
-
-      //
-      // run...
-      //
-      if (!prog_error) {
-        if (zero_length) {
-          v_toarray1(var_p, 0);
+        int size = 1;
+        for (int i = 0; i < dimensions; i++) {
+          size = size * (ABS(ubound[i] - lbound[i]) + 1);
+        }
+        if (!preserve) {
+          v_new_array(var_p, size);
         } else {
-          int i;
-          int size = 1;
-          for (i = 0; i < array.v.a.maxdim; i++) {
-            size = size * (ABS(array.v.a.ubound[i] - array.v.a.lbound[i]) + 1);
-          }
-          if (!preserve) {
-            v_toarray1(var_p, size);
+          if (var_p->type == V_ARRAY) {
+            v_resize_array(var_p, size);
           } else {
-            if (var_p->type == V_ARRAY) {
-              v_resize_array(var_p, size);
-            } else {
-              v_toarray1(var_p, size);
-            }
-          }
-
-          // dim
-          var_p->v.a.maxdim = array.v.a.maxdim;
-          for (i = 0; i < array.v.a.maxdim; i++) {
-            var_p->v.a.lbound[i] = array.v.a.lbound[i];
-            var_p->v.a.ubound[i] = array.v.a.ubound[i];
+            v_new_array(var_p, size);
           }
         }
-      } else {
-        exitf = 1;
+        // dim
+        v_maxdim(var_p) = dimensions;
+        for (int i = 0; i < dimensions; i++) {
+          v_lbound(var_p, i) = lbound[i];
+          v_ubound(var_p, i) = ubound[i];
+        }
       }
     }
+    free(lbound);
+    free(ubound);
   } while (!exitf && !prog_error);
 }
 
@@ -328,7 +340,7 @@ void cmd_lins() {
   if (prog_error) {
     return;
   }
-  idx -= var_p->v.a.lbound[0];
+  idx -= v_lbound(var_p, 0);
 
   par_getcomma();
   if (prog_error) {
@@ -412,7 +424,7 @@ void cmd_ldel() {
   if (prog_error) {
     return;
   }
-  idx -= var_p->v.a.lbound[0];
+  idx -= v_lbound(var_p, 0);
   if ((idx >= size) || (idx < 0)) {
     err_out_of_range();
     return;
@@ -2520,7 +2532,7 @@ void cmd_sort() {
   if (!errf) {
     if (v_asize(var_p) > 1) {
       static_qsort_last_use_ip = use_ip;
-      qsort(var_p->v.a.data, v_asize(var_p), sizeof(var_t), qs_cmp);
+      qsort(v_data(var_p), v_asize(var_p), sizeof(var_t), qs_cmp);
     }
   }
   // NO RTE anymore... there is no meaning on this because of empty
@@ -2585,12 +2597,12 @@ void cmd_search() {
   }
   // search
   if (!errf) {
-    rv_p->v.i = var_p->v.a.lbound[0] - 1;
+    rv_p->v.i = v_lbound(var_p, 0) - 1;
     for (int i = 0; i < v_asize(var_p); i++) {
       var_t *elem_p = v_elem(var_p, i);
       int bcmp = sb_qcmp(elem_p, &vkey, use_ip);
       if (bcmp == 0) {
-        rv_p->v.i = i + var_p->v.a.lbound[0];
+        rv_p->v.i = i + v_lbound(var_p, 0);
         break;
       }
     }

src/common/blib_db.c

@@ -149,18 +149,18 @@ void write_encoded_var(int handle, var_t *var) {
     dev_fwrite(handle, (byte *)var->v.p.ptr, fv.size);
     break;
   case V_ARRAY:
-    fv.size = var->v.a.size;
+    fv.size = v_asize(var);
     dev_fwrite(handle, (byte *)&fv, sizeof(struct file_encoded_var));
 
     // write additional data about array
-    dev_fwrite(handle, &var->v.a.maxdim, 1);
-    for (int i = 0; i < var->v.a.maxdim; i++) {
-      dev_fwrite(handle, (byte *)&var->v.a.lbound[i], sizeof(int));
-      dev_fwrite(handle, (byte *)&var->v.a.ubound[i], sizeof(int));
+    dev_fwrite(handle, &v_maxdim(var), 1);
+    for (int i = 0; i < v_maxdim(var); i++) {
+      dev_fwrite(handle, (byte *)&v_lbound(var, i), sizeof(int));
+      dev_fwrite(handle, (byte *)&v_ubound(var, i), sizeof(int));
     }
 
     // write elements
-    for (int i = 0; i < var->v.a.size; i++) {
+    for (int i = 0; i < v_asize(var); i++) {
       var_t *elem = v_elem(var, i);
       write_encoded_var(handle, elem);
     }
@@ -200,14 +200,14 @@ int read_encoded_var(int handle, var_t *var) {
     v_new_array(var, fv.size);
 
     // read additional data about array
-    dev_fread(handle, (byte *)&var->v.a.maxdim, 1);
-    for (int i = 0; i < var->v.a.maxdim; i++) {
-      dev_fread(handle, (byte *)&var->v.a.lbound[i], sizeof(int));
-      dev_fread(handle, (byte *)&var->v.a.ubound[i], sizeof(int));
+    dev_fread(handle, (byte *)&v_maxdim(var), 1);
+    for (int i = 0; i < v_maxdim(var); i++) {
+      dev_fread(handle, (byte *)&v_lbound(var, i), sizeof(int));
+      dev_fread(handle, (byte *)&v_ubound(var, i), sizeof(int));
     }
 
     // write elements
-    for (int i = 0; i < var->v.a.size; i++) {
+    for (int i = 0; i < v_asize(var); i++) {
       var_t *elem = v_elem(var, i);
       v_init(elem);
       read_encoded_var(handle, elem);
@@ -711,7 +711,7 @@ void cmd_fsaveln() {
 
   if (var_p->type == V_ARRAY) {
     // parameter is an array
-    for (int i = 0; i < array_p->v.a.size; i++) {
+    for (int i = 0; i < v_asize(array_p); i++) {
       var_p = v_elem(array_p, i);
       fprint_var(handle, var_p);
       dev_fwrite(handle, (byte *)"\n", 1);

src/common/blib_func.c

@@ -1873,10 +1873,10 @@ void cmd_intN(long funcCode, var_t *r) {
 
         if (!prog_error) {
           l--;
-          if (l >= 0 && l < var_p->v.a.maxdim) {
-            r->v.i = var_p->v.a.lbound[l];
+          if (l >= 0 && l < v_maxdim(var_p)) {
+            r->v.i = v_lbound(var_p, l);
           } else {
-            rt_raise(ERR_BOUND_DIM, var_p->v.a.maxdim, l);
+            rt_raise(ERR_BOUND_DIM, v_maxdim(var_p), l);
           }
         }
       } else {
@@ -1909,10 +1909,10 @@ void cmd_intN(long funcCode, var_t *r) {
 
         if (!prog_error) {
           l--;
-          if (l >= 0 && l < var_p->v.a.maxdim) {
-            r->v.i = var_p->v.a.ubound[l];
+          if (l >= 0 && l < v_maxdim(var_p)) {
+            r->v.i = v_ubound(var_p, l);
           } else {
-            rt_raise(ERR_BOUND_DIM, var_p->v.a.maxdim);
+            rt_raise(ERR_BOUND_DIM, v_maxdim(var_p));
           }
         }
       } else {

src/common/blib_graph.c

@@ -1194,7 +1194,7 @@ void cmd_chart() {
   var_p = par_getvarray();
   if (prog_error)
     return;
-  count = var_p->v.a.size;
+  count = v_asize(var_p);
 
   // optional labels-flag
   if (code_peek() == kwTYPE_SEP) {
@@ -1274,7 +1274,7 @@ var_t *par_getm3() {
   if (prog_error) {
     return NULL;
   }
-  if (vp == NULL || vp->type != V_ARRAY || vp->v.a.size != 9) {
+  if (vp == NULL || vp->type != V_ARRAY || v_asize(vp) != 9) {
     err_typemismatch();
     return NULL;
   }
@@ -1486,7 +1486,7 @@ void cmd_m3apply() {
   p = par_getvarray();
   if (prog_error)
     return;
-  count = p->v.a.size;
+  count = v_asize(p);
 
   // copy m to om
   for (i = 0; i < 3; i++) {
@@ -1501,7 +1501,7 @@ void cmd_m3apply() {
   if (e->type != V_ARRAY) {
     int o;
 
-    count = (p->v.a.size >> 1);
+    count = (v_asize(p) >> 1);
     for (i = 0; i < count; i++) {
       o = i << 1;
       x = v_getreal(v_elem(p, o));
@@ -1515,7 +1515,7 @@ void cmd_m3apply() {
 
       if (e->type != V_ARRAY)
         err_parsepoly(i, 10);
-      else if ((e->v.a.size % 2) != 0)
+      else if ((v_asize(e) % 2) != 0)
         err_parsepoly(i, 11);
 
       if (prog_error)

src/common/brun.c

@@ -366,9 +366,9 @@ void cmd_chain(void) {
       code = strdup(var.v.p.ptr);
     }
   } else if (var.type == V_ARRAY) {
-    int el;
     int len = 0;
-    for (el = 0; el < var.v.a.size; el++) {
+    uint32_t size = v_asize(&var);
+    for (int el = 0; el < size; el++) {
       var_t *el_p = v_elem(&var, el);
       if (el_p->type == V_STR) {
         int str_len = strlen(el_p->v.p.ptr) + 2;