X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Fctables.c;h=af53a6b6c53643a9d577a0b06a01d43e5db06880;hb=b5deaec1f396fdb01dfddeef54f2c5aadb293121;hp=8277a702b28a165150f1191c0795aa763b1b761c;hpb=ad65d486079abfef4bd526beb36a94edf751cd7b;p=pspp

diff --git a/src/language/stats/ctables.c b/src/language/stats/ctables.c
index 8277a702b2..af53a6b6c5 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"
@@ -165,25 +166,40 @@ struct ctables_domain
   {
     struct hmap_node node;
 
-    const struct ctables_freq *example;
+    const struct ctables_cell *example;
 
     double valid;
     double missing;
   };
 
-struct ctables_freq
+enum ctables_summary_variant
   {
-    /* In struct ctables's 'ft' hmap.  Indexed by all the values in all the
+    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
        axes (except the scalar variable, if any). */
     struct hmap_node node;
 
-    /* The domains that contains this cell. */
+    /* The domains that contain this cell. */
     struct ctables_domain *domains[N_CTDTS];
 
+    bool hide;
+    enum ctables_summary_variant sv;
+
     struct
       {
-        size_t vaa_idx;
-        union value *values;
+        size_t nest_idx;
+        struct ctables_cell_value
+          {
+            const struct ctables_category *category;
+            union value value;
+          }
+        *cvs;
         int leaf;
       }
     axes[PIVOT_N_AXES];
@@ -262,14 +278,21 @@ struct ctables_postcompute_expr
       };
   };
 
-enum ctables_label_position
+struct ctables_summary_spec_set
   {
-    CTLP_NORMAL,
-    CTLP_OPPOSITE,
-    CTLP_LAYER,
+    struct ctables_summary_spec *specs;
+    size_t n;
+    size_t allocated;
+
+    struct variable *var;
   };
 
-struct var_array
+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 *);
+
+/* A nested sequence of variables, e.g. a > b > c. */
+struct ctables_nest
   {
     struct variable **vars;
     size_t n;
@@ -277,30 +300,51 @@ struct var_array
     size_t *domains[N_CTDTS];
     size_t n_domains[N_CTDTS];
 
-    struct ctables_summary_spec *summaries;
-    size_t n_summaries;
-    struct variable *summary_var;
+    struct ctables_summary_spec_set specs[N_CSVS];
   };
 
-struct var_array2
+/* 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 var_array2 vaas[PIVOT_N_AXES];
+    struct ctables_stack stacks[PIVOT_N_AXES];
     enum pivot_axis_type summary_axis;
-    struct hmap ft;
+    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;
@@ -343,77 +387,123 @@ ctables_var_name (const struct ctables_var *var)
 struct ctables_categories
   {
     size_t n_refs;
-
-    /* Explicit categories. */
-    struct ctables_cat_value *values;
-    size_t n_values;
-
-    /* Implicit categories. */
-    bool sort_ascending;
-    bool include_missing;
-    enum { CTCS_VALUE, CTCS_LABEL, CTCS_FUNCTION } key;
-    enum ctables_summary_function sort_func;
-    struct variable *sort_func_var;
-    double percentile;
-
-    /* Totals. */
-    bool show_totals;
-    bool totals_before;
-    char *total_label;
-
-    /* Empty categories. */
+    struct ctables_category *cats;
+    size_t n_cats;
     bool show_empty;
   };
 
-struct ctables_cat_value
+struct ctables_category
   {
-    enum ctables_cat_value_type
+    enum ctables_category_type
       {
-        CCVT_NUMBER,
-        CCVT_STRING,
-        CCVT_RANGE,
-        CCVT_MISSING,
-        CCVT_OTHERNM,
-        CCVT_SUBTOTAL,
-        CCVT_HSUBTOTAL,
+        CCT_NUMBER,
+        CCT_STRING,
+        CCT_RANGE,
+        CCT_MISSING,
+        CCT_OTHERNM,
+
+        CCT_SUBTOTAL,
+        CCT_HSUBTOTAL,
+        CCT_TOTAL,
+
+        CCT_VALUE,
+        CCT_LABEL,
+        CCT_FUNCTION,
       }
     type;
 
+    struct ctables_category *subtotal;
+
     union
       {
-        double number;          /* CCVT_NUMBER. */
-        char *string;           /* CCVT_STRING. */
-        double range[2];        /* CCVT_RANGE. */
-        char *subtotal_label;   /* CCVT_SUBTOTAL, CCVT_HSUBTOTAL. */
+        double number;          /* CCT_NUMBER. */
+        char *string;           /* CCT_STRING. */
+        double range[2];        /* CCT_RANGE. */
+        char *total_label;   /* CCT_SUBTOTAL, CCT_HSUBTOTAL, CCT_TOTAL. */
+
+        /* CCT_VALUE, CCT_LABEL, CCT_FUNCTION. */
+        struct
+          {
+            bool include_missing;
+            bool sort_ascending;
+
+            /* CCT_FUNCTION. */
+            enum ctables_summary_function sort_function;
+            struct variable *sort_var;
+            double percentile;
+          };
       };
   };
 
-static const struct ctables_cat_value *ctables_categories_match (
-  const struct ctables_categories *, const union value *,
-  const struct variable *);
-
 static void
-ctables_cat_value_uninit (struct ctables_cat_value *cv)
+ctables_category_uninit (struct ctables_category *cat)
 {
-  if (!cv)
+  if (!cat)
     return;
 
-  switch (cv->type)
+  switch (cat->type)
     {
-    case CCVT_NUMBER:
-    case CCVT_RANGE:
-    case CCVT_MISSING:
-    case CCVT_OTHERNM:
+    case CCT_NUMBER:
+    case CCT_RANGE:
+    case CCT_MISSING:
+    case CCT_OTHERNM:
+      break;
+
+    case CCT_STRING:
+      free (cat->string);
+      break;
+
+    case CCT_SUBTOTAL:
+    case CCT_HSUBTOTAL:
+    case CCT_TOTAL:
+      free (cat->total_label);
       break;
 
-    case CCVT_STRING:
-      free (cv->string);
+    case CCT_VALUE:
+    case CCT_LABEL:
+    case CCT_FUNCTION:
       break;
+    }
+}
+
+static bool
+ctables_category_equal (const struct ctables_category *a,
+                        const struct ctables_category *b)
+{
+  if (a->type != b->type)
+    return false;
 
-    case CCVT_SUBTOTAL:
-    case CCVT_HSUBTOTAL:
-      free (cv->subtotal_label);
+  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
@@ -426,13 +516,26 @@ ctables_categories_unref (struct ctables_categories *c)
   if (--c->n_refs)
     return;
 
-  for (size_t i = 0; i < c->n_values; i++)
-    ctables_cat_value_uninit (&c->values[i]);
-  free (c->values);
-  free (c->total_label);
+  for (size_t i = 0; i < c->n_cats; i++)
+    ctables_category_uninit (&c->cats[i]);
+  free (c->cats);
   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
   {
@@ -475,9 +578,7 @@ struct ctables_axis
           {
             struct ctables_var var;
             bool scale;
-            struct ctables_summary_spec *summaries;
-            size_t n_summaries;
-            size_t allocated_summaries;
+            struct ctables_summary_spec_set specs[N_CSVS];
           };
 
         /* Nonterminals. */
@@ -509,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)
 {
@@ -518,6 +628,30 @@ 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->specs[i]);
+  free (set->specs);
+}
+
 static bool
 parse_col_width (struct lexer *lexer, const char *name, double *width)
 {
@@ -611,9 +745,8 @@ ctables_axis_destroy (struct ctables_axis *axis)
   switch (axis->op)
     {
     case CTAO_VAR:
-      for (size_t i = 0; i < axis->n_summaries; i++)
-        ctables_summary_spec_uninit (&axis->summaries[i]);
-      free (axis->summaries);
+      for (size_t i = 0; i < N_CSVS; i++)
+        ctables_summary_spec_set_uninit (&axis->specs[i]);
       break;
 
     case CTAO_STACK:
@@ -704,15 +837,10 @@ 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)
+                  const struct msg_location *loc, enum ctables_summary_variant sv)
 {
   if (axis->op == CTAO_VAR)
     {
-      if (axis->n_summaries >= axis->allocated_summaries)
-        axis->summaries = x2nrealloc (axis->summaries,
-                                      &axis->allocated_summaries,
-                                      sizeof *axis->summaries);
-
       const char *function_name = ctables_summary_function_name (function);
       const char *var_name = ctables_var_name (&axis->var);
       switch (ctables_function_availability (function))
@@ -744,7 +872,12 @@ add_summary_spec (struct ctables_axis *axis,
           break;
         }
 
-      struct ctables_summary_spec *dst = &axis->summaries[axis->n_summaries++];
+      struct ctables_summary_spec_set *set = &axis->specs[sv];
+      if (set->n >= set->allocated)
+        set->specs = x2nrealloc (set->specs, &set->allocated,
+                                 sizeof *set->specs);
+
+      struct ctables_summary_spec *dst = &set->specs[set->n++];
       *dst = (struct ctables_summary_spec) {
         .function = function,
         .percentile = percentile,
@@ -758,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))
+                               format, loc, sv))
           return false;
       return true;
     }
@@ -832,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)
 {
@@ -839,7 +978,8 @@ ctables_axis_parse_postfix (struct ctables_axis_parse_ctx *ctx)
   if (!sub || !lex_match (ctx->lexer, T_LBRACK))
     return sub;
 
-  do
+  enum ctables_summary_variant sv = CSV_CELL;
+  for (;;)
     {
       int start_ofs = lex_ofs (ctx->lexer);
 
@@ -871,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)
@@ -887,15 +1028,24 @@ 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);
+      add_summary_spec (sub, function, percentile, label, formatp, loc, sv);
       free (label);
       msg_location_destroy (loc);
 
       lex_match (ctx->lexer, T_COMMA);
+      if (sv == CSV_CELL && lex_match_id (ctx->lexer, "TOTALS"))
+        {
+          if (!lex_force_match (ctx->lexer, T_LBRACK))
+            goto error;
+          sv = CSV_TOTAL;
+        }
+      else if (lex_match (ctx->lexer, T_RBRACK))
+        {
+          if (sv == CSV_TOTAL && !lex_force_match (ctx->lexer, T_RBRACK))
+            goto error;
+          return sub;
+        }
     }
-  while (!lex_match (ctx->lexer, T_RBRACK));
-
-  return sub;
 
 error:
   ctables_axis_destroy (sub);
@@ -935,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->n_summaries ? axis : NULL;
+    return !axis->scale && axis->specs[CSV_CELL].n ? axis : NULL;
   else
     {
       for (size_t i = 0; i < 2; i++)
@@ -1085,11 +1235,11 @@ ctables_destroy (struct ctables *ct)
   free (ct);
 }
 
-static struct ctables_cat_value
-ccvt_range (double low, double high)
+static struct ctables_category
+cct_range (double low, double high)
 {
-  return (struct ctables_cat_value) {
-    .type = CCVT_RANGE,
+  return (struct ctables_category) {
+    .type = CCT_RANGE,
     .range = { low, high }
   };
 }
@@ -1118,31 +1268,30 @@ ctables_table_parse_categories (struct lexer *lexer, struct dictionary *dict,
     }
   free (vars);
 
+  size_t allocated_cats = 0;
   if (lex_match (lexer, T_LBRACK))
     {
-      size_t allocated_values = 0;
       do
         {
-          if (c->n_values >= allocated_values)
-            c->values = x2nrealloc (c->values, &allocated_values,
-                                    sizeof *c->values);
+          if (c->n_cats >= allocated_cats)
+            c->cats = x2nrealloc (c->cats, &allocated_cats, sizeof *c->cats);
 
-          struct ctables_cat_value *v = &c->values[c->n_values];
+          struct ctables_category *cat = &c->cats[c->n_cats];
           if (lex_match_id (lexer, "OTHERNM"))
-            v->type = CCVT_OTHERNM;
+            cat->type = CCT_OTHERNM;
           else if (lex_match_id (lexer, "MISSING"))
-            v->type = CCVT_MISSING;
+            cat->type = CCT_MISSING;
           else if (lex_match_id (lexer, "SUBTOTAL"))
-            *v = (struct ctables_cat_value)
-              { .type = CCVT_SUBTOTAL, .subtotal_label = NULL };
+            *cat = (struct ctables_category)
+              { .type = CCT_SUBTOTAL, .total_label = NULL };
           else if (lex_match_id (lexer, "HSUBTOTAL"))
-            *v = (struct ctables_cat_value)
-              { .type = CCVT_HSUBTOTAL, .subtotal_label = NULL };
+            *cat = (struct ctables_category)
+              { .type = CCT_HSUBTOTAL, .total_label = NULL };
           else if (lex_match_id (lexer, "LO"))
             {
               if (!lex_force_match_id (lexer, "THRU") || lex_force_num (lexer))
                 return false;
-              *v = ccvt_range (-DBL_MAX, lex_number (lexer));
+              *cat = cct_range (-DBL_MAX, lex_number (lexer));
               lex_get (lexer);
             }
           else if (lex_is_number (lexer))
@@ -1151,28 +1300,28 @@ ctables_table_parse_categories (struct lexer *lexer, struct dictionary *dict,
               lex_get (lexer);
               if (lex_match_id (lexer, "THRU"))
                 {
-                  v->type = CCVT_RANGE;
-                  v->range[0] = number;
+                  cat->type = CCT_RANGE;
+                  cat->range[0] = number;
                   if (lex_match_id (lexer, "HI"))
-                    *v = ccvt_range (number, DBL_MAX);
+                    *cat = cct_range (number, DBL_MAX);
                   else
                     {
                       if (!lex_force_num (lexer))
                         return false;
-                      *v = ccvt_range (number, lex_number (lexer));
+                      *cat = cct_range (number, lex_number (lexer));
                       lex_get (lexer);
                     }
                 }
               else
-                *v = (struct ctables_cat_value) {
-                  .type = CCVT_NUMBER,
+                *cat = (struct ctables_category) {
+                  .type = CCT_NUMBER,
                   .number = number
                 };
             }
           else if (lex_is_string (lexer))
             {
-              *v = (struct ctables_cat_value) {
-                .type = CCVT_STRING,
+              *cat = (struct ctables_category) {
+                .type = CCT_STRING,
                 .string = ss_xstrdup (lex_tokss (lexer)),
               };
               lex_get (lexer);
@@ -1183,69 +1332,81 @@ ctables_table_parse_categories (struct lexer *lexer, struct dictionary *dict,
               return false;
             }
 
-          if ((v->type == CCVT_SUBTOTAL || v->type == CCVT_HSUBTOTAL)
-              && lex_match (lexer, T_EQUALS))
+          if (cat->type == CCT_SUBTOTAL || cat->type == CCT_HSUBTOTAL)
             {
-              if (!lex_force_string (lexer))
-                return false;
+              if (lex_match (lexer, T_EQUALS))
+                {
+                  if (!lex_force_string (lexer))
+                    return false;
 
-              v->subtotal_label = ss_xstrdup (lex_tokss (lexer));
-              lex_get (lexer);
+                  cat->total_label = ss_xstrdup (lex_tokss (lexer));
+                  lex_get (lexer);
+                }
+              else
+                cat->total_label = xstrdup (_("Subtotal"));
             }
 
-          c->n_values++;
+          c->n_cats++;
           lex_match (lexer, T_COMMA);
         }
       while (!lex_match (lexer, T_RBRACK));
     }
 
+  struct ctables_category cat = {
+    .type = CCT_VALUE,
+    .include_missing = false,
+    .sort_ascending = true,
+  };
+  bool show_totals = false;
+  char *total_label = NULL;
+  bool totals_before = false;
   while (lex_token (lexer) != T_SLASH && lex_token (lexer) != T_ENDCMD)
     {
-      if (!c->n_values && lex_match_id (lexer, "ORDER"))
+      if (!c->n_cats && lex_match_id (lexer, "ORDER"))
         {
           lex_match (lexer, T_EQUALS);
           if (lex_match_id (lexer, "A"))
-            c->sort_ascending = true;
+            cat.sort_ascending = true;
           else if (lex_match_id (lexer, "D"))
-            c->sort_ascending = false;
+            cat.sort_ascending = false;
           else
             {
               lex_error_expecting (lexer, "A", "D");
               return false;
             }
         }
-      else if (!c->n_values && lex_match_id (lexer, "KEY"))
+      else if (!c->n_cats && lex_match_id (lexer, "KEY"))
         {
           lex_match (lexer, T_EQUALS);
           if (lex_match_id (lexer, "VALUE"))
-            c->key = CTCS_VALUE;
+            cat.type = CCT_VALUE;
           else if (lex_match_id (lexer, "LABEL"))
-            c->key = CTCS_LABEL;
+            cat.type = CCT_LABEL;
           else
             {
-              c->key = CTCS_FUNCTION;
-              if (!parse_ctables_summary_function (lexer, &c->sort_func))
+              cat.type = CCT_FUNCTION;
+              if (!parse_ctables_summary_function (lexer, &cat.sort_function))
                 return false;
 
               if (lex_match (lexer, T_LPAREN))
                 {
-                  c->sort_func_var = parse_variable (lexer, dict);
-                  if (!c->sort_func_var)
+                  cat.sort_var = parse_variable (lexer, dict);
+                  if (!cat.sort_var)
                     return false;
 
-                  if (c->sort_func == CTSF_PTILE)
+                  if (cat.sort_function == CTSF_PTILE)
                     {
                       lex_match (lexer, T_COMMA);
                       if (!lex_force_num_range_closed (lexer, "PTILE", 0, 100))
                         return false;
-                      c->percentile = lex_number (lexer);
+                      cat.percentile = lex_number (lexer);
                       lex_get (lexer);
                     }
 
                   if (!lex_force_match (lexer, T_RPAREN))
                     return false;
                 }
-              else if (ctables_function_availability (c->sort_func)
+              else if (ctables_function_availability (cat.sort_function)
                        == CTFA_SCALE)
                 {
                   bool UNUSED b = lex_force_match (lexer, T_LPAREN);
@@ -1253,13 +1414,13 @@ ctables_table_parse_categories (struct lexer *lexer, struct dictionary *dict,
                 }
             }
         }
-      else if (!c->n_values && lex_match_id (lexer, "MISSING"))
+      else if (!c->n_cats && lex_match_id (lexer, "MISSING"))
         {
           lex_match (lexer, T_EQUALS);
           if (lex_match_id (lexer, "INCLUDE"))
-            c->include_missing = true;
+            cat.include_missing = true;
           else if (lex_match_id (lexer, "EXCLUDE"))
-            c->include_missing = false;
+            cat.include_missing = false;
           else
             {
               lex_error_expecting (lexer, "INCLUDE", "EXCLUDE");
@@ -1269,7 +1430,7 @@ ctables_table_parse_categories (struct lexer *lexer, struct dictionary *dict,
       else if (lex_match_id (lexer, "TOTAL"))
         {
           lex_match (lexer, T_EQUALS);
-          if (!parse_bool (lexer, &c->show_totals))
+          if (!parse_bool (lexer, &show_totals))
             return false;
         }
       else if (lex_match_id (lexer, "LABEL"))
@@ -1277,17 +1438,17 @@ ctables_table_parse_categories (struct lexer *lexer, struct dictionary *dict,
           lex_match (lexer, T_EQUALS);
           if (!lex_force_string (lexer))
             return false;
-          free (c->total_label);
-          c->total_label = ss_xstrdup (lex_tokss (lexer));
+          free (total_label);
+          total_label = ss_xstrdup (lex_tokss (lexer));
           lex_get (lexer);
         }
       else if (lex_match_id (lexer, "POSITION"))
         {
           lex_match (lexer, T_EQUALS);
           if (lex_match_id (lexer, "BEFORE"))
-            c->totals_before = true;
+            totals_before = true;
           else if (lex_match_id (lexer, "AFTER"))
-            c->totals_before = false;
+            totals_before = false;
           else
             {
               lex_error_expecting (lexer, "BEFORE", "AFTER");
@@ -1309,7 +1470,7 @@ ctables_table_parse_categories (struct lexer *lexer, struct dictionary *dict,
         }
       else
         {
-          if (!c->n_values)
+          if (!c->n_cats)
             lex_error_expecting (lexer, "ORDER", "KEY", "MISSING",
                                  "TOTAL", "LABEL", "POSITION", "EMPTY");
           else
@@ -1317,41 +1478,100 @@ ctables_table_parse_categories (struct lexer *lexer, struct dictionary *dict,
           return false;
         }
     }
+
+  if (!c->n_cats)
+    {
+      if (c->n_cats >= allocated_cats)
+        c->cats = x2nrealloc (c->cats, &allocated_cats,
+                                sizeof *c->cats);
+      c->cats[c->n_cats++] = cat;
+    }
+
+  if (show_totals)
+    {
+      if (c->n_cats >= allocated_cats)
+        c->cats = x2nrealloc (c->cats, &allocated_cats, sizeof *c->cats);
+
+      struct ctables_category *totals;
+      if (totals_before)
+        {
+          insert_element (c->cats, c->n_cats, sizeof *c->cats, 0);
+          totals = &c->cats[0];
+        }
+      else
+        totals = &c->cats[c->n_cats];
+      c->n_cats++;
+
+      *totals = (struct ctables_category) {
+        .type = CCT_TOTAL,
+        .total_label = total_label ? total_label : xstrdup (_("Total")),
+      };
+    }
+
+  struct ctables_category *subtotal = NULL;
+  for (size_t i = totals_before ? 0 : c->n_cats;
+       totals_before ? i < c->n_cats : i-- > 0;
+       totals_before ? i++ : 0)
+    {
+      struct ctables_category *cat = &c->cats[i];
+      switch (cat->type)
+        {
+        case CCT_NUMBER:
+        case CCT_STRING:
+        case CCT_RANGE:
+        case CCT_MISSING:
+        case CCT_OTHERNM:
+          cat->subtotal = subtotal;
+          break;
+
+        case CCT_SUBTOTAL:
+        case CCT_HSUBTOTAL:
+          subtotal = cat;
+          break;
+
+        case CCT_TOTAL:
+        case CCT_VALUE:
+        case CCT_LABEL:
+        case CCT_FUNCTION:
+          break;
+        }
+    }
+
   return true;
 }
 
 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
-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++)
+        ctables_nest_uninit (&stack->nests[i]);
+      free (stack->nests);
     }
 }
 
-static struct var_array2
-nest_fts (struct var_array2 va0, struct var_array2 va1)
+static struct ctables_stack
+nest_fts (struct ctables_stack s0, struct ctables_stack s1)
 {
-  if (!va0.n)
-    return va1;
-  else if (!va1.n)
-    return va0;
-
-  struct var_array2 vaa = { .vas = xnmalloc (va0.n, va1.n * sizeof *vaa.vas) };
-  for (size_t i = 0; i < va0.n; i++)
-    for (size_t j = 0; j < va1.n; j++)
+  if (!s0.n)
+    return s1;
+  else if (!s1.n)
+    return s0;
+
+  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);
@@ -1363,48 +1583,49 @@ nest_fts (struct var_array2 va0, struct var_array2 va1)
           vars[n++] = b->vars[k];
         assert (n == allocate);
 
-        const struct var_array *summary_src;
-        if (!a->summary_var)
+        const struct ctables_nest *summary_src;
+        if (!a->specs[CSV_CELL].var)
           summary_src = b;
-        else if (!b->summary_var)
+        else if (!b->specs[CSV_CELL].var)
           summary_src = a;
         else
           NOT_REACHED ();
-        vaa.vas[vaa.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,
-          .summaries = summary_src->summaries,
-          .n_summaries = summary_src->n_summaries,
-          .summary_var = summary_src->summary_var,
         };
+        for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++)
+          ctables_summary_spec_set_clone (&new->specs[sv], &summary_src->specs[sv]);
       }
-  var_array2_uninit (&va0);
-  var_array2_uninit (&va1);
-  return vaa;
+  ctables_stack_uninit (&s0);
+  ctables_stack_uninit (&s1);
+  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 = { .nests = xnmalloc (s0.n + s1.n, sizeof *stack.nests) };
+  for (size_t i = 0; i < s0.n; i++)
+    stack.nests[stack.n++] = s0.nests[i];
+  for (size_t i = 0; i < s1.n; i++)
+    stack.nests[stack.n++] = s1.nests[i];
+  assert (stack.n == s0.n + s1.n);
+  free (s0.nests);
+  free (s1.nests);
+  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)
     {
@@ -1414,19 +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->n_summaries || a->scale)
-        {
-          va->summaries = a->summaries;
-          va->n_summaries = a->n_summaries;
-          va->summary_var = a->var.var;
-        }
-      return (struct var_array2) { .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]),
@@ -1740,7 +1961,7 @@ ctables_summary_add (union ctables_summary *s,
 }
 
 static double
-ctables_summary_value (const struct ctables_freq *f,
+ctables_summary_value (const struct ctables_cell *cell,
                        union ctables_summary *s,
                        const struct ctables_summary_spec *ss)
 {
@@ -1751,25 +1972,25 @@ ctables_summary_value (const struct ctables_freq *f,
       return s->valid;
 
     case CTSF_SUBTABLEPCT_COUNT:
-      return f->domains[CTDT_SUBTABLE]->valid ? s->valid / f->domains[CTDT_SUBTABLE]->valid * 100 : SYSMIS;
+      return cell->domains[CTDT_SUBTABLE]->valid ? s->valid / cell->domains[CTDT_SUBTABLE]->valid * 100 : SYSMIS;
 
     case CTSF_ROWPCT_COUNT:
-      return f->domains[CTDT_ROW]->valid ? s->valid / f->domains[CTDT_ROW]->valid * 100 : SYSMIS;
+      return cell->domains[CTDT_ROW]->valid ? s->valid / cell->domains[CTDT_ROW]->valid * 100 : SYSMIS;
 
     case CTSF_COLPCT_COUNT:
-      return f->domains[CTDT_COL]->valid ? s->valid / f->domains[CTDT_COL]->valid * 100 : SYSMIS;
+      return cell->domains[CTDT_COL]->valid ? s->valid / cell->domains[CTDT_COL]->valid * 100 : SYSMIS;
 
     case CTSF_TABLEPCT_COUNT:
-      return f->domains[CTDT_TABLE]->valid ? s->valid / f->domains[CTDT_TABLE]->valid * 100 : SYSMIS;
+      return cell->domains[CTDT_TABLE]->valid ? s->valid / cell->domains[CTDT_TABLE]->valid * 100 : SYSMIS;
 
     case CTSF_LAYERPCT_COUNT:
-      return f->domains[CTDT_LAYER]->valid ? s->valid / f->domains[CTDT_LAYER]->valid * 100 : SYSMIS;
+      return cell->domains[CTDT_LAYER]->valid ? s->valid / cell->domains[CTDT_LAYER]->valid * 100 : SYSMIS;
 
     case CTSF_LAYERROWPCT_COUNT:
-      return f->domains[CTDT_LAYERROW]->valid ? s->valid / f->domains[CTDT_LAYERROW]->valid * 100 : SYSMIS;
+      return cell->domains[CTDT_LAYERROW]->valid ? s->valid / cell->domains[CTDT_LAYERROW]->valid * 100 : SYSMIS;
 
     case CTSF_LAYERCOLPCT_COUNT:
-      return f->domains[CTDT_LAYERCOL]->valid ? s->valid / f->domains[CTDT_LAYERCOL]->valid * 100 : SYSMIS;
+      return cell->domains[CTDT_LAYERCOL]->valid ? s->valid / cell->domains[CTDT_LAYERCOL]->valid * 100 : SYSMIS;
 
     case CTSF_ROWPCT_VALIDN:
     case CTSF_COLPCT_VALIDN:
@@ -1882,49 +2103,82 @@ ctables_summary_value (const struct ctables_freq *f,
   NOT_REACHED ();
 }
 
-struct ctables_freq_sort_aux
+struct ctables_cell_sort_aux
   {
     const struct ctables_table *t;
     enum pivot_axis_type a;
   };
 
 static int
-ctables_freq_compare_3way (const void *a_, const void *b_, const void *aux_)
+ctables_cell_compare_3way (const void *a_, const void *b_, const void *aux_)
 {
-  const struct ctables_freq_sort_aux *aux = aux_;
-  struct ctables_freq *const *ap = a_;
-  struct ctables_freq *const *bp = b_;
-  const struct ctables_freq *a = *ap;
-  const struct ctables_freq *b = *bp;
-
-  size_t a_idx = a->axes[aux->a].vaa_idx;
-  size_t b_idx = b->axes[aux->a].vaa_idx;
+  const struct ctables_cell_sort_aux *aux = aux_;
+  struct ctables_cell *const *ap = a_;
+  struct ctables_cell *const *bp = b_;
+  const struct ctables_cell *a = *ap;
+  const struct ctables_cell *b = *bp;
+
+  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->vaas[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 union value *val_a = &a->axes[aux->a].values[i];
-        const union value *val_b = &b->axes[aux->a].values[i];
-        int cmp = value_compare_3way (val_a, val_b, var_get_width (var));
-        if (!cmp)
-          continue;
-
-        const struct ctables_categories *cats = aux->t->categories[var_get_dict_index (var)];
-        if (cats && cats->n_values)
+        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)
+          return a_cv->category > b_cv->category ? 1 : -1;
+
+        const union value *a_val = &a_cv->value;
+        const union value *b_val = &b_cv->value;
+        switch (a_cv->category->type)
           {
-            const struct ctables_cat_value *a_cv = ctables_categories_match (cats, val_a, var);
-            const struct ctables_cat_value *b_cv = ctables_categories_match (cats, val_b, var);
-            assert (a_cv && b_cv);
-            return (a_cv == b_cv ? cmp
-                    : a_cv > b_cv ? 1
-                    : -1);
-          }
+          case CCT_NUMBER:
+          case CCT_STRING:
+          case CCT_SUBTOTAL:
+          case CCT_HSUBTOTAL:
+          case CCT_TOTAL:
+            /* Must be equal. */
+            continue;
+
+          case CCT_RANGE:
+          case CCT_MISSING:
+          case CCT_OTHERNM:
+            {
+              int cmp = value_compare_3way (a_val, b_val, var_get_width (var));
+              if (cmp)
+                return cmp;
+            }
+            break;
+
+          case CCT_VALUE:
+            {
+              int cmp = value_compare_3way (a_val, b_val, var_get_width (var));
+              if (cmp)
+                return a_cv->category->sort_ascending ? cmp : -cmp;
+            }
+            break;
+
+          case CCT_LABEL:
+            {
+              const char *a_label = var_lookup_value_label (var, a_val);
+              const char *b_label = var_lookup_value_label (var, b_val);
+              int cmp = (a_label
+                         ? (b_label ? strcmp (a_label, b_label) : 1)
+                         : (b_label ? -1 : value_compare_3way (
+                              a_val, b_val, var_get_width (var))));
+              if (cmp)
+                return a_cv->category->sort_ascending ? cmp : -cmp;
+            }
+            break;
 
-        return cmp;
+          case CCT_FUNCTION:
+            NOT_REACHED ();
+          }
       }
   return 0;
 }
@@ -1948,40 +2202,40 @@ ctables_freq_compare_3way (const void *a_, const void *b_, const void *aux_)
  */
 
 static struct ctables_domain *
-ctables_domain_insert (struct ctables_table *t, struct ctables_freq *f,
+ctables_domain_insert (struct ctables_table *t, struct ctables_cell *cell,
                        enum ctables_domain_type domain)
 {
   size_t hash = 0;
   for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
     {
-      size_t idx = f->axes[a].vaa_idx;
-      const struct var_array *va = &t->vaas[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];
-          hash = value_hash (&f->axes[a].values[v_idx],
-                             var_get_width (va->vars[v_idx]), hash);
+          size_t v_idx = nest->domains[domain][i];
+          hash = value_hash (&cell->axes[a].cvs[v_idx].value,
+                             var_get_width (nest->vars[v_idx]), hash);
         }
     }
 
   struct ctables_domain *d;
   HMAP_FOR_EACH_WITH_HASH (d, struct ctables_domain, node, hash, &t->domains[domain])
     {
-      const struct ctables_freq *df = d->example;
+      const struct ctables_cell *df = d->example;
       for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
         {
-          size_t idx = f->axes[a].vaa_idx;
-          if (idx != df->axes[a].vaa_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->vaas[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];
-              if (!value_equal (&df->axes[a].values[v_idx],
-                                &f->axes[a].values[v_idx],
-                                var_get_width (va->vars[v_idx])))
+              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 (nest->vars[v_idx])))
                 goto not_equal;
             }
         }
@@ -1991,459 +2245,936 @@ ctables_domain_insert (struct ctables_table *t, struct ctables_freq *f,
     }
 
   d = xmalloc (sizeof *d);
-  *d = (struct ctables_domain) { .example = f };
+  *d = (struct ctables_domain) { .example = cell };
   hmap_insert (&t->domains[domain], &d->node, hash);
   return d;
 }
 
-static const struct ctables_cat_value *
-ctables_categories_match (const struct ctables_categories *cats,
+static const struct ctables_category *
+ctables_categories_match (const struct ctables_categories *c,
                           const union value *v, const struct variable *var)
 {
-  const struct ctables_cat_value *othernm = NULL;
-  for (size_t i = cats->n_values; i-- > 0; )
+  const struct ctables_category *othernm = NULL;
+  for (size_t i = c->n_cats; i-- > 0; )
     {
-      const struct ctables_cat_value *cv = &cats->values[i];
-      switch (cv->type)
+      const struct ctables_category *cat = &c->cats[i];
+      switch (cat->type)
         {
-        case CCVT_NUMBER:
-          if (cv->number == v->f)
-            return cv;
+        case CCT_NUMBER:
+          if (cat->number == v->f)
+            return cat;
           break;
 
-        case CCVT_STRING:
+        case CCT_STRING:
           NOT_REACHED ();
 
-        case CCVT_RANGE:
-          if ((cv->range[0] == -DBL_MAX || v->f >= cv->range[0])
-              && (cv->range[1] == DBL_MAX || v->f <= cv->range[1]))
-            return cv;
+        case CCT_RANGE:
+          if ((cat->range[0] == -DBL_MAX || v->f >= cat->range[0])
+              && (cat->range[1] == DBL_MAX || v->f <= cat->range[1]))
+            return cat;
           break;
 
-        case CCVT_MISSING:
+        case CCT_MISSING:
           if (var_is_value_missing (var, v))
-            return cv;
+            return cat;
           break;
 
-        case CCVT_OTHERNM:
+        case CCT_OTHERNM:
           if (!othernm)
-            othernm = cv;
+            othernm = cat;
           break;
 
-        case CCVT_SUBTOTAL:
-        case CCVT_HSUBTOTAL:
+        case CCT_SUBTOTAL:
+        case CCT_HSUBTOTAL:
+        case CCT_TOTAL:
           break;
+
+        case CCT_VALUE:
+        case CCT_LABEL:
+        case CCT_FUNCTION:
+          return (cat->include_missing || !var_is_value_missing (var, v) ? cat
+                  : NULL);
         }
     }
 
   return var_is_value_missing (var, v) ? NULL : othernm;
 }
 
-static void
-ctables_freqtab_insert (struct ctables_table *t,
-                        const struct ccase *c,
-                        size_t ir, size_t ic, size_t il,
-                        double weight)
+static const struct ctables_category *
+ctables_categories_total (const struct ctables_categories *c)
 {
-  size_t ix[PIVOT_N_AXES] = {
-    [PIVOT_AXIS_ROW] = ir,
-    [PIVOT_AXIS_COLUMN] = ic,
-    [PIVOT_AXIS_LAYER] = il,
-  };
-  const struct var_array *ss = &t->vaas[t->summary_axis].vas[ix[t->summary_axis]];
-
-  for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
-    {
-      const struct var_array *va = &t->vaas[a].vas[ix[a]];
-      for (size_t i = 0; i < va->n; i++)
-        {
-          if (i == va->scale_idx)
-            continue;
-
-          const struct ctables_categories *cats = t->categories[var_get_dict_index (va->vars[i])];
-          if (!cats || !cats->n_values)
-            continue;
+  const struct ctables_category *first = &c->cats[0];
+  const struct ctables_category *last = &c->cats[c->n_cats - 1];
+  return (first->type == CCT_TOTAL ? first
+          : last->type == CCT_TOTAL ? last
+          : NULL);
+}
 
-          if (!ctables_categories_match (cats, case_data (c, va->vars[i]), va->vars[i]))
-            return;
-        }
-    }
+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])
+{
+  const struct ctables_nest *ss = &t->stacks[t->summary_axis].nests[ix[t->summary_axis]];
 
   size_t hash = 0;
+  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->vaas[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)
-          hash = value_hash (case_data (c, va->vars[i]),
-                             var_get_width (va->vars[i]), hash);
+      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, nest->vars[i]),
+                                 var_get_width (nest->vars[i]), hash);
+            else
+              sv = CSV_TOTAL;
+          }
     }
 
-  struct ctables_freq *f;
-  HMAP_FOR_EACH_WITH_HASH (f, struct ctables_freq, node, hash, &t->ft)
+  struct ctables_cell *cell;
+  HMAP_FOR_EACH_WITH_HASH (cell, struct ctables_cell, node, hash, &t->cells)
     {
       for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
         {
-          const struct var_array *va = &t->vaas[a].vas[ix[a]];
-          if (f->axes[a].vaa_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
-                && !value_equal (case_data (c, va->vars[i]),
-                                 &f->axes[a].values[i],
-                                 var_get_width (va->vars[i])))
+          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, nest->vars[i]),
+                                         &cell->axes[a].cvs[i].value,
+                                         var_get_width (nest->vars[i])))))
                 goto not_equal;
         }
 
-      goto summarize;
+      return cell;
 
     not_equal: ;
     }
 
-  f = xmalloc (sizeof *f);
+  cell = xmalloc (sizeof *cell);
+  cell->hide = false;
+  cell->sv = sv;
   for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
     {
-      const struct var_array *va = &t->vaas[a].vas[ix[a]];
-      f->axes[a].vaa_idx = ix[a];
-      f->axes[a].values = (va->n
-                           ? xnmalloc (va->n, sizeof *f->axes[a].values)
-                           : NULL);
-      for (size_t i = 0; i < va->n; i++)
-        value_clone (&f->axes[a].values[i], case_data (c, va->vars[i]),
-                     var_get_width (va->vars[i]));
+      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 < nest->n; i++)
+        {
+          if (i != nest->scale_idx)
+            {
+              const struct ctables_category *subtotal = cats[a][i]->subtotal;
+              if (subtotal && subtotal->type == CCT_HSUBTOTAL)
+                cell->hide = true;
+            }
+
+          cell->axes[a].cvs[i].category = cats[a][i];
+          value_clone (&cell->axes[a].cvs[i].value, case_data (c, nest->vars[i]),
+                       var_get_width (nest->vars[i]));
+        }
     }
-  f->summaries = xmalloc (ss->n_summaries * sizeof *f->summaries);
-  for (size_t i = 0; i < ss->n_summaries; i++)
-    ctables_summary_init (&f->summaries[i], &ss->summaries[i]);
-  for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++)
-    f->domains[dt] = ctables_domain_insert (t, f, dt);
-  hmap_insert (&t->ft, &f->node, hash);
 
-summarize:
-  for (size_t i = 0; i < ss->n_summaries; i++)
-    ctables_summary_add (&f->summaries[i], &ss->summaries[i], ss->summary_var,
-                         case_data (c, ss->summary_var), weight);
+  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++)
-    f->domains[dt]->valid += weight;
+    cell->domains[dt] = ctables_domain_insert (t, cell, dt);
+  hmap_insert (&t->cells, &cell->node, hash);
+  return cell;
 }
 
-static bool
-ctables_execute (struct dataset *ds, struct ctables *ct)
+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)
 {
-  for (size_t i = 0; i < ct->n_tables; i++)
-    {
-      struct ctables_table *t = ct->tables[i];
-      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]);
+  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]];
 
-            for (size_t j = 0; j < t->vaas[a].n; j++)
-              {
-                struct var_array *va = &t->vaas[a].vas[j];
-                for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++)
-                  {
-                    va->domains[dt] = xmalloc (va->n * sizeof *va->domains[dt]);
-                    va->n_domains[dt] = 0;
-
-                    for (size_t k = 0; k < va->n; k++)
-                      {
-                        if (k == va->scale_idx)
-                          continue;
+  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;
+}
 
-                        switch (dt)
-                          {
-                          case CTDT_TABLE:
-                            continue;
+static void
+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_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;
 
-                          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;
+          const struct variable *var = nest->vars[i];
 
-                          case CTDT_LAYERCOL:
-                            if (a == PIVOT_AXIS_ROW)
-                              continue;
-                            break;
-                          }
+          const struct ctables_category *total = ctables_categories_total (
+            t->categories[var_get_dict_index (var)]);
+          if (total)
+            {
+              const struct ctables_category *save = cats[a][i];
+              cats[a][i] = total;
+              ctables_cell_add__ (t, c, ix, cats, weight);
+              recurse_totals (t, c, ix, cats, weight, a, i + 1);
+              cats[a][i] = save;
+            }
+        }
+      start_nest = 0;
+    }
+}
 
-                        va->domains[dt][va->n_domains[dt]++] = k;
-                      }
-                  }
-              }
-          }
-        else
-          {
-            struct var_array *va = xmalloc (sizeof *va);
-            *va = (struct var_array) { .n = 0 };
-            t->vaas[a] = (struct var_array2) { .vas = va, .n = 1 };
-          }
+static void
+ctables_cell_insert (struct ctables_table *t,
+                     const struct ccase *c,
+                     size_t ir, size_t ic, size_t il,
+                     double weight)
+{
+  size_t ix[PIVOT_N_AXES] = {
+    [PIVOT_AXIS_ROW] = ir,
+    [PIVOT_AXIS_COLUMN] = ic,
+    [PIVOT_AXIS_LAYER] = il,
+  };
 
-      for (size_t i = 0; i < t->vaas[t->summary_axis].n; i++)
+  const struct ctables_category *cats[PIVOT_N_AXES][10];
+  for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
+    {
+      const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]];
+      for (size_t i = 0; i < nest->n; i++)
         {
-          struct var_array *va = &t->vaas[t->summary_axis].vas[i];
-          if (!va->n_summaries)
-            {
-              va->summaries = xmalloc (sizeof *va->summaries);
-              va->n_summaries = 1;
+          if (i == nest->scale_idx)
+            continue;
 
-              enum ctables_summary_function function
-                = va->summary_var ? CTSF_MEAN : CTSF_COUNT;
-              struct ctables_var var = { .is_mrset = false, .var = va->summary_var };
+          const struct variable *var = nest->vars[i];
+          const union value *value = case_data (c, var);
 
-              *va->summaries = (struct ctables_summary_spec) {
-                .function = function,
-                .format = ctables_summary_default_format (function, &var),
-                .label = ctables_summary_default_label (function, 0),
-              };
-              if (!va->summary_var)
-                va->summary_var = va->vars[0];
-            }
+          if (var_is_numeric (var) && value->f == SYSMIS)
+            return;
+
+          cats[a][i] = ctables_categories_match (
+            t->categories[var_get_dict_index (var)], value, var);
+          if (!cats[a][i])
+            return;
         }
     }
 
-  struct casereader *input = casereader_create_filter_weight (proc_open (ds),
-                                                              dataset_dict (ds),
-                                                              NULL, NULL);
-  bool warn_on_invalid = true;
-  double total_weight = 0;
-  for (struct ccase *c = casereader_read (input); c;
-       case_unref (c), c = casereader_read (input))
-    {
-      double weight = dict_get_case_weight (dataset_dict (ds), c,
-                                            &warn_on_invalid);
-      total_weight += weight;
+  ctables_cell_add__ (t, c, ix, cats, weight);
 
-      for (size_t i = 0; i < ct->n_tables; i++)
+  recurse_totals (t, c, ix, cats, weight, 0, 0);
+
+  for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
+    {
+      const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]];
+      for (size_t i = 0; i < nest->n; i++)
         {
-          struct ctables_table *t = ct->tables[i];
+          if (i == nest->scale_idx)
+            continue;
 
-          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++)
-                ctables_freqtab_insert (t, c, ir, ic, il, weight);
+          const struct ctables_category *save = cats[a][i];
+          if (save->subtotal)
+            {
+              cats[a][i] = save->subtotal;
+              ctables_cell_add__ (t, c, ix, cats, weight);
+              cats[a][i] = save;
+            }
         }
     }
-  casereader_destroy (input);
+}
 
-  for (size_t i = 0; i < ct->n_tables; i++)
-    {
-      struct ctables_table *t = ct->tables[i];
+struct merge_item
+  {
+    const struct ctables_summary_spec_set *set;
+    size_t ofs;
+  };
 
-      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"))),
-        NULL);
-      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;
+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);
+}
 
-          assert (t->axes[a]);
+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));
+}
 
-          struct ctables_freq **sorted = xnmalloc (t->ft.count, sizeof *sorted);
+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;
+}
 
-          struct ctables_freq *f;
-          size_t n = 0;
-          HMAP_FOR_EACH (f, struct ctables_freq, node, &t->ft)
-            sorted[n++] = f;
-          assert (n == t->ft.count);
+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));
+}
 
-          struct ctables_freq_sort_aux aux = { .t = t, .a = a };
-          sort (sorted, n, sizeof *sorted, ctables_freq_compare_3way, &aux);
+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;
+  if (summary_dimension)
+    {
+      struct pivot_dimension *d = pivot_dimension_create (
+        pt, t->slabels_axis, N_("Summaries"));
+      const struct ctables_summary_spec_set *specs = &t->summary_specs;
+      for (size_t i = 0; i < specs->n; i++)
+        pivot_category_create_leaf (
+          d->root, pivot_value_new_text (specs->specs[i].label));
+    }
 
-          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;
+  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));
+        }
+    }
 
-          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++)
+  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);
+      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
+        {
+          enum ctables_level_type
             {
-              struct ctables_freq *f = sorted[j];
-              const struct var_array *va = &t->vaas[a].vas[f->axes[a].vaa_idx];
+              CTL_VAR,          /* Variable label for nest->vars[var_idx]. */
+              CTL_CATEGORY,     /* Category for nest->vars[var_idx]. */
+              CTL_SUMMARY,      /* Summary functions. */
+            }
+          type;
+
+          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];
 
-              size_t n_common = 0;
-              bool new_subtable = false;
-              if (j > 0)
+          bool new_subtable = !prev || prev->axes[a].nest_idx != cell->axes[a].nest_idx;
+          if (new_subtable)
+            {
+              n_levels = 0;
+              printf ("%s levels:", pivot_axis_type_to_string (a));
+              for (size_t k = 0; k < nest->n; k++)
                 {
-                  struct ctables_freq *prev = sorted[j - 1];
-                  if (prev->axes[a].vaa_idx == f->axes[a].vaa_idx)
+                  enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (nest->vars[k])];
+                  if (vlabel != CTVL_NONE)
                     {
-                      for (; n_common < va->n; n_common++)
-                        if (n_common != va->scale_idx
-                            && !value_equal (&prev->axes[a].values[n_common],
-                                             &f->axes[a].values[n_common],
-                                             var_get_type (va->vars[n_common])))
-                          break;
+                      printf (" var(%s)", var_get_name (nest->vars[k]));
+                      levels[n_levels++] = (struct ctables_level) {
+                        .type = CTL_VAR,
+                        .var_idx = k,
+                      };
                     }
-                  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 (nest->scale_idx != k
+                      && (k != nest->n - 1 || t->label_axis[a] == a))
+                    {
+                      printf (" category(%s)", var_get_name (nest->vars[k]));
+                      levels[n_levels++] = (struct ctables_level) {
+                        .type = CTL_CATEGORY,
+                        .var_idx = k,
+                      };
+                    }
                 }
-              if (n_common == va->n)
+
+              if (a == t->slabels_axis && a == t->summary_axis)
                 {
-                  f->axes[a].leaf = prev_leaf;
-                  continue;
+                  printf (" summary");
+                  levels[n_levels++] = (struct ctables_level) {
+                    .type = CTL_SUMMARY,
+                    .var_idx = SIZE_MAX,
+                  };
                 }
+              printf ("\n");
+            }
 
-              for (size_t k = n_common; k < va->n; k++)
+          size_t n_common = 0;
+          if (!new_subtable)
+            {
+              for (; n_common < n_levels; n_common++)
                 {
-                  struct pivot_category *parent = k > 0 ? groups[k - 1] : top;
-
-                  struct pivot_value *label
-                    = (k != va->scale_idx
-                       ? pivot_value_new_var_value (va->vars[k],
-                                                    &f->axes[a].values[k])
-                       : NULL);
-                  if (k == va->n - 1)
+                  const struct ctables_level *level = &levels[n_common];
+                  if (level->type == CTL_CATEGORY)
                     {
-                      if (a == t->summary_axis)
+                      size_t var_idx = level->var_idx;
+                      if (prev->axes[a].cvs[var_idx].category
+                          != cell->axes[a].cvs[var_idx].category)
                         {
-                          if (label)
-                            parent = pivot_category_create_group__ (parent, label);
-                          for (size_t m = 0; m < va->n_summaries; m++)
-                            {
-                              int leaf = pivot_category_create_leaf (
-                                parent, pivot_value_new_text (va->summaries[m].label));
-                              if (m == 0)
-                                prev_leaf = leaf;
-                            }
+                          break;
                         }
-                      else
+                      else if (!value_equal (&prev->axes[a].cvs[var_idx].value,
+                                           &cell->axes[a].cvs[var_idx].value,
+                                             var_get_type (nest->vars[var_idx])))
                         {
-                          /* 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;
                         }
-                      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;
+          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 ();
 
-              f->axes[a].leaf = prev_leaf;
+                  if (k == n_levels - 1)
+                    prev_leaf = pivot_category_create_leaf (parent, label);
+                  else
+                    groups[k] = pivot_category_create_group__ (parent, label);
+                }
             }
-          free (sorted);
-          free (groups);
+
+          cell->axes[a].leaf = prev_leaf;
         }
-      struct ctables_freq *f;
-      HMAP_FOR_EACH (f, struct ctables_freq, node, &t->ft)
+      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++)
         {
-          const struct var_array *ss = &t->vaas[t->summary_axis].vas[f->axes[t->summary_axis].vaa_idx];
-          for (size_t j = 0; j < ss->n_summaries; j++)
+          size_t dindexes[5];
+          size_t n_dindexes = 0;
+
+          if (summary_dimension)
+            dindexes[n_dindexes++] = specs->specs[j].axis_idx;
+
+          if (categories_dimension)
             {
-              size_t dindexes[3];
-              size_t n_dindexes = 0;
+              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_check_label_position (struct ctables_table *t, enum pivot_axis_type a)
+{
+  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)
+    {
+      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 (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
-                if (d[a])
+        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++)
+              {
+                nest->domains[dt] = xmalloc (nest->n * sizeof *nest->domains[dt]);
+                nest->n_domains[dt] = 0;
+
+                for (size_t k = 0; k < nest->n; k++)
                   {
-                    int leaf = f->axes[a].leaf;
-                    if (a == t->summary_axis)
-                      leaf += j;
-                    dindexes[n_dindexes++] = leaf;
+                    if (k == nest->scale_idx)
+                      continue;
+
+                    switch (dt)
+                      {
+                      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 == nest->n - 1
+                                || (nest->scale_idx == nest->n - 1
+                                    && k == nest->n - 2))
+                              continue;
+                          }
+                        break;
+
+                      case CTDT_LAYERROW:
+                        if (a == PIVOT_AXIS_COLUMN)
+                          continue;
+                        break;
+
+                      case CTDT_LAYERCOL:
+                        if (a == PIVOT_AXIS_ROW)
+                          continue;
+                        break;
+                      }
+
+                    nest->domains[dt][nest->n_domains[dt]++] = k;
                   }
+              }
+          }
+      }
+    else
+      {
+        struct ctables_nest *nest = xmalloc (sizeof *nest);
+        *nest = (struct ctables_nest) { .n = 0 };
+        t->stacks[a] = (struct ctables_stack) { .nests = nest, .n = 1 };
+      }
 
-              double d = ctables_summary_value (f, &f->summaries[j], &ss->summaries[j]);
-              struct pivot_value *value = pivot_value_new_number (d);
-              value->numeric.format = ss->summaries[j].format;
-              pivot_table_put (pt, dindexes, n_dindexes, value);
-            }
+  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 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]);
+    }
 
-      pivot_table_submit (pt);
+  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] };
     }
 
-#if 0
-  for (size_t i = 0; i < ct->n_tables; i++)
+  while (n_left > 0)
     {
-      struct ctables_table *t = ct->tables[i];
+      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];
 
-      for (size_t j = 0; j < t->n_fts; j++)
+      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; )
         {
-          struct ctables_freqtab *ft = t->fts[j];
-          struct ctables_freq *f, *next;
-          HMAP_FOR_EACH_SAFE (f, next, struct ctables_freq, node, &ft->data)
+          if (merge_item_compare_3way (&items[j], &min) == 0)
             {
-              hmap_delete (&ft->data, &f->node);
-              for (size_t k = 0; k < ft->n_summaries; k++)
-                ctables_summary_uninit (&f->summaries[k], &ft->summaries[k]);
-              free (f->summaries);
-              for (size_t k = 0; k < ft->vars.n; k++)
+              struct merge_item *item = &items[j];
+              item->set->specs[item->ofs].axis_idx = merged->n - 1;
+              if (++item->ofs >= item->set->n)
                 {
-                  const struct variable *var = ft->vars.vars[k];
-                  value_destroy (&f->values[k], var_get_width (var));
+                  items[j] = items[--n_left];
+                  continue;
                 }
-              free (f);
             }
-          hmap_destroy (&ft->data);
-          var_array_uninit (&ft->vars);
-          free (ft);
+          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");
         }
-      free (t->fts);
     }
 #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);
+  bool warn_on_invalid = true;
+  double total_weight = 0;
+  for (struct ccase *c = casereader_read (input); c;
+       case_unref (c), c = casereader_read (input))
+    {
+      double weight = dict_get_case_weight (dataset_dict (ds), c,
+                                            &warn_on_invalid);
+      total_weight += weight;
+
+      for (size_t i = 0; i < ct->n_tables; i++)
+        {
+          struct ctables_table *t = ct->tables[i];
+
+          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);
+
+          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);
+
+  for (size_t i = 0; i < ct->n_tables; i++)
+    {
+      struct ctables_table *t = ct->tables[i];
+
+      if (t->clabels_example)
+        ctables_sort_clabels_values (t);
+
+      ctables_table_output (ct, ct->tables[i]);
+    }
   return proc_commit (ds);
 }
 
@@ -2659,16 +3390,40 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds)
         ct->tables = x2nrealloc (ct->tables, &allocated_tables,
                                  sizeof *ct->tables);
 
+      struct ctables_category *cat = xmalloc (sizeof *cat);
+      *cat = (struct ctables_category) {
+        .type = CCT_VALUE,
+        .include_missing = false,
+        .sort_ascending = true,
+      };
+
+      struct ctables_categories *c = xmalloc (sizeof *c);
+      size_t n_vars = dict_get_n_vars (dataset_dict (ds));
+      *c = (struct ctables_categories) {
+        .n_refs = n_vars,
+        .cats = cat,
+        .n_cats = 1,
+      };
+
+      struct ctables_categories **categories = xnmalloc (n_vars,
+                                                         sizeof *categories);
+      for (size_t i = 0; i < n_vars; i++)
+        categories[i] = c;
+
       struct ctables_table *t = xmalloc (sizeof *t);
       *t = (struct ctables_table) {
-        .ft = HMAP_INITIALIZER (t->ft),
-        .slabels_position = PIVOT_AXIS_COLUMN,
+        .cells = HMAP_INITIALIZER (t->cells),
+        .slabels_axis = PIVOT_AXIS_COLUMN,
         .slabels_visible = true,
-        .row_labels = CTLP_NORMAL,
-        .col_labels = CTLP_NORMAL,
-        .categories = xcalloc (dict_get_n_vars (dataset_dict (ds)),
-                               sizeof *t->categories),
-        .n_categories = dict_get_n_vars (dataset_dict (ds)),
+        .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,
       };
       for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++)
@@ -2754,7 +3509,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;
 
@@ -2762,17 +3521,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");
@@ -2794,17 +3553,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");
@@ -2815,9 +3577,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");
@@ -3087,14 +3849,20 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds)
                                    "SIGTEST", "COMPARETEST");
               goto error;
             }
+
+          if (!lex_match (lexer, T_SLASH))
+            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);