Rename var_array2 to stack.

diff --git a/src/language/stats/ctables.c b/src/language/stats/ctables.c
index d5982a8c1e404d90f71821a189fbd25639d60434..ba2ac71c093f9a81e562c8672f1867d662d53acb 100644 (file)
--- a/src/language/stats/ctables.c
+++ b/src/language/stats/ctables.c
@@ -185,7 +185,7 @@ struct ctables_cell
 
     struct
       {
-        size_t vaa_idx;
+        size_t stack_idx;
         struct ctables_cell_value
           {
             const struct ctables_category *category;
@@ -300,7 +300,8 @@ struct var_array
     struct ctables_summary_spec_set total_sss;
   };
 
-struct var_array2
+/* A stack of nestings, e.g. this represents (...) + (...) + ... + (...). */
+struct ctables_stack
   {
     struct var_array *vas;
     size_t n;
@@ -309,7 +310,7 @@ struct var_array2
 struct ctables_table
   {
     struct ctables_axis *axes[PIVOT_N_AXES];
-    struct var_array2 vaas[PIVOT_N_AXES];
+    struct ctables_stack stacks[PIVOT_N_AXES];
     enum pivot_axis_type summary_axis;
     struct hmap cells;
     struct hmap domains[N_CTDTS];
@@ -1443,25 +1444,25 @@ var_array_uninit (struct var_array *va)
 }
 
 static void
-var_array2_uninit (struct var_array2 *vaa)
+ctables_stack_uninit (struct ctables_stack *stack)
 {
-  if (vaa)
+  if (stack)
     {
-      for (size_t i = 0; i < vaa->n; i++)
-        var_array_uninit (&vaa->vas[i]);
-      free (vaa->vas);
+      for (size_t i = 0; i < stack->n; i++)
+        var_array_uninit (&stack->vas[i]);
+      free (stack->vas);
     }
 }
 
-static struct var_array2
-nest_fts (struct var_array2 va0, struct var_array2 va1)
+static struct ctables_stack
+nest_fts (struct ctables_stack va0, struct ctables_stack va1)
 {
   if (!va0.n)
     return va1;
   else if (!va1.n)
     return va0;
 
-  struct var_array2 vaa = { .vas = xnmalloc (va0.n, va1.n * sizeof *vaa.vas) };
+  struct ctables_stack stack = { .vas = xnmalloc (va0.n, va1.n * sizeof *stack.vas) };
   for (size_t i = 0; i < va0.n; i++)
     for (size_t j = 0; j < va1.n; j++)
       {
@@ -1485,7 +1486,7 @@ nest_fts (struct var_array2 va0, struct var_array2 va1)
           summary_src = a;
         else
           NOT_REACHED ();
-        vaa.vas[vaa.n++] = (struct var_array) {
+        stack.vas[stack.n++] = (struct var_array) {
           .vars = vars,
           .scale_idx = (a->scale_idx != SIZE_MAX ? a->scale_idx
                         : b->scale_idx != SIZE_MAX ? a->n + b->scale_idx
@@ -1495,30 +1496,30 @@ nest_fts (struct var_array2 va0, struct var_array2 va1)
           .total_sss = summary_src->total_sss,
         };
       }
-  var_array2_uninit (&va0);
-  var_array2_uninit (&va1);
-  return vaa;
+  ctables_stack_uninit (&va0);
+  ctables_stack_uninit (&va1);
+  return stack;
 }
 
-static struct var_array2
-stack_fts (struct var_array2 va0, struct var_array2 va1)
+static struct ctables_stack
+stack_fts (struct ctables_stack s0, struct ctables_stack s1)
 {
-  struct var_array2 vaa = { .vas = xnmalloc (va0.n + va1.n, sizeof *vaa.vas) };
-  for (size_t i = 0; i < va0.n; i++)
-    vaa.vas[vaa.n++] = va0.vas[i];
-  for (size_t i = 0; i < va1.n; i++)
-    vaa.vas[vaa.n++] = va1.vas[i];
-  assert (vaa.n == va0.n + va1.n);
-  free (va0.vas);
-  free (va1.vas);
-  return vaa;
+  struct ctables_stack stack = { .vas = xnmalloc (s0.n + s1.n, sizeof *stack.vas) };
+  for (size_t i = 0; i < s0.n; i++)
+    stack.vas[stack.n++] = s0.vas[i];
+  for (size_t i = 0; i < s1.n; i++)
+    stack.vas[stack.n++] = s1.vas[i];
+  assert (stack.n == s0.n + s1.n);
+  free (s0.vas);
+  free (s1.vas);
+  return stack;
 }
 
-static struct var_array2
+static struct ctables_stack
 enumerate_fts (enum pivot_axis_type axis_type, const struct ctables_axis *a)
 {
   if (!a)
-    return (struct var_array2) { .n = 0 };
+    return (struct ctables_stack) { .n = 0 };
 
   switch (a->op)
     {
@@ -1541,7 +1542,7 @@ enumerate_fts (enum pivot_axis_type axis_type, const struct ctables_axis *a)
           va->cell_sss.var = a->var.var;
           va->total_sss.var = a->var.var;
         }
-      return (struct var_array2) { .vas = va, .n = 1 };
+      return (struct ctables_stack) { .vas = va, .n = 1 };
 
     case CTAO_STACK:
       return stack_fts (enumerate_fts (axis_type, a->subs[0]),
@@ -2012,12 +2013,12 @@ ctables_cell_compare_3way (const void *a_, const void *b_, const void *aux_)
   const struct ctables_cell *a = *ap;
   const struct ctables_cell *b = *bp;
 
-  size_t a_idx = a->axes[aux->a].vaa_idx;
-  size_t b_idx = b->axes[aux->a].vaa_idx;
+  size_t a_idx = a->axes[aux->a].stack_idx;
+  size_t b_idx = b->axes[aux->a].stack_idx;
   if (a_idx != b_idx)
     return a_idx < b_idx ? -1 : 1;
 
-  const struct var_array *va = &aux->t->vaas[aux->a].vas[a_idx];
+  const struct var_array *va = &aux->t->stacks[aux->a].vas[a_idx];
   for (size_t i = 0; i < va->n; i++)
     if (i != va->scale_idx)
       {
@@ -2102,8 +2103,8 @@ ctables_domain_insert (struct ctables_table *t, struct ctables_cell *cell,
   size_t hash = 0;
   for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
     {
-      size_t idx = cell->axes[a].vaa_idx;
-      const struct var_array *va = &t->vaas[a].vas[idx];
+      size_t idx = cell->axes[a].stack_idx;
+      const struct var_array *va = &t->stacks[a].vas[idx];
       hash = hash_int (idx, hash);
       for (size_t i = 0; i < va->n_domains[domain]; i++)
         {
@@ -2119,11 +2120,11 @@ ctables_domain_insert (struct ctables_table *t, struct ctables_cell *cell,
       const struct ctables_cell *df = d->example;
       for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
         {
-          size_t idx = cell->axes[a].vaa_idx;
-          if (idx != df->axes[a].vaa_idx)
+          size_t idx = cell->axes[a].stack_idx;
+          if (idx != df->axes[a].stack_idx)
             goto not_equal;
 
-          const struct var_array *va = &t->vaas[a].vas[idx];
+          const struct var_array *va = &t->stacks[a].vas[idx];
           for (size_t i = 0; i < va->n_domains[domain]; i++)
             {
               size_t v_idx = va->domains[domain][i];
@@ -2210,13 +2211,13 @@ ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c,
                        const struct ctables_category *cats[PIVOT_N_AXES][10],
                        double weight)
 {
-  const struct var_array *ss = &t->vaas[t->summary_axis].vas[ix[t->summary_axis]];
+  const struct var_array *ss = &t->stacks[t->summary_axis].vas[ix[t->summary_axis]];
 
   size_t hash = 0;
   bool total = false;
   for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
     {
-      const struct var_array *va = &t->vaas[a].vas[ix[a]];
+      const struct var_array *va = &t->stacks[a].vas[ix[a]];
       hash = hash_int (ix[a], hash);
       for (size_t i = 0; i < va->n; i++)
         if (i != va->scale_idx)
@@ -2237,8 +2238,8 @@ ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c,
     {
       for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
         {
-          const struct var_array *va = &t->vaas[a].vas[ix[a]];
-          if (cell->axes[a].vaa_idx != ix[a])
+          const struct var_array *va = &t->stacks[a].vas[ix[a]];
+          if (cell->axes[a].stack_idx != ix[a])
             goto not_equal;
           for (size_t i = 0; i < va->n; i++)
             if (i != va->scale_idx
@@ -2262,8 +2263,8 @@ ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c,
   cell->total = total;
   for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
     {
-      const struct var_array *va = &t->vaas[a].vas[ix[a]];
-      cell->axes[a].vaa_idx = ix[a];
+      const struct var_array *va = &t->stacks[a].vas[ix[a]];
+      cell->axes[a].stack_idx = ix[a];
       cell->axes[a].cvs = (va->n
                         ? xnmalloc (va->n, sizeof *cell->axes[a].cvs)
                         : NULL);
@@ -2312,7 +2313,7 @@ recurse_totals (struct ctables_table *t, const struct ccase *c,
 {
   for (enum pivot_axis_type a = start_a; a < PIVOT_N_AXES; a++)
     {
-      const struct var_array *va = &t->vaas[a].vas[ix[a]];
+      const struct var_array *va = &t->stacks[a].vas[ix[a]];
       for (size_t i = start_va; i < va->n; i++)
         {
           if (i == va->scale_idx)
@@ -2350,7 +2351,7 @@ ctables_cell_insert (struct ctables_table *t,
   const struct ctables_category *cats[PIVOT_N_AXES][10];
   for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
     {
-      const struct var_array *va = &t->vaas[a].vas[ix[a]];
+      const struct var_array *va = &t->stacks[a].vas[ix[a]];
       for (size_t i = 0; i < va->n; i++)
         {
           if (i == va->scale_idx)
@@ -2375,7 +2376,7 @@ ctables_cell_insert (struct ctables_table *t,
 
   for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
     {
-      const struct var_array *va = &t->vaas[a].vas[ix[a]];
+      const struct var_array *va = &t->stacks[a].vas[ix[a]];
       for (size_t i = 0; i < va->n; i++)
         {
           if (i == va->scale_idx)
@@ -2401,11 +2402,11 @@ ctables_execute (struct dataset *ds, struct ctables *ct)
       for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
         if (t->axes[a])
           {
-            t->vaas[a] = enumerate_fts (a, t->axes[a]);
+            t->stacks[a] = enumerate_fts (a, t->axes[a]);
 
-            for (size_t j = 0; j < t->vaas[a].n; j++)
+            for (size_t j = 0; j < t->stacks[a].n; j++)
               {
-                struct var_array *va = &t->vaas[a].vas[j];
+                struct var_array *va = &t->stacks[a].vas[j];
                 for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++)
                   {
                     va->domains[dt] = xmalloc (va->n * sizeof *va->domains[dt]);
@@ -2460,29 +2461,29 @@ ctables_execute (struct dataset *ds, struct ctables *ct)
           {
             struct var_array *va = xmalloc (sizeof *va);
             *va = (struct var_array) { .n = 0 };
-            t->vaas[a] = (struct var_array2) { .vas = va, .n = 1 };
+            t->stacks[a] = (struct ctables_stack) { .vas = va, .n = 1 };
           }
 
-      for (size_t i = 0; i < t->vaas[t->summary_axis].n; i++)
+      for (size_t i = 0; i < t->stacks[t->summary_axis].n; i++)
         {
-          struct var_array *va = &t->vaas[t->summary_axis].vas[i];
+          struct var_array *va = &t->stacks[t->summary_axis].vas[i];
           if (!va->cell_sss.n)
             {
-              struct ctables_summary_spec_set *css = &va->cell_sss;
-              css->summaries = xmalloc (sizeof *css->summaries);
-              css->n = 1;
+              struct ctables_summary_spec_set *sss = &va->cell_sss;
+              sss->summaries = xmalloc (sizeof *sss->summaries);
+              sss->n = 1;
 
               enum ctables_summary_function function
-                = css->var ? CTSF_MEAN : CTSF_COUNT;
-              struct ctables_var var = { .is_mrset = false, .var = css->var };
+                = sss->var ? CTSF_MEAN : CTSF_COUNT;
+              struct ctables_var var = { .is_mrset = false, .var = sss->var };
 
-              *css->summaries = (struct ctables_summary_spec) {
+              *sss->summaries = (struct ctables_summary_spec) {
                 .function = function,
                 .format = ctables_summary_default_format (function, &var),
                 .label = ctables_summary_default_label (function, 0),
               };
-              if (!css->var)
-                css->var = va->vars[0];
+              if (!sss->var)
+                sss->var = va->vars[0];
 
               va->total_sss = va->cell_sss;
             }
@@ -2507,9 +2508,9 @@ ctables_execute (struct dataset *ds, struct ctables *ct)
         {
           struct ctables_table *t = ct->tables[i];
 
-          for (size_t ir = 0; ir < t->vaas[PIVOT_AXIS_ROW].n; ir++)
-            for (size_t ic = 0; ic < t->vaas[PIVOT_AXIS_COLUMN].n; ic++)
-              for (size_t il = 0; il < t->vaas[PIVOT_AXIS_LAYER].n; il++)
+          for (size_t ir = 0; ir < t->stacks[PIVOT_AXIS_ROW].n; ir++)
+            for (size_t ic = 0; ic < t->stacks[PIVOT_AXIS_COLUMN].n; ic++)
+              for (size_t il = 0; il < t->stacks[PIVOT_AXIS_LAYER].n; il++)
                 ctables_cell_insert (t, c, ir, ic, il, weight);
         }
     }
@@ -2561,9 +2562,9 @@ ctables_execute (struct dataset *ds, struct ctables *ct)
           sort (sorted, n, sizeof *sorted, ctables_cell_compare_3way, &aux);
 
           size_t max_depth = 0;
-          for (size_t j = 0; j < t->vaas[a].n; j++)
-            if (t->vaas[a].vas[j].n > max_depth)
-              max_depth = t->vaas[a].vas[j].n;
+          for (size_t j = 0; j < t->stacks[a].n; j++)
+            if (t->stacks[a].vas[j].n > max_depth)
+              max_depth = t->stacks[a].vas[j].n;
 
           struct pivot_category **groups = xnmalloc (max_depth, sizeof *groups);
           struct pivot_category *top = NULL;
@@ -2571,14 +2572,14 @@ ctables_execute (struct dataset *ds, struct ctables *ct)
           for (size_t j = 0; j < n; j++)
             {
               struct ctables_cell *cell = sorted[j];
-              const struct var_array *va = &t->vaas[a].vas[cell->axes[a].vaa_idx];
+              const struct var_array *va = &t->stacks[a].vas[cell->axes[a].stack_idx];
 
               size_t n_common = 0;
               bool new_subtable = false;
               if (j > 0)
                 {
                   struct ctables_cell *prev = sorted[j - 1];
-                  if (prev->axes[a].vaa_idx == cell->axes[a].vaa_idx)
+                  if (prev->axes[a].stack_idx == cell->axes[a].stack_idx)
                     {
                       for (; n_common < va->n; n_common++)
                         if (n_common != va->scale_idx
@@ -2670,7 +2671,7 @@ ctables_execute (struct dataset *ds, struct ctables *ct)
           if (cell->hide)
             continue;
 
-          const struct var_array *va = &t->vaas[t->summary_axis].vas[cell->axes[t->summary_axis].vaa_idx];
+          const struct var_array *va = &t->stacks[t->summary_axis].vas[cell->axes[t->summary_axis].stack_idx];
           const struct ctables_summary_spec_set *sss = cell->total ? &va->total_sss : &va->cell_sss;
           for (size_t j = 0; j < sss->n; j++)
             {