X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Fctables.c;h=c982f19cf63ad431faaf532c0637133daf43b574;hb=b09f1b74d89c58a78e347262540cc61824607f85;hp=ba2ac71c093f9a81e562c8672f1867d662d53acb;hpb=73ccdb2077e3df29298ee53909b28ecd9f82b703;p=pspp

diff --git a/src/language/stats/ctables.c b/src/language/stats/ctables.c
index ba2ac71c09..c982f19cf6 100644
--- a/src/language/stats/ctables.c
+++ b/src/language/stats/ctables.c
@@ -22,6 +22,7 @@
 #include "data/dataset.h"
 #include "data/dictionary.h"
 #include "data/mrset.h"
+#include "data/value-labels.h"
 #include "language/command.h"
 #include "language/lexer/format-parser.h"
 #include "language/lexer/lexer.h"
@@ -171,6 +172,13 @@ struct ctables_domain
     double missing;
   };
 
+enum ctables_summary_variant
+  {
+    CSV_CELL,
+    CSV_TOTAL
+#define N_CSVS 2
+  };
+
 struct ctables_cell
   {
     /* In struct ctables's 'cells' hmap.  Indexed by all the values in all the
@@ -181,11 +189,11 @@ struct ctables_cell
     struct ctables_domain *domains[N_CTDTS];
 
     bool hide;
-    bool total;
+    enum ctables_summary_variant sv;
 
     struct
       {
-        size_t stack_idx;
+        size_t nest_idx;
         struct ctables_cell_value
           {
             const struct ctables_category *category;
@@ -270,25 +278,21 @@ struct ctables_postcompute_expr
       };
   };
 
-enum ctables_label_position
-  {
-    CTLP_NORMAL,
-    CTLP_OPPOSITE,
-    CTLP_LAYER,
-  };
-
 struct ctables_summary_spec_set
   {
-    struct ctables_summary_spec *summaries;
+    struct ctables_summary_spec *specs;
     size_t n;
     size_t allocated;
 
     struct variable *var;
   };
 
+static void ctables_summary_spec_set_clone (struct ctables_summary_spec_set *,
+                                            const struct ctables_summary_spec_set *);
 static void ctables_summary_spec_set_uninit (struct ctables_summary_spec_set *);
 
-struct var_array
+/* A nested sequence of variables, e.g. a > b > c. */
+struct ctables_nest
   {
     struct variable **vars;
     size_t n;
@@ -296,30 +300,51 @@ struct var_array
     size_t *domains[N_CTDTS];
     size_t n_domains[N_CTDTS];
 
-    struct ctables_summary_spec_set cell_sss;
-    struct ctables_summary_spec_set total_sss;
+    struct ctables_summary_spec_set specs[N_CSVS];
   };
 
-/* A stack of nestings, e.g. this represents (...) + (...) + ... + (...). */
+/* A stack of nestings, e.g. nest1 + nest2 + ... + nestN. */
 struct ctables_stack
   {
-    struct var_array *vas;
+    struct ctables_nest *nests;
     size_t n;
   };
 
+struct ctables_value
+  {
+    struct hmap_node node;
+    union value value;
+    int leaf;
+  };
+
 struct ctables_table
   {
     struct ctables_axis *axes[PIVOT_N_AXES];
     struct ctables_stack stacks[PIVOT_N_AXES];
     enum pivot_axis_type summary_axis;
+    struct ctables_summary_spec_set summary_specs;
     struct hmap cells;
     struct hmap domains[N_CTDTS];
 
-    enum pivot_axis_type slabels_position;
+    const struct variable *clabels_example;
+    struct hmap clabels_values_map;
+    struct ctables_value **clabels_values;
+    size_t n_clabels_values;
+
+    enum pivot_axis_type slabels_axis;
     bool slabels_visible;
 
-    enum ctables_label_position row_labels;
-    enum ctables_label_position col_labels;
+    /* The innermost category labels for axis 'a' appear on axis label_axis[a].
+
+       Most commonly, label_axis[a] == a, and in particular we always have
+       label_axis{PIVOT_AXIS_LAYER] == PIVOT_AXIS_LAYER.
+
+       If ROWLABELS or COLLABELS is specified, then one of
+       label_axis[PIVOT_AXIS_ROW] or label_axis[PIVOT_AXIS_COLUMN] can be the
+       opposite axis or PIVOT_AXIS_LAYER.  Only one of them will differ.
+    */
+    enum pivot_axis_type label_axis[PIVOT_N_AXES];
+    enum pivot_axis_type clabels_from_axis;
 
     /* Indexed by variable dictionary index. */
     struct ctables_categories **categories;
@@ -441,6 +466,46 @@ ctables_category_uninit (struct ctables_category *cat)
     }
 }
 
+static bool
+ctables_category_equal (const struct ctables_category *a,
+                        const struct ctables_category *b)
+{
+  if (a->type != b->type)
+    return false;
+
+  switch (a->type)
+    {
+    case CCT_NUMBER:
+      return a->number == b->number;
+
+    case CCT_STRING:
+      return strcmp (a->string, b->string);
+
+    case CCT_RANGE:
+      return a->range[0] == b->range[0] && a->range[1] == b->range[1];
+
+    case CCT_MISSING:
+    case CCT_OTHERNM:
+      return true;
+
+    case CCT_SUBTOTAL:
+    case CCT_HSUBTOTAL:
+    case CCT_TOTAL:
+      return !strcmp (a->total_label, b->total_label);
+
+    case CCT_VALUE:
+    case CCT_LABEL:
+    case CCT_FUNCTION:
+      return (a->include_missing == b->include_missing
+              && a->sort_ascending == b->sort_ascending
+              && a->sort_function == b->sort_function
+              && a->sort_var == b->sort_var
+              && a->percentile == b->percentile);
+    }
+
+  NOT_REACHED ();
+}
+
 static void
 ctables_categories_unref (struct ctables_categories *c)
 {
@@ -457,6 +522,20 @@ ctables_categories_unref (struct ctables_categories *c)
   free (c);
 }
 
+static bool
+ctables_categories_equal (const struct ctables_categories *a,
+                          const struct ctables_categories *b)
+{
+  if (a->n_cats != b->n_cats || a->show_empty != b->show_empty)
+    return false;
+
+  for (size_t i = 0; i < a->n_cats; i++)
+    if (!ctables_category_equal (&a->cats[i], &b->cats[i]))
+      return false;
+
+  return true;
+}
+
 /* Chi-square test (SIGTEST). */
 struct ctables_chisq
   {
@@ -499,8 +578,7 @@ struct ctables_axis
           {
             struct ctables_var var;
             bool scale;
-            struct ctables_summary_spec_set cell_sss;
-            struct ctables_summary_spec_set total_sss;
+            struct ctables_summary_spec_set specs[N_CSVS];
           };
 
         /* Nonterminals. */
@@ -532,8 +610,17 @@ struct ctables_summary_spec
     double percentile;          /* CTSF_PTILE only. */
     char *label;
     struct fmt_spec format;     /* XXX extra CTABLES formats */
+    size_t axis_idx;
   };
 
+static void
+ctables_summary_spec_clone (struct ctables_summary_spec *dst,
+                            const struct ctables_summary_spec *src)
+{
+  *dst = *src;
+  dst->label = xstrdup (src->label);
+}
+
 static void
 ctables_summary_spec_uninit (struct ctables_summary_spec *s)
 {
@@ -541,12 +628,28 @@ ctables_summary_spec_uninit (struct ctables_summary_spec *s)
     free (s->label);
 }
 
+static void
+ctables_summary_spec_set_clone (struct ctables_summary_spec_set *dst,
+                                const struct ctables_summary_spec_set *src)
+{
+  struct ctables_summary_spec *specs = xnmalloc (src->n, sizeof *specs);
+  for (size_t i = 0; i < src->n; i++)
+    ctables_summary_spec_clone (&specs[i], &src->specs[i]);
+
+  *dst = (struct ctables_summary_spec_set) {
+    .specs = specs,
+    .n = src->n,
+    .allocated = src->n,
+    .var = src->var
+  };
+}
+
 static void
 ctables_summary_spec_set_uninit (struct ctables_summary_spec_set *set)
 {
   for (size_t i = 0; i < set->n; i++)
-    ctables_summary_spec_uninit (&set->summaries[i]);
-  free (set->summaries);
+    ctables_summary_spec_uninit (&set->specs[i]);
+  free (set->specs);
 }
 
 static bool
@@ -642,8 +745,8 @@ ctables_axis_destroy (struct ctables_axis *axis)
   switch (axis->op)
     {
     case CTAO_VAR:
-      ctables_summary_spec_set_uninit (&axis->cell_sss);
-      ctables_summary_spec_set_uninit (&axis->total_sss);
+      for (size_t i = 0; i < N_CSVS; i++)
+        ctables_summary_spec_set_uninit (&axis->specs[i]);
       break;
 
     case CTAO_STACK:
@@ -734,7 +837,7 @@ static bool
 add_summary_spec (struct ctables_axis *axis,
                   enum ctables_summary_function function, double percentile,
                   const char *label, const struct fmt_spec *format,
-                  const struct msg_location *loc, bool totals)
+                  const struct msg_location *loc, enum ctables_summary_variant sv)
 {
   if (axis->op == CTAO_VAR)
     {
@@ -769,13 +872,12 @@ add_summary_spec (struct ctables_axis *axis,
           break;
         }
 
-      struct ctables_summary_spec_set *set = (totals ? &axis->total_sss
-                                              : &axis->cell_sss);
+      struct ctables_summary_spec_set *set = &axis->specs[sv];
       if (set->n >= set->allocated)
-        set->summaries = x2nrealloc (set->summaries, &set->allocated,
-                                     sizeof *set->summaries);
+        set->specs = x2nrealloc (set->specs, &set->allocated,
+                                 sizeof *set->specs);
 
-      struct ctables_summary_spec *dst = &set->summaries[set->n++];
+      struct ctables_summary_spec *dst = &set->specs[set->n++];
       *dst = (struct ctables_summary_spec) {
         .function = function,
         .percentile = percentile,
@@ -789,7 +891,7 @@ add_summary_spec (struct ctables_axis *axis,
     {
       for (size_t i = 0; i < 2; i++)
         if (!add_summary_spec (axis->subs[i], function, percentile, label,
-                               format, loc, totals))
+                               format, loc, sv))
           return false;
       return true;
     }
@@ -863,6 +965,12 @@ ctables_axis_parse_primary (struct ctables_axis_parse_ctx *ctx)
   return axis;
 }
 
+static bool
+has_digit (const char *s)
+{
+  return s[strcspn (s, "0123456789")] != '\0';
+}
+
 static struct ctables_axis *
 ctables_axis_parse_postfix (struct ctables_axis_parse_ctx *ctx)
 {
@@ -870,7 +978,7 @@ ctables_axis_parse_postfix (struct ctables_axis_parse_ctx *ctx)
   if (!sub || !lex_match (ctx->lexer, T_LBRACK))
     return sub;
 
-  bool totals = false;
+  enum ctables_summary_variant sv = CSV_CELL;
   for (;;)
     {
       int start_ofs = lex_ofs (ctx->lexer);
@@ -903,7 +1011,8 @@ ctables_axis_parse_postfix (struct ctables_axis_parse_ctx *ctx)
       /* Parse format. */
       struct fmt_spec format;
       const struct fmt_spec *formatp;
-      if (lex_token (ctx->lexer) == T_ID)
+      if (lex_token (ctx->lexer) == T_ID
+          && has_digit (lex_tokcstr (ctx->lexer)))
         {
           if (!parse_format_specifier (ctx->lexer, &format)
               || !fmt_check_output (&format)
@@ -919,28 +1028,23 @@ ctables_axis_parse_postfix (struct ctables_axis_parse_ctx *ctx)
 
       struct msg_location *loc = lex_ofs_location (ctx->lexer, start_ofs,
                                                    lex_ofs (ctx->lexer) - 1);
-      add_summary_spec (sub, function, percentile, label, formatp, loc,
-                        totals);
+      add_summary_spec (sub, function, percentile, label, formatp, loc, sv);
       free (label);
       msg_location_destroy (loc);
 
-      if (lex_match (ctx->lexer, T_COMMA))
+      lex_match (ctx->lexer, T_COMMA);
+      if (sv == CSV_CELL && lex_match_id (ctx->lexer, "TOTALS"))
         {
-          if (!totals && lex_match_id (ctx->lexer, "TOTALS"))
-            {
-              if (!lex_force_match (ctx->lexer, T_LBRACK))
-                goto error;
-              totals = true;
-            }
+          if (!lex_force_match (ctx->lexer, T_LBRACK))
+            goto error;
+          sv = CSV_TOTAL;
         }
-      else if (lex_force_match (ctx->lexer, T_RBRACK))
+      else if (lex_match (ctx->lexer, T_RBRACK))
         {
-          if (totals && !lex_force_match (ctx->lexer, T_RBRACK))
+          if (sv == CSV_TOTAL && !lex_force_match (ctx->lexer, T_RBRACK))
             goto error;
           return sub;
         }
-      else
-        goto error;
     }
 
 error:
@@ -981,7 +1085,7 @@ find_categorical_summary_spec (const struct ctables_axis *axis)
   if (!axis)
     return NULL;
   else if (axis->op == CTAO_VAR)
-    return !axis->scale && axis->cell_sss.n ? axis : NULL;
+    return !axis->scale && axis->specs[CSV_CELL].n ? axis : NULL;
   else
     {
       for (size_t i = 0; i < 2; i++)
@@ -1437,10 +1541,10 @@ ctables_table_parse_categories (struct lexer *lexer, struct dictionary *dict,
 }
 
 static void
-var_array_uninit (struct var_array *va)
+ctables_nest_uninit (struct ctables_nest *nest)
 {
-  if (va)
-    free (va->vars);
+  if (nest)
+    free (nest->vars);
 }
 
 static void
@@ -1449,25 +1553,25 @@ ctables_stack_uninit (struct ctables_stack *stack)
   if (stack)
     {
       for (size_t i = 0; i < stack->n; i++)
-        var_array_uninit (&stack->vas[i]);
-      free (stack->vas);
+        ctables_nest_uninit (&stack->nests[i]);
+      free (stack->nests);
     }
 }
 
 static struct ctables_stack
-nest_fts (struct ctables_stack va0, struct ctables_stack va1)
+nest_fts (struct ctables_stack s0, struct ctables_stack s1)
 {
-  if (!va0.n)
-    return va1;
-  else if (!va1.n)
-    return va0;
+  if (!s0.n)
+    return s1;
+  else if (!s1.n)
+    return s0;
 
-  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++)
+  struct ctables_stack stack = { .nests = xnmalloc (s0.n, s1.n * sizeof *stack.nests) };
+  for (size_t i = 0; i < s0.n; i++)
+    for (size_t j = 0; j < s1.n; j++)
       {
-        const struct var_array *a = &va0.vas[i];
-        const struct var_array *b = &va1.vas[j];
+        const struct ctables_nest *a = &s0.nests[i];
+        const struct ctables_nest *b = &s1.nests[j];
 
         size_t allocate = a->n + b->n;
         struct variable **vars = xnmalloc (allocate, sizeof *vars);
@@ -1479,39 +1583,41 @@ nest_fts (struct ctables_stack va0, struct ctables_stack va1)
           vars[n++] = b->vars[k];
         assert (n == allocate);
 
-        const struct var_array *summary_src;
-        if (!a->cell_sss.var)
+        const struct ctables_nest *summary_src;
+        if (!a->specs[CSV_CELL].var)
           summary_src = b;
-        else if (!b->cell_sss.var)
+        else if (!b->specs[CSV_CELL].var)
           summary_src = a;
         else
           NOT_REACHED ();
-        stack.vas[stack.n++] = (struct var_array) {
+
+        struct ctables_nest *new = &stack.nests[stack.n++];
+        *new = (struct ctables_nest) {
           .vars = vars,
           .scale_idx = (a->scale_idx != SIZE_MAX ? a->scale_idx
                         : b->scale_idx != SIZE_MAX ? a->n + b->scale_idx
                         : SIZE_MAX),
           .n = n,
-          .cell_sss = summary_src->cell_sss,
-          .total_sss = summary_src->total_sss,
         };
+        for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++)
+          ctables_summary_spec_set_clone (&new->specs[sv], &summary_src->specs[sv]);
       }
-  ctables_stack_uninit (&va0);
-  ctables_stack_uninit (&va1);
+  ctables_stack_uninit (&s0);
+  ctables_stack_uninit (&s1);
   return stack;
 }
 
 static struct ctables_stack
 stack_fts (struct ctables_stack s0, struct ctables_stack s1)
 {
-  struct ctables_stack stack = { .vas = xnmalloc (s0.n + s1.n, sizeof *stack.vas) };
+  struct ctables_stack stack = { .nests = xnmalloc (s0.n + s1.n, sizeof *stack.nests) };
   for (size_t i = 0; i < s0.n; i++)
-    stack.vas[stack.n++] = s0.vas[i];
+    stack.nests[stack.n++] = s0.nests[i];
   for (size_t i = 0; i < s1.n; i++)
-    stack.vas[stack.n++] = s1.vas[i];
+    stack.nests[stack.n++] = s1.nests[i];
   assert (stack.n == s0.n + s1.n);
-  free (s0.vas);
-  free (s1.vas);
+  free (s0.nests);
+  free (s1.nests);
   return stack;
 }
 
@@ -1529,20 +1635,19 @@ enumerate_fts (enum pivot_axis_type axis_type, const struct ctables_axis *a)
       struct variable **vars = xmalloc (sizeof *vars);
       *vars = a->var.var;
 
-      struct var_array *va = xmalloc (sizeof *va);
-      *va = (struct var_array) {
+      struct ctables_nest *nest = xmalloc (sizeof *nest);
+      *nest = (struct ctables_nest) {
         .vars = vars,
         .n = 1,
         .scale_idx = a->scale ? 0 : SIZE_MAX,
       };
-      if (a->cell_sss.n || a->scale)
-        {
-          va->cell_sss = a->cell_sss;
-          va->total_sss = a->total_sss;
-          va->cell_sss.var = a->var.var;
-          va->total_sss.var = a->var.var;
-        }
-      return (struct ctables_stack) { .vas = va, .n = 1 };
+      if (a->specs[CSV_CELL].n || a->scale)
+        for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++)
+          {
+            ctables_summary_spec_set_clone (&nest->specs[sv], &a->specs[sv]);
+            nest->specs[sv].var = a->var.var;
+          }
+      return (struct ctables_stack) { .nests = nest, .n = 1 };
 
     case CTAO_STACK:
       return stack_fts (enumerate_fts (axis_type, a->subs[0]),
@@ -1820,7 +1925,8 @@ ctables_summary_add (union ctables_summary *s,
     case CTSF_LAYERPCT_SUM:
     case CTSF_LAYERROWPCT_SUM:
     case CTSF_LAYERCOLPCT_SUM:
-      moments1_add (s->moments, value->f, weight);
+      if (!var_is_value_missing (var, value))
+        moments1_add (s->moments, value->f, weight);
       break;
 
     case CTSF_MEDIAN:
@@ -2013,16 +2119,16 @@ 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].stack_idx;
-  size_t b_idx = b->axes[aux->a].stack_idx;
+  size_t a_idx = a->axes[aux->a].nest_idx;
+  size_t b_idx = b->axes[aux->a].nest_idx;
   if (a_idx != b_idx)
     return a_idx < b_idx ? -1 : 1;
 
-  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)
+  const struct ctables_nest *nest = &aux->t->stacks[aux->a].nests[a_idx];
+  for (size_t i = 0; i < nest->n; i++)
+    if (i != nest->scale_idx)
       {
-        const struct variable *var = va->vars[i];
+        const struct variable *var = nest->vars[i];
         const struct ctables_cell_value *a_cv = &a->axes[aux->a].cvs[i];
         const struct ctables_cell_value *b_cv = &b->axes[aux->a].cvs[i];
         if (a_cv->category != b_cv->category)
@@ -2103,14 +2209,14 @@ 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].stack_idx;
-      const struct var_array *va = &t->stacks[a].vas[idx];
+      size_t idx = cell->axes[a].nest_idx;
+      const struct ctables_nest *nest = &t->stacks[a].nests[idx];
       hash = hash_int (idx, hash);
-      for (size_t i = 0; i < va->n_domains[domain]; i++)
+      for (size_t i = 0; i < nest->n_domains[domain]; i++)
         {
-          size_t v_idx = va->domains[domain][i];
+          size_t v_idx = nest->domains[domain][i];
           hash = value_hash (&cell->axes[a].cvs[v_idx].value,
-                             var_get_width (va->vars[v_idx]), hash);
+                             var_get_width (nest->vars[v_idx]), hash);
         }
     }
 
@@ -2120,17 +2226,17 @@ 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].stack_idx;
-          if (idx != df->axes[a].stack_idx)
+          size_t idx = cell->axes[a].nest_idx;
+          if (idx != df->axes[a].nest_idx)
             goto not_equal;
 
-          const struct var_array *va = &t->stacks[a].vas[idx];
-          for (size_t i = 0; i < va->n_domains[domain]; i++)
+          const struct ctables_nest *nest = &t->stacks[a].nests[idx];
+          for (size_t i = 0; i < nest->n_domains[domain]; i++)
             {
-              size_t v_idx = va->domains[domain][i];
+              size_t v_idx = nest->domains[domain][i];
               if (!value_equal (&df->axes[a].cvs[v_idx].value,
                                 &cell->axes[a].cvs[v_idx].value,
-                                var_get_width (va->vars[v_idx])))
+                                var_get_width (nest->vars[v_idx])))
                 goto not_equal;
             }
         }
@@ -2205,31 +2311,30 @@ ctables_categories_total (const struct ctables_categories *c)
           : NULL);
 }
 
-static void
+static struct ctables_cell *
 ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c,
                        size_t ix[PIVOT_N_AXES],
-                       const struct ctables_category *cats[PIVOT_N_AXES][10],
-                       double weight)
+                       const struct ctables_category *cats[PIVOT_N_AXES][10])
 {
-  const struct var_array *ss = &t->stacks[t->summary_axis].vas[ix[t->summary_axis]];
+  const struct ctables_nest *ss = &t->stacks[t->summary_axis].nests[ix[t->summary_axis]];
 
   size_t hash = 0;
-  bool total = false;
+  enum ctables_summary_variant sv = CSV_CELL;
   for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
     {
-      const struct var_array *va = &t->stacks[a].vas[ix[a]];
+      const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]];
       hash = hash_int (ix[a], hash);
-      for (size_t i = 0; i < va->n; i++)
-        if (i != va->scale_idx)
+      for (size_t i = 0; i < nest->n; i++)
+        if (i != nest->scale_idx)
           {
             hash = hash_pointer (cats[a][i], hash);
             if (cats[a][i]->type != CCT_TOTAL
                 && cats[a][i]->type != CCT_SUBTOTAL
                 && cats[a][i]->type != CCT_HSUBTOTAL)
-              hash = value_hash (case_data (c, va->vars[i]),
-                                 var_get_width (va->vars[i]), hash);
+              hash = value_hash (case_data (c, nest->vars[i]),
+                                 var_get_width (nest->vars[i]), hash);
             else
-              total = true;
+              sv = CSV_TOTAL;
           }
     }
 
@@ -2238,39 +2343,39 @@ 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->stacks[a].vas[ix[a]];
-          if (cell->axes[a].stack_idx != ix[a])
+          const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]];
+          if (cell->axes[a].nest_idx != ix[a])
             goto not_equal;
-          for (size_t i = 0; i < va->n; i++)
-            if (i != va->scale_idx
+          for (size_t i = 0; i < nest->n; i++)
+            if (i != nest->scale_idx
                 && (cats[a][i] != cell->axes[a].cvs[i].category
                     || (cats[a][i]->type != CCT_TOTAL
                         && cats[a][i]->type != CCT_SUBTOTAL
                         && cats[a][i]->type != CCT_HSUBTOTAL
-                        && !value_equal (case_data (c, va->vars[i]),
+                        && !value_equal (case_data (c, nest->vars[i]),
                                          &cell->axes[a].cvs[i].value,
-                                         var_get_width (va->vars[i])))))
+                                         var_get_width (nest->vars[i])))))
                 goto not_equal;
         }
 
-      goto summarize;
+      return cell;
 
     not_equal: ;
     }
 
   cell = xmalloc (sizeof *cell);
   cell->hide = false;
-  cell->total = total;
+  cell->sv = sv;
   for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; 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)
+      const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]];
+      cell->axes[a].nest_idx = ix[a];
+      cell->axes[a].cvs = (nest->n
+                        ? xnmalloc (nest->n, sizeof *cell->axes[a].cvs)
                         : NULL);
-      for (size_t i = 0; i < va->n; i++)
+      for (size_t i = 0; i < nest->n; i++)
         {
-          if (i != va->scale_idx)
+          if (i != nest->scale_idx)
             {
               const struct ctables_category *subtotal = cats[a][i]->subtotal;
               if (subtotal && subtotal->type == CCT_HSUBTOTAL)
@@ -2278,28 +2383,34 @@ ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c,
             }
 
           cell->axes[a].cvs[i].category = cats[a][i];
-          value_clone (&cell->axes[a].cvs[i].value, case_data (c, va->vars[i]),
-                       var_get_width (va->vars[i]));
+          value_clone (&cell->axes[a].cvs[i].value, case_data (c, nest->vars[i]),
+                       var_get_width (nest->vars[i]));
         }
     }
 
-  {
-    const struct ctables_summary_spec_set *sss
-      = (cell->total ? &ss->total_sss : &ss->cell_sss);
-    cell->summaries = xmalloc (sss->n * sizeof *cell->summaries);
-    for (size_t i = 0; i < sss->n; i++)
-      ctables_summary_init (&cell->summaries[i], &sss->summaries[i]);
-  }
+  const struct ctables_summary_spec_set *specs = &ss->specs[cell->sv];
+  cell->summaries = xmalloc (specs->n * sizeof *cell->summaries);
+  for (size_t i = 0; i < specs->n; i++)
+    ctables_summary_init (&cell->summaries[i], &specs->specs[i]);
   for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++)
     cell->domains[dt] = ctables_domain_insert (t, cell, dt);
   hmap_insert (&t->cells, &cell->node, hash);
+  return cell;
+}
+
+static void
+ctables_cell_add__ (struct ctables_table *t, const struct ccase *c,
+                    size_t ix[PIVOT_N_AXES],
+                    const struct ctables_category *cats[PIVOT_N_AXES][10],
+                    double weight)
+{
+  struct ctables_cell *cell = ctables_cell_insert__ (t, c, ix, cats);
+  const struct ctables_nest *ss = &t->stacks[t->summary_axis].nests[ix[t->summary_axis]];
 
-summarize: ;
-  const struct ctables_summary_spec_set *sss
-    = (cell->total ? &ss->total_sss : &ss->cell_sss);
-  for (size_t i = 0; i < sss->n; i++)
-    ctables_summary_add (&cell->summaries[i], &sss->summaries[i], sss->var,
-                         case_data (c, sss->var), weight);
+  const struct ctables_summary_spec_set *specs = &ss->specs[cell->sv];
+  for (size_t i = 0; i < specs->n; i++)
+    ctables_summary_add (&cell->summaries[i], &specs->specs[i], specs->var,
+                         case_data (c, specs->var), weight);
   for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++)
     cell->domains[dt]->valid += weight;
 }
@@ -2309,17 +2420,17 @@ recurse_totals (struct ctables_table *t, const struct ccase *c,
                 size_t ix[PIVOT_N_AXES],
                 const struct ctables_category *cats[PIVOT_N_AXES][10],
                 double weight,
-                enum pivot_axis_type start_a, size_t start_va)
+                enum pivot_axis_type start_axis, size_t start_nest)
 {
-  for (enum pivot_axis_type a = start_a; a < PIVOT_N_AXES; a++)
+  for (enum pivot_axis_type a = start_axis; a < PIVOT_N_AXES; a++)
     {
-      const struct var_array *va = &t->stacks[a].vas[ix[a]];
-      for (size_t i = start_va; i < va->n; i++)
+      const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]];
+      for (size_t i = start_nest; i < nest->n; i++)
         {
-          if (i == va->scale_idx)
+          if (i == nest->scale_idx)
             continue;
 
-          const struct variable *var = va->vars[i];
+          const struct variable *var = nest->vars[i];
 
           const struct ctables_category *total = ctables_categories_total (
             t->categories[var_get_dict_index (var)]);
@@ -2327,12 +2438,40 @@ recurse_totals (struct ctables_table *t, const struct ccase *c,
             {
               const struct ctables_category *save = cats[a][i];
               cats[a][i] = total;
-              ctables_cell_insert__ (t, c, ix, cats, weight);
+              ctables_cell_add__ (t, c, ix, cats, weight);
               recurse_totals (t, c, ix, cats, weight, a, i + 1);
               cats[a][i] = save;
             }
         }
-      start_va = 0;
+      start_nest = 0;
+    }
+}
+
+static void
+recurse_subtotals (struct ctables_table *t, const struct ccase *c,
+                   size_t ix[PIVOT_N_AXES],
+                   const struct ctables_category *cats[PIVOT_N_AXES][10],
+                   double weight,
+                   enum pivot_axis_type start_axis, size_t start_nest)
+{
+  for (enum pivot_axis_type a = start_axis; a < PIVOT_N_AXES; a++)
+    {
+      const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]];
+      for (size_t i = start_nest; i < nest->n; i++)
+        {
+          if (i == nest->scale_idx)
+            continue;
+
+          const struct ctables_category *save = cats[a][i];
+          if (save->subtotal)
+            {
+              cats[a][i] = save->subtotal;
+              ctables_cell_add__ (t, c, ix, cats, weight);
+              recurse_subtotals (t, c, ix, cats, weight, a, i + 1);
+              cats[a][i] = save;
+            }
+        }
+      start_nest = 0;
     }
 }
 
@@ -2351,13 +2490,13 @@ 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->stacks[a].vas[ix[a]];
-      for (size_t i = 0; i < va->n; i++)
+      const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]];
+      for (size_t i = 0; i < nest->n; i++)
         {
-          if (i == va->scale_idx)
+          if (i == nest->scale_idx)
             continue;
 
-          const struct variable *var = va->vars[i];
+          const struct variable *var = nest->vars[i];
           const union value *value = case_data (c, var);
 
           if (var_is_numeric (var) && value->f == SYSMIS)
@@ -2370,128 +2509,645 @@ ctables_cell_insert (struct ctables_table *t,
         }
     }
 
-  ctables_cell_insert__ (t, c, ix, cats, weight);
+  ctables_cell_add__ (t, c, ix, cats, weight);
 
   recurse_totals (t, c, ix, cats, weight, 0, 0);
+  recurse_subtotals (t, c, ix, cats, weight, 0, 0);
+}
+
+struct merge_item
+  {
+    const struct ctables_summary_spec_set *set;
+    size_t ofs;
+  };
+
+static int
+merge_item_compare_3way (const struct merge_item *a, const struct merge_item *b)
+{
+  const struct ctables_summary_spec *as = &a->set->specs[a->ofs];
+  const struct ctables_summary_spec *bs = &b->set->specs[b->ofs];
+  if (as->function != bs->function)
+    return as->function > bs->function ? 1 : -1;
+  else if (as->percentile != bs->percentile)
+    return as->percentile < bs->percentile ? 1 : -1;
+  return strcmp (as->label, bs->label);
+}
+
+static struct pivot_value *
+ctables_category_create_label (const struct ctables_category *cat,
+                               const struct variable *var,
+                               const union value *value)
+{
+  return (cat->type == CCT_TOTAL || cat->type == CCT_SUBTOTAL || cat->type == CCT_HSUBTOTAL
+          ? pivot_value_new_user_text (cat->total_label, SIZE_MAX)
+          : pivot_value_new_var_value (var, value));
+}
+
+static struct ctables_value *
+ctables_value_find__ (struct ctables_table *t, const union value *value,
+                      int width, unsigned int hash)
+{
+  struct ctables_value *clv;
+  HMAP_FOR_EACH_WITH_HASH (clv, struct ctables_value, node,
+                           hash, &t->clabels_values_map)
+    if (value_equal (value, &clv->value, width))
+      return clv;
+  return NULL;
+}
+
+static struct ctables_value *
+ctables_value_find (struct ctables_table *t,
+                    const union value *value, int width)
+{
+  return ctables_value_find__ (t, value, width,
+                               value_hash (value, width, 0));
+}
+
+static void
+ctables_table_output (struct ctables *ct, struct ctables_table *t)
+{
+  struct pivot_table *pt = pivot_table_create__ (
+    (t->title
+     ? pivot_value_new_user_text (t->title, SIZE_MAX)
+     : pivot_value_new_text (N_("Custom Tables"))),
+    "Custom Tables");
+  if (t->caption)
+    pivot_table_set_caption (
+      pt, pivot_value_new_user_text (t->caption, SIZE_MAX));
+  if (t->corner)
+    pivot_table_set_caption (
+      pt, pivot_value_new_user_text (t->corner, SIZE_MAX));
+
+  bool summary_dimension = (t->summary_axis != t->slabels_axis
+                            || (!t->slabels_visible
+                                && t->summary_specs.n > 1));
+  if (summary_dimension)
+    {
+      struct pivot_dimension *d = pivot_dimension_create (
+        pt, t->slabels_axis, N_("Statistics"));
+      const struct ctables_summary_spec_set *specs = &t->summary_specs;
+      if (!t->slabels_visible)
+        d->hide_all_labels = true;
+      for (size_t i = 0; i < specs->n; i++)
+        pivot_category_create_leaf (
+          d->root, pivot_value_new_text (specs->specs[i].label));
+    }
+
+  bool categories_dimension = t->clabels_example != NULL;
+  if (categories_dimension)
+    {
+      struct pivot_dimension *d = pivot_dimension_create (
+        pt, t->label_axis[t->clabels_from_axis],
+        t->clabels_from_axis == PIVOT_AXIS_ROW
+        ? N_("Row Categories")
+        : N_("Column Categories"));
+      const struct variable *var = t->clabels_example;
+      const struct ctables_categories *c = t->categories[var_get_dict_index (var)];
+      for (size_t i = 0; i < t->n_clabels_values; i++)
+        {
+          const struct ctables_value *value = t->clabels_values[i];
+          const struct ctables_category *cat = ctables_categories_match (c, &value->value, var);
+          assert (cat != NULL);
+          pivot_category_create_leaf (d->root, ctables_category_create_label (
+                                        cat, t->clabels_example, &value->value));
+        }
+    }
 
+  pivot_table_set_look (pt, ct->look);
+  struct pivot_dimension *d[PIVOT_N_AXES];
   for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
     {
-      const struct var_array *va = &t->stacks[a].vas[ix[a]];
-      for (size_t i = 0; i < va->n; i++)
+      static const char *names[] = {
+        [PIVOT_AXIS_ROW] = N_("Rows"),
+        [PIVOT_AXIS_COLUMN] = N_("Columns"),
+        [PIVOT_AXIS_LAYER] = N_("Layers"),
+      };
+      d[a] = (t->axes[a] || a == t->summary_axis
+              ? pivot_dimension_create (pt, a, names[a])
+              : NULL);
+      if (!d[a])
+        continue;
+
+      assert (t->axes[a]);
+
+      struct ctables_cell **sorted = xnmalloc (t->cells.count, sizeof *sorted);
+      size_t n_sorted = 0;
+
+      struct ctables_cell *cell;
+      HMAP_FOR_EACH (cell, struct ctables_cell, node, &t->cells)
+        if (!cell->hide)
+          sorted[n_sorted++] = cell;
+      assert (n_sorted <= t->cells.count);
+
+      struct ctables_cell_sort_aux aux = { .t = t, .a = a };
+      sort (sorted, n_sorted, sizeof *sorted, ctables_cell_compare_3way, &aux);
+
+      size_t max_depth = 0;
+      for (size_t j = 0; j < t->stacks[a].n; j++)
+        if (t->stacks[a].nests[j].n > max_depth)
+          max_depth = t->stacks[a].nests[j].n;
+
+      /* Pivot categories:
+
+         - variable label for nest->vars[0], if vlabel != CTVL_NONE
+         - category for nest->vars[0], if nest->scale_idx != 0
+         - variable label for nest->vars[1], if vlabel != CTVL_NONE
+         - category for nest->vars[1], if nest->scale_idx != 1
+         ...
+         - variable label for nest->vars[n - 1], if vlabel != CTVL_NONE
+         - category for nest->vars[n - 1], if t->label_axis[a] == a && nest->scale_idx != n - 1.
+         - summary function, if 'a == t->slabels_axis && a ==
+         t->summary_axis'.
+
+         Additional dimensions:
+
+         - If 'a == t->slabels_axis && a != t->summary_axis', add a summary
+         dimension.
+         - If 't->label_axis[b] == a' for some 'b != a', add a category
+         dimension to 'a'.
+      */
+
+      struct ctables_level
         {
-          if (i == va->scale_idx)
-            continue;
+          enum ctables_level_type
+            {
+              CTL_VAR,          /* Variable label for nest->vars[var_idx]. */
+              CTL_CATEGORY,     /* Category for nest->vars[var_idx]. */
+              CTL_SUMMARY,      /* Summary functions. */
+            }
+          type;
 
-          const struct ctables_category *save = cats[a][i];
-          if (save->subtotal)
+          size_t var_idx;
+        };
+      struct ctables_level *levels = xnmalloc (1 + 2 * max_depth, sizeof *levels);
+      size_t n_levels = 0;
+
+      struct pivot_category **groups = xnmalloc (1 + 2 * max_depth, sizeof *groups);
+      int prev_leaf = 0;
+      for (size_t j = 0; j < n_sorted; j++)
+        {
+          struct ctables_cell *cell = sorted[j];
+          struct ctables_cell *prev = j > 0 ? sorted[j - 1] : NULL;
+          const struct ctables_nest *nest = &t->stacks[a].nests[cell->axes[a].nest_idx];
+
+          bool new_subtable = !prev || prev->axes[a].nest_idx != cell->axes[a].nest_idx;
+          if (new_subtable)
             {
-              cats[a][i] = save->subtotal;
-              ctables_cell_insert__ (t, c, ix, cats, weight);
-              cats[a][i] = save;
+              n_levels = 0;
+              for (size_t k = 0; k < nest->n; k++)
+                {
+                  enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (nest->vars[k])];
+                  if (vlabel != CTVL_NONE)
+                    {
+                      levels[n_levels++] = (struct ctables_level) {
+                        .type = CTL_VAR,
+                        .var_idx = k,
+                      };
+                    }
+
+                  if (nest->scale_idx != k
+                      && (k != nest->n - 1 || t->label_axis[a] == a))
+                    {
+                      levels[n_levels++] = (struct ctables_level) {
+                        .type = CTL_CATEGORY,
+                        .var_idx = k,
+                      };
+                    }
+                }
+
+              if (!summary_dimension && a == t->slabels_axis)
+                {
+                  levels[n_levels++] = (struct ctables_level) {
+                    .type = CTL_SUMMARY,
+                    .var_idx = SIZE_MAX,
+                  };
+                }
+            }
+
+          size_t n_common = 0;
+          if (!new_subtable)
+            {
+              for (; n_common < n_levels; n_common++)
+                {
+                  const struct ctables_level *level = &levels[n_common];
+                  if (level->type == CTL_CATEGORY)
+                    {
+                      size_t var_idx = level->var_idx;
+                      const struct ctables_category *c = cell->axes[a].cvs[var_idx].category;
+                      if (prev->axes[a].cvs[var_idx].category != c)
+                        break;
+                      else if (c->type != CCT_SUBTOTAL
+                               && c->type != CCT_HSUBTOTAL
+                               && c->type != CCT_TOTAL
+                               && !value_equal (&prev->axes[a].cvs[var_idx].value,
+                                                &cell->axes[a].cvs[var_idx].value,
+                                                var_get_type (nest->vars[var_idx])))
+                        break;
+                    }
+                }
+            }
+
+          for (size_t k = n_common; k < n_levels; k++)
+            {
+              const struct ctables_level *level = &levels[k];
+              struct pivot_category *parent = k ? groups[k - 1] : d[a]->root;
+              if (level->type == CTL_SUMMARY)
+                {
+                  const struct ctables_summary_spec_set *specs = &t->summary_specs;
+                  for (size_t m = 0; m < specs->n; m++)
+                    {
+                      int leaf = pivot_category_create_leaf (
+                        parent, pivot_value_new_text (specs->specs[m].label));
+                      if (!m)
+                        prev_leaf = leaf;
+                    }
+                }
+              else
+                {
+                  const struct variable *var = nest->vars[level->var_idx];
+                  struct pivot_value *label;
+                  if (level->type == CTL_VAR)
+                    label = pivot_value_new_variable (var);
+                  else if (level->type == CTL_CATEGORY)
+                    {
+                      const struct ctables_cell_value *cv = &cell->axes[a].cvs[level->var_idx];
+                      label = ctables_category_create_label (cv->category,
+                                                             var, &cv->value);
+                    }
+                  else
+                    NOT_REACHED ();
+
+                  if (k == n_levels - 1)
+                    prev_leaf = pivot_category_create_leaf (parent, label);
+                  else
+                    groups[k] = pivot_category_create_group__ (parent, label);
+                }
             }
+
+          cell->axes[a].leaf = prev_leaf;
         }
+      free (sorted);
+      free (groups);
     }
+
+  struct ctables_cell *cell;
+  HMAP_FOR_EACH (cell, struct ctables_cell, node, &t->cells)
+    {
+      if (cell->hide)
+        continue;
+
+      const struct ctables_nest *specs_nest = &t->stacks[t->summary_axis].nests[cell->axes[t->summary_axis].nest_idx];
+      const struct ctables_summary_spec_set *specs = &specs_nest->specs[cell->sv];
+      for (size_t j = 0; j < specs->n; j++)
+        {
+          size_t dindexes[5];
+          size_t n_dindexes = 0;
+
+          if (summary_dimension)
+            dindexes[n_dindexes++] = specs->specs[j].axis_idx;
+
+          if (categories_dimension)
+            {
+              const struct ctables_nest *clabels_nest = &t->stacks[t->clabels_from_axis].nests[cell->axes[t->clabels_from_axis].nest_idx];
+              const struct variable *var = clabels_nest->vars[clabels_nest->n - 1];
+              const union value *value = &cell->axes[t->clabels_from_axis].cvs[clabels_nest->n - 1].value;
+              const struct ctables_value *ctv = ctables_value_find (t, value, var_get_width (var));
+              assert (ctv != NULL);
+              dindexes[n_dindexes++] = ctv->leaf;
+            }
+
+          for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
+            if (d[a])
+              {
+                int leaf = cell->axes[a].leaf;
+                if (a == t->summary_axis && !summary_dimension)
+                  leaf += j;
+                dindexes[n_dindexes++] = leaf;
+              }
+
+          double d = ctables_summary_value (cell, &cell->summaries[j], &specs->specs[j]);
+          struct pivot_value *value = pivot_value_new_number (d);
+          value->numeric.format = specs->specs[j].format;
+          pivot_table_put (pt, dindexes, n_dindexes, value);
+        }
+    }
+
+  pivot_table_submit (pt);
 }
 
 static bool
-ctables_execute (struct dataset *ds, struct ctables *ct)
+ctables_check_label_position (struct ctables_table *t, enum pivot_axis_type a)
 {
-  for (size_t i = 0; i < ct->n_tables; i++)
+  enum pivot_axis_type label_pos = t->label_axis[a];
+  if (label_pos == a)
+    return true;
+
+  t->clabels_from_axis = a;
+
+  const char *subcommand_name = a == PIVOT_AXIS_ROW ? "ROWLABELS" : "COLLABELS";
+  const char *pos_name = label_pos == PIVOT_AXIS_LAYER ? "LAYER" : "OPPOSITE";
+
+  const struct ctables_stack *stack = &t->stacks[a];
+  if (!stack->n)
+    return true;
+
+  const struct ctables_nest *n0 = &stack->nests[0];
+  assert (n0->n > 0);
+  const struct variable *v0 = n0->vars[n0->n - 1];
+  struct ctables_categories *c0 = t->categories[var_get_dict_index (v0)];
+  t->clabels_example = v0;
+
+  for (size_t i = 0; i < c0->n_cats; i++)
+    if (c0->cats[i].type == CCT_FUNCTION)
+      {
+        msg (SE, _("%s=%s is not allowed with sorting based "
+                   "on a summary function."),
+             subcommand_name, pos_name);
+        return false;
+      }
+  if (n0->n - 1 == n0->scale_idx)
     {
-      struct ctables_table *t = ct->tables[i];
-      for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
-        if (t->axes[a])
-          {
-            t->stacks[a] = enumerate_fts (a, t->axes[a]);
+      msg (SE, _("%s=%s requires the variables to be moved to be categorical, "
+                 "but %s is a scale variable."),
+           subcommand_name, pos_name, var_get_name (v0));
+      return false;
+    }
+
+  for (size_t i = 1; i < stack->n; i++)
+    {
+      const struct ctables_nest *ni = &stack->nests[i];
+      assert (ni->n > 0);
+      const struct variable *vi = ni->vars[ni->n - 1];
+      struct ctables_categories *ci = t->categories[var_get_dict_index (vi)];
+
+      if (ni->n - 1 == ni->scale_idx)
+        {
+          msg (SE, _("%s=%s requires the variables to be moved to be "
+                     "categorical, but %s is a scale variable."),
+               subcommand_name, pos_name, var_get_name (vi));
+          return false;
+        }
+      if (var_get_width (v0) != var_get_width (vi))
+        {
+          msg (SE, _("%s=%s requires the variables to be "
+                     "moved to have the same width, but %s has "
+                     "width %d and %s has width %d."),
+               subcommand_name, pos_name,
+               var_get_name (v0), var_get_width (v0),
+               var_get_name (vi), var_get_width (vi));
+          return false;
+        }
+      if (!val_labs_equal (var_get_value_labels (v0),
+                           var_get_value_labels (vi)))
+        {
+          msg (SE, _("%s=%s requires the variables to be "
+                     "moved to have the same value labels, but %s "
+                     "and %s have different value labels."),
+               subcommand_name, pos_name,
+               var_get_name (v0), var_get_name (vi));
+          return false;
+        }
+      if (!ctables_categories_equal (c0, ci))
+        {
+          msg (SE, _("%s=%s requires the variables to be "
+                     "moved to have the same category "
+                     "specifications, but %s and %s have different "
+                     "category specifications."),
+               subcommand_name, pos_name,
+               var_get_name (v0), var_get_name (vi));
+          return false;
+        }
+    }
+
+  return true;
+}
+
+static bool
+ctables_prepare_table (struct ctables_table *t)
+{
+  for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
+    if (t->axes[a])
+      {
+        t->stacks[a] = enumerate_fts (a, t->axes[a]);
 
-            for (size_t j = 0; j < t->stacks[a].n; j++)
+        for (size_t j = 0; j < t->stacks[a].n; j++)
+          {
+            struct ctables_nest *nest = &t->stacks[a].nests[j];
+            for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++)
               {
-                struct var_array *va = &t->stacks[a].vas[j];
-                for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++)
+                nest->domains[dt] = xmalloc (nest->n * sizeof *nest->domains[dt]);
+                nest->n_domains[dt] = 0;
+
+                for (size_t k = 0; k < nest->n; k++)
                   {
-                    va->domains[dt] = xmalloc (va->n * sizeof *va->domains[dt]);
-                    va->n_domains[dt] = 0;
+                    if (k == nest->scale_idx)
+                      continue;
 
-                    for (size_t k = 0; k < va->n; k++)
+                    switch (dt)
                       {
-                        if (k == va->scale_idx)
-                          continue;
+                      case CTDT_TABLE:
+                        continue;
 
-                        switch (dt)
+                      case CTDT_LAYER:
+                        if (a != PIVOT_AXIS_LAYER)
+                          continue;
+                        break;
+
+                      case CTDT_SUBTABLE:
+                      case CTDT_ROW:
+                      case CTDT_COL:
+                        if (dt == CTDT_SUBTABLE ? a != PIVOT_AXIS_LAYER
+                            : dt == CTDT_ROW ? a == PIVOT_AXIS_COLUMN
+                            : a == PIVOT_AXIS_ROW)
                           {
-                          case CTDT_TABLE:
-                            continue;
-
-                          case CTDT_LAYER:
-                            if (a != PIVOT_AXIS_LAYER)
-                              continue;
-                            break;
-
-                          case CTDT_SUBTABLE:
-                          case CTDT_ROW:
-                          case CTDT_COL:
-                            if (dt == CTDT_SUBTABLE ? a != PIVOT_AXIS_LAYER
-                                : dt == CTDT_ROW ? a == PIVOT_AXIS_COLUMN
-                                : a == PIVOT_AXIS_ROW)
-                              {
-                                if (k == va->n - 1
-                                    || (va->scale_idx == va->n - 1
-                                        && k == va->n - 2))
-                                  continue;
-                              }
-                            break;
-
-                          case CTDT_LAYERROW:
-                            if (a == PIVOT_AXIS_COLUMN)
-                              continue;
-                            break;
-
-                          case CTDT_LAYERCOL:
-                            if (a == PIVOT_AXIS_ROW)
+                            if (k == nest->n - 1
+                                || (nest->scale_idx == nest->n - 1
+                                    && k == nest->n - 2))
                               continue;
-                            break;
                           }
+                        break;
+
+                      case CTDT_LAYERROW:
+                        if (a == PIVOT_AXIS_COLUMN)
+                          continue;
+                        break;
 
-                        va->domains[dt][va->n_domains[dt]++] = k;
+                      case CTDT_LAYERCOL:
+                        if (a == PIVOT_AXIS_ROW)
+                          continue;
+                        break;
                       }
+
+                    nest->domains[dt][nest->n_domains[dt]++] = k;
                   }
               }
           }
-        else
-          {
-            struct var_array *va = xmalloc (sizeof *va);
-            *va = (struct var_array) { .n = 0 };
-            t->stacks[a] = (struct ctables_stack) { .vas = va, .n = 1 };
-          }
+      }
+    else
+      {
+        struct ctables_nest *nest = xmalloc (sizeof *nest);
+        *nest = (struct ctables_nest) { .n = 0 };
+        t->stacks[a] = (struct ctables_stack) { .nests = nest, .n = 1 };
+      }
 
-      for (size_t i = 0; i < t->stacks[t->summary_axis].n; i++)
+  struct ctables_stack *stack = &t->stacks[t->summary_axis];
+  for (size_t i = 0; i < stack->n; i++)
+    {
+      struct ctables_nest *nest = &stack->nests[i];
+      if (!nest->specs[CSV_CELL].n)
         {
-          struct var_array *va = &t->stacks[t->summary_axis].vas[i];
-          if (!va->cell_sss.n)
-            {
-              struct ctables_summary_spec_set *sss = &va->cell_sss;
-              sss->summaries = xmalloc (sizeof *sss->summaries);
-              sss->n = 1;
-
-              enum ctables_summary_function function
-                = sss->var ? CTSF_MEAN : CTSF_COUNT;
-              struct ctables_var var = { .is_mrset = false, .var = sss->var };
-
-              *sss->summaries = (struct ctables_summary_spec) {
-                .function = function,
-                .format = ctables_summary_default_format (function, &var),
-                .label = ctables_summary_default_label (function, 0),
-              };
-              if (!sss->var)
-                sss->var = va->vars[0];
+          struct ctables_summary_spec_set *specs = &nest->specs[CSV_CELL];
+          specs->specs = xmalloc (sizeof *specs->specs);
+          specs->n = 1;
+
+          enum ctables_summary_function function
+            = specs->var ? CTSF_MEAN : CTSF_COUNT;
+          struct ctables_var var = { .is_mrset = false, .var = specs->var };
+
+          *specs->specs = (struct ctables_summary_spec) {
+            .function = function,
+            .format = ctables_summary_default_format (function, &var),
+            .label = ctables_summary_default_label (function, 0),
+          };
+          if (!specs->var)
+            specs->var = nest->vars[0];
+
+          ctables_summary_spec_set_clone (&nest->specs[CSV_TOTAL],
+                                          &nest->specs[CSV_CELL]);
+        }
+      else if (!nest->specs[CSV_TOTAL].n)
+        ctables_summary_spec_set_clone (&nest->specs[CSV_TOTAL],
+                                        &nest->specs[CSV_CELL]);
+    }
+
+  struct ctables_summary_spec_set *merged = &t->summary_specs;
+  struct merge_item *items = xnmalloc (2 * stack->n, sizeof *items);
+  size_t n_left = 0;
+  for (size_t j = 0; j < stack->n; j++)
+    {
+      const struct ctables_nest *nest = &stack->nests[j];
+      if (nest->n)
+        for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++)
+          items[n_left++] = (struct merge_item) { .set = &nest->specs[sv] };
+    }
+
+  while (n_left > 0)
+    {
+      struct merge_item min = items[0];
+      for (size_t j = 1; j < n_left; j++)
+        if (merge_item_compare_3way (&items[j], &min) < 0)
+          min = items[j];
 
-              va->total_sss = va->cell_sss;
+      if (merged->n >= merged->allocated)
+        merged->specs = x2nrealloc (merged->specs, &merged->allocated,
+                                    sizeof *merged->specs);
+      merged->specs[merged->n++] = min.set->specs[min.ofs];
+
+      for (size_t j = 0; j < n_left; )
+        {
+          if (merge_item_compare_3way (&items[j], &min) == 0)
+            {
+              struct merge_item *item = &items[j];
+              item->set->specs[item->ofs].axis_idx = merged->n - 1;
+              if (++item->ofs >= item->set->n)
+                {
+                  items[j] = items[--n_left];
+                  continue;
+                }
             }
-          else if (!va->total_sss.n)
-            va->total_sss = va->cell_sss;
+          j++;
+        }
+    }
+
+#if 0
+  for (size_t j = 0; j < merged->n; j++)
+    printf ("%s\n", ctables_summary_function_name (merged->specs[j].function));
+
+  for (size_t j = 0; j < stack->n; j++)
+    {
+      const struct ctables_nest *nest = &stack->nests[j];
+      for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++)
+        {
+          const struct ctables_summary_spec_set *specs = &nest->specs[sv];
+          for (size_t k = 0; k < specs->n; k++)
+            printf ("(%s, %zu) ", ctables_summary_function_name (specs->specs[k].function),
+                    specs->specs[k].axis_idx);
+          printf ("\n");
+        }
+    }
+#endif
+
+  return (ctables_check_label_position (t, PIVOT_AXIS_ROW)
+          && ctables_check_label_position (t, PIVOT_AXIS_COLUMN));
+}
+
+static void
+ctables_insert_clabels_values (struct ctables_table *t, const struct ccase *c,
+                               enum pivot_axis_type a)
+{
+  struct ctables_stack *stack = &t->stacks[a];
+  for (size_t i = 0; i < stack->n; i++)
+    {
+      const struct ctables_nest *nest = &stack->nests[i];
+      const struct variable *var = nest->vars[nest->n - 1];
+      int width = var_get_width (var);
+      const union value *value = case_data (c, var);
+
+      if (var_is_numeric (var) && value->f == SYSMIS)
+        continue;
+
+      if (!ctables_categories_match (t->categories [var_get_dict_index (var)],
+                                     value, var))
+        continue;
+
+      unsigned int hash = value_hash (value, width, 0);
+
+      struct ctables_value *clv = ctables_value_find__ (t, value, width, hash);
+      if (!clv)
+        {
+          clv = xmalloc (sizeof *clv);
+          value_clone (&clv->value, value, width);
+          hmap_insert (&t->clabels_values_map, &clv->node, hash);
         }
     }
+}
+
+static int
+compare_clabels_values_3way (const void *a_, const void *b_, const void *width_)
+{
+  const struct ctables_value *const *ap = a_;
+  const struct ctables_value *const *bp = b_;
+  const struct ctables_value *a = *ap;
+  const struct ctables_value *b = *bp;
+  const int *width = width_;
+  return value_compare_3way (&a->value, &b->value, *width);
+}
+
+static void
+ctables_sort_clabels_values (struct ctables_table *t)
+{
+  int width = var_get_width (t->clabels_example);
+
+  size_t n = hmap_count (&t->clabels_values_map);
+  t->clabels_values = xnmalloc (n, sizeof *t->clabels_values);
+
+  struct ctables_value *clv;
+  size_t i = 0;
+  HMAP_FOR_EACH (clv, struct ctables_value, node, &t->clabels_values_map)
+    t->clabels_values[i++] = clv;
+  t->n_clabels_values = n;
+  assert (i == n);
+
+  sort (t->clabels_values, n, sizeof *t->clabels_values,
+        compare_clabels_values_3way, &width);
+
+  for (size_t i = 0; i < n; i++)
+    t->clabels_values[i]->leaf = i;
+}
 
+static bool
+ctables_execute (struct dataset *ds, struct ctables *ct)
+{
   struct casereader *input = casereader_create_filter_weight (proc_open (ds),
                                                               dataset_dict (ds),
                                                               NULL, NULL);
@@ -2512,6 +3168,10 @@ ctables_execute (struct dataset *ds, struct ctables *ct)
             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);
+
+          for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
+            if (t->label_axis[a] != a)
+              ctables_insert_clabels_values (t, c, a);
         }
     }
   casereader_destroy (input);
@@ -2520,183 +3180,11 @@ ctables_execute (struct dataset *ds, struct ctables *ct)
     {
       struct ctables_table *t = ct->tables[i];
 
-      struct pivot_table *pt = pivot_table_create__ (
-        (t->title
-         ? pivot_value_new_user_text (t->title, SIZE_MAX)
-         : pivot_value_new_text (N_("Custom Tables"))),
-        "Custom Tables");
-      if (t->caption)
-        pivot_table_set_caption (
-          pt, pivot_value_new_user_text (t->caption, SIZE_MAX));
-      if (t->corner)
-        pivot_table_set_caption (
-          pt, pivot_value_new_user_text (t->corner, SIZE_MAX));
-
-      pivot_table_set_look (pt, ct->look);
-      struct pivot_dimension *d[PIVOT_N_AXES];
-      for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
-        {
-          static const char *names[] = {
-            [PIVOT_AXIS_ROW] = N_("Rows"),
-            [PIVOT_AXIS_COLUMN] = N_("Columns"),
-            [PIVOT_AXIS_LAYER] = N_("Layers"),
-          };
-          d[a] = (t->axes[a] || a == t->summary_axis
-                  ? pivot_dimension_create (pt, a, names[a])
-                  : NULL);
-          if (!d[a])
-            continue;
-
-          assert (t->axes[a]);
-
-          struct ctables_cell **sorted = xnmalloc (t->cells.count, sizeof *sorted);
-
-          struct ctables_cell *cell;
-          size_t n = 0;
-          HMAP_FOR_EACH (cell, struct ctables_cell, node, &t->cells)
-            if (!cell->hide)
-              sorted[n++] = cell;
-          assert (n <= t->cells.count);
-
-          struct ctables_cell_sort_aux aux = { .t = t, .a = a };
-          sort (sorted, n, sizeof *sorted, ctables_cell_compare_3way, &aux);
-
-          size_t max_depth = 0;
-          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;
-          int prev_leaf = 0;
-          for (size_t j = 0; j < n; j++)
-            {
-              struct ctables_cell *cell = sorted[j];
-              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].stack_idx == cell->axes[a].stack_idx)
-                    {
-                      for (; n_common < va->n; n_common++)
-                        if (n_common != va->scale_idx
-                            && (prev->axes[a].cvs[n_common].category
-                                != cell->axes[a].cvs[n_common].category
-                                || !value_equal (&prev->axes[a].cvs[n_common].value,
-                                                 &cell->axes[a].cvs[n_common].value,
-                                                 var_get_type (va->vars[n_common]))))
-                          break;
-                    }
-                  else
-                    new_subtable = true;
-                }
-              else
-                new_subtable = true;
-
-              if (new_subtable)
-                {
-                  enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (va->vars[0])];
-                  top = d[a]->root;
-                  if (vlabel != CTVL_NONE)
-                    top = pivot_category_create_group__ (
-                      top, pivot_value_new_variable (va->vars[0]));
-                }
-              if (n_common == va->n)
-                {
-                  cell->axes[a].leaf = prev_leaf;
-                  continue;
-                }
-
-              for (size_t k = n_common; k < va->n; k++)
-                {
-                  struct pivot_category *parent = k > 0 ? groups[k - 1] : top;
-
-                  struct pivot_value *label
-                    = (k == va->scale_idx ? NULL
-                       : (cell->axes[a].cvs[k].category->type == CCT_TOTAL
-                          || cell->axes[a].cvs[k].category->type == CCT_SUBTOTAL
-                          || cell->axes[a].cvs[k].category->type == CCT_HSUBTOTAL)
-                       ? pivot_value_new_user_text (cell->axes[a].cvs[k].category->total_label,
-                                                    SIZE_MAX)
-                       : pivot_value_new_var_value (va->vars[k],
-                                                    &cell->axes[a].cvs[k].value));
-                  if (k == va->n - 1)
-                    {
-                      if (a == t->summary_axis)
-                        {
-                          if (label)
-                            parent = pivot_category_create_group__ (parent, label);
-                          const struct ctables_summary_spec_set *sss
-                            = cell->total ? &va->total_sss : &va->cell_sss;
-                          for (size_t m = 0; m < sss->n; m++)
-                            {
-                              int leaf = pivot_category_create_leaf (
-                                parent, pivot_value_new_text (sss->summaries[m].label));
-                              if (m == 0)
-                                prev_leaf = leaf;
-                            }
-                        }
-                      else
-                        {
-                          /* This assertion is true as long as the summary axis
-                             is the axis where the summaries are displayed. */
-                          assert (label);
-
-                          prev_leaf = pivot_category_create_leaf (parent, label);
-                        }
-                      break;
-                    }
-
-                  if (label)
-                    parent = pivot_category_create_group__ (parent, label);
-
-                  enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (va->vars[k + 1])];
-                  if (vlabel != CTVL_NONE)
-                    parent = pivot_category_create_group__ (
-                      parent, pivot_value_new_variable (va->vars[k + 1]));
-                  groups[k] = parent;
-                }
-
-              cell->axes[a].leaf = prev_leaf;
-            }
-          free (sorted);
-          free (groups);
-        }
-      struct ctables_cell *cell;
-      HMAP_FOR_EACH (cell, struct ctables_cell, node, &t->cells)
-        {
-          if (cell->hide)
-            continue;
+      if (t->clabels_example)
+        ctables_sort_clabels_values (t);
 
-          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++)
-            {
-              size_t dindexes[3];
-              size_t n_dindexes = 0;
-
-              for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
-                if (d[a])
-                  {
-                    int leaf = cell->axes[a].leaf;
-                    if (a == t->summary_axis)
-                      leaf += j;
-                    dindexes[n_dindexes++] = leaf;
-                  }
-
-              double d = ctables_summary_value (cell, &cell->summaries[j], &sss->summaries[j]);
-              struct pivot_value *value = pivot_value_new_number (d);
-              value->numeric.format = sss->summaries[j].format;
-              pivot_table_put (pt, dindexes, n_dindexes, value);
-            }
-        }
-
-      pivot_table_submit (pt);
+      ctables_table_output (ct, ct->tables[i]);
     }
-
   return proc_commit (ds);
 }
 
@@ -2935,10 +3423,15 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds)
       struct ctables_table *t = xmalloc (sizeof *t);
       *t = (struct ctables_table) {
         .cells = HMAP_INITIALIZER (t->cells),
-        .slabels_position = PIVOT_AXIS_COLUMN,
+        .slabels_axis = PIVOT_AXIS_COLUMN,
         .slabels_visible = true,
-        .row_labels = CTLP_NORMAL,
-        .col_labels = CTLP_NORMAL,
+        .clabels_values_map = HMAP_INITIALIZER (t->clabels_values_map),
+        .label_axis = {
+          [PIVOT_AXIS_ROW] = PIVOT_AXIS_ROW,
+          [PIVOT_AXIS_COLUMN] = PIVOT_AXIS_COLUMN,
+          [PIVOT_AXIS_LAYER] = PIVOT_AXIS_LAYER,
+        },
+        .clabels_from_axis = PIVOT_AXIS_LAYER, 
         .categories = categories,
         .n_categories = n_vars,
         .cilevel = 95,
@@ -3026,7 +3519,11 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds)
           }
 
       if (lex_token (lexer) == T_ENDCMD)
-        break;
+        {
+          if (!ctables_prepare_table (t))
+            goto error;
+          break;
+        }
       if (!lex_force_match (lexer, T_SLASH))
         break;
 
@@ -3034,17 +3531,17 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds)
         {
           if (lex_match_id (lexer, "SLABELS"))
             {
-              while (lex_token (lexer) != T_SLASH)
+              while (lex_token (lexer) != T_SLASH && lex_token (lexer) != T_ENDCMD)
                 {
                   if (lex_match_id (lexer, "POSITION"))
                     {
                       lex_match (lexer, T_EQUALS);
                       if (lex_match_id (lexer, "COLUMN"))
-                        t->slabels_position = PIVOT_AXIS_COLUMN;
+                        t->slabels_axis = PIVOT_AXIS_COLUMN;
                       else if (lex_match_id (lexer, "ROW"))
-                        t->slabels_position = PIVOT_AXIS_ROW;
+                        t->slabels_axis = PIVOT_AXIS_ROW;
                       else if (lex_match_id (lexer, "LAYER"))
-                        t->slabels_position = PIVOT_AXIS_LAYER;
+                        t->slabels_axis = PIVOT_AXIS_LAYER;
                       else
                         {
                           lex_error_expecting (lexer, "COLUMN", "ROW", "LAYER");
@@ -3066,17 +3563,20 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds)
             }
           else if (lex_match_id (lexer, "CLABELS"))
             {
-              while (lex_token (lexer) != T_SLASH)
+              while (lex_token (lexer) != T_SLASH && lex_token (lexer) != T_ENDCMD)
                 {
                   if (lex_match_id (lexer, "AUTO"))
-                    t->row_labels = t->col_labels = CTLP_NORMAL;
+                    {
+                      t->label_axis[PIVOT_AXIS_ROW] = PIVOT_AXIS_ROW;
+                      t->label_axis[PIVOT_AXIS_COLUMN] = PIVOT_AXIS_COLUMN;
+                    }
                   else if (lex_match_id (lexer, "ROWLABELS"))
                     {
                       lex_match (lexer, T_EQUALS);
                       if (lex_match_id (lexer, "OPPOSITE"))
-                        t->row_labels = CTLP_OPPOSITE;
+                        t->label_axis[PIVOT_AXIS_ROW] = PIVOT_AXIS_COLUMN;
                       else if (lex_match_id (lexer, "LAYER"))
-                        t->row_labels = CTLP_LAYER;
+                        t->label_axis[PIVOT_AXIS_ROW] = PIVOT_AXIS_LAYER;
                       else
                         {
                           lex_error_expecting (lexer, "OPPOSITE", "LAYER");
@@ -3087,9 +3587,9 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds)
                     {
                       lex_match (lexer, T_EQUALS);
                       if (lex_match_id (lexer, "OPPOSITE"))
-                        t->col_labels = CTLP_OPPOSITE;
+                        t->label_axis[PIVOT_AXIS_COLUMN] = PIVOT_AXIS_ROW;
                       else if (lex_match_id (lexer, "LAYER"))
-                        t->col_labels = CTLP_LAYER;
+                        t->label_axis[PIVOT_AXIS_COLUMN] = PIVOT_AXIS_LAYER;
                       else
                         {
                           lex_error_expecting (lexer, "OPPOSITE", "LAYER");
@@ -3364,12 +3864,15 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds)
             break;
         }
 
-      if (t->row_labels != CTLP_NORMAL && t->col_labels != CTLP_NORMAL)
+      if (t->label_axis[PIVOT_AXIS_ROW] != PIVOT_AXIS_ROW
+          && t->label_axis[PIVOT_AXIS_COLUMN] != PIVOT_AXIS_COLUMN)
         {
           msg (SE, _("ROWLABELS and COLLABELS may not both be specified."));
           goto error;
         }
 
+      if (!ctables_prepare_table (t))
+        goto error;
     }
   while (lex_token (lexer) != T_ENDCMD);