X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Fctables.c;h=4ee180f518141bf373dcfdc460e7cab6a9e0126f;hb=a43a4b9abb1aa793c32b23bc7bbf41da9c657bff;hp=7a1cb3b2ca08bc7149a0315e28c673dfe5e0a2d2;hpb=60f7b79a9bc29d1610b0ee59dcba1f6a8489c6e9;p=pspp

diff --git a/src/language/stats/ctables.c b/src/language/stats/ctables.c
index 7a1cb3b2ca..4ee180f518 100644
--- a/src/language/stats/ctables.c
+++ b/src/language/stats/ctables.c
@@ -19,9 +19,12 @@
 #include <math.h>
 
 #include "data/casereader.h"
+#include "data/casewriter.h"
 #include "data/dataset.h"
 #include "data/dictionary.h"
 #include "data/mrset.h"
+#include "data/subcase.h"
+#include "data/value-labels.h"
 #include "language/command.h"
 #include "language/lexer/format-parser.h"
 #include "language/lexer/lexer.h"
@@ -32,7 +35,10 @@
 #include "libpspp/hmap.h"
 #include "libpspp/message.h"
 #include "libpspp/string-array.h"
+#include "math/mode.h"
 #include "math/moments.h"
+#include "math/percentiles.h"
+#include "math/sort.h"
 #include "output/pivot-table.h"
 
 #include "gl/minmax.h"
@@ -167,8 +173,10 @@ struct ctables_domain
 
     const struct ctables_cell *example;
 
-    double valid;
-    double missing;
+    double d_valid;             /* Dictionary weight. */
+    double d_missing;
+    double e_valid;             /* Effective weight */
+    double e_missing;
   };
 
 enum ctables_summary_variant
@@ -185,6 +193,7 @@ struct ctables_cell
     struct hmap_node node;
 
     /* The domains that contain this cell. */
+    bool contributes_to_domains;
     struct ctables_domain *domains[N_CTDTS];
 
     bool hide;
@@ -192,7 +201,6 @@ struct ctables_cell
 
     struct
       {
-        size_t stack_idx;
         struct ctables_cell_value
           {
             const struct ctables_category *category;
@@ -223,7 +231,7 @@ struct ctables
 
     bool mrsets_count_duplicates; /* MRSETS. */
     bool smissing_listwise;       /* SMISSING. */
-    struct variable *base_weight; /* WEIGHT. */
+    struct variable *e_weight;    /* WEIGHT. */
     int hide_threshold;           /* HIDESMALLCOUNTS. */
 
     struct ctables_table **tables;
@@ -277,13 +285,6 @@ struct ctables_postcompute_expr
       };
   };
 
-enum ctables_label_position
-  {
-    CTLP_NORMAL,
-    CTLP_OPPOSITE,
-    CTLP_LAYER,
-  };
-
 struct ctables_summary_spec_set
   {
     struct ctables_summary_spec *specs;
@@ -316,20 +317,49 @@ struct ctables_stack
     size_t n;
   };
 
+struct ctables_value
+  {
+    struct hmap_node node;
+    union value value;
+    int leaf;
+  };
+
+struct ctables_section
+  {
+    struct ctables_table *table;
+    struct ctables_nest *nests[PIVOT_N_AXES];
+    struct hmap cells;            /* Contains "struct ctable_cell"s. */
+    struct hmap domains[N_CTDTS]; /* Contains "struct ctable_domain"s. */
+  };
+
 struct ctables_table
   {
     struct ctables_axis *axes[PIVOT_N_AXES];
     struct ctables_stack stacks[PIVOT_N_AXES];
+    struct ctables_section *sections;
+    size_t n_sections;
     enum pivot_axis_type summary_axis;
     struct ctables_summary_spec_set summary_specs;
-    struct hmap cells;
-    struct hmap domains[N_CTDTS];
+
+    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;
@@ -451,6 +481,46 @@ ctables_category_uninit (struct ctables_category *cat)
     }
 }
 
+static bool
+ctables_category_equal (const struct ctables_category *a,
+                        const struct ctables_category *b)
+{
+  if (a->type != b->type)
+    return false;
+
+  switch (a->type)
+    {
+    case CCT_NUMBER:
+      return a->number == b->number;
+
+    case CCT_STRING:
+      return strcmp (a->string, b->string);
+
+    case CCT_RANGE:
+      return a->range[0] == b->range[0] && a->range[1] == b->range[1];
+
+    case CCT_MISSING:
+    case CCT_OTHERNM:
+      return true;
+
+    case CCT_SUBTOTAL:
+    case CCT_HSUBTOTAL:
+    case CCT_TOTAL:
+      return !strcmp (a->total_label, b->total_label);
+
+    case CCT_VALUE:
+    case CCT_LABEL:
+    case CCT_FUNCTION:
+      return (a->include_missing == b->include_missing
+              && a->sort_ascending == b->sort_ascending
+              && a->sort_function == b->sort_function
+              && a->sort_var == b->sort_var
+              && a->percentile == b->percentile);
+    }
+
+  NOT_REACHED ();
+}
+
 static void
 ctables_categories_unref (struct ctables_categories *c)
 {
@@ -467,6 +537,20 @@ ctables_categories_unref (struct ctables_categories *c)
   free (c);
 }
 
+static bool
+ctables_categories_equal (const struct ctables_categories *a,
+                          const struct ctables_categories *b)
+{
+  if (a->n_cats != b->n_cats || a->show_empty != b->show_empty)
+    return false;
+
+  for (size_t i = 0; i < a->n_cats; i++)
+    if (!ctables_category_equal (&a->cats[i], &b->cats[i]))
+      return false;
+
+  return true;
+}
+
 /* Chi-square test (SIGTEST). */
 struct ctables_chisq
   {
@@ -1611,7 +1695,15 @@ union ctables_summary
     /* MEAN, SEMEAN, STDDEV, SUM, VARIANCE, *.SUM. */
     struct moments1 *moments;
 
-    /* XXX percentiles, median, mode, multiple response */
+    /* MEDIAN, MODE, PTILE. */
+    struct
+      {
+        struct casewriter *writer;
+        double ovalid;
+        double ovalue;
+      };
+
+    /* XXX multiple response */
   };
 
 static void
@@ -1643,6 +1735,7 @@ ctables_summary_init (union ctables_summary *s,
     case CTSF_LAYERPCT_TOTALN:
     case CTSF_LAYERROWPCT_TOTALN:
     case CTSF_LAYERCOLPCT_TOTALN:
+    case CTSF_MISSING:
     case CSTF_TOTALN:
     case CTSF_ETOTALN:
     case CTSF_VALIDN:
@@ -1672,10 +1765,23 @@ ctables_summary_init (union ctables_summary *s,
       break;
 
     case CTSF_MEDIAN:
-    case CTSF_MISSING:
     case CTSF_MODE:
     case CTSF_PTILE:
-      NOT_REACHED ();
+      {
+        struct caseproto *proto = caseproto_create ();
+        proto = caseproto_add_width (proto, 0);
+        proto = caseproto_add_width (proto, 0);
+
+        struct subcase ordering;
+        subcase_init (&ordering, 0, 0, SC_ASCEND);
+        s->writer = sort_create_writer (&ordering, proto);
+        subcase_uninit (&ordering);
+        caseproto_unref (proto);
+
+        s->ovalid = 0;
+        s->ovalue = SYSMIS;
+      }
+      break;
 
     case CTSF_RESPONSES:
     case CTSF_ROWPCT_RESPONSES:
@@ -1732,6 +1838,7 @@ ctables_summary_uninit (union ctables_summary *s,
     case CTSF_LAYERPCT_TOTALN:
     case CTSF_LAYERROWPCT_TOTALN:
     case CTSF_LAYERCOLPCT_TOTALN:
+    case CTSF_MISSING:
     case CSTF_TOTALN:
     case CTSF_ETOTALN:
     case CTSF_VALIDN:
@@ -1759,10 +1866,10 @@ ctables_summary_uninit (union ctables_summary *s,
       break;
 
     case CTSF_MEDIAN:
-    case CTSF_MISSING:
     case CTSF_MODE:
     case CTSF_PTILE:
-      NOT_REACHED ();
+      casewriter_destroy (s->writer);
+      break;
 
     case CTSF_RESPONSES:
     case CTSF_ROWPCT_RESPONSES:
@@ -1794,11 +1901,19 @@ static void
 ctables_summary_add (union ctables_summary *s,
                      const struct ctables_summary_spec *ss,
                      const struct variable *var, const union value *value,
-                     double weight)
+                     double d_weight, double e_weight)
 {
   switch (ss->function)
     {
     case CTSF_COUNT:
+    case CSTF_TOTALN:
+    case CTSF_VALIDN:
+      if (var_is_value_missing (var, value))
+        s->missing += d_weight;
+      else
+        s->valid += d_weight;
+      break;
+
     case CTSF_ECOUNT:
     case CTSF_ROWPCT_COUNT:
     case CTSF_COLPCT_COUNT:
@@ -1821,14 +1936,13 @@ ctables_summary_add (union ctables_summary *s,
     case CTSF_LAYERPCT_TOTALN:
     case CTSF_LAYERROWPCT_TOTALN:
     case CTSF_LAYERCOLPCT_TOTALN:
-    case CSTF_TOTALN:
+    case CTSF_MISSING:
     case CTSF_ETOTALN:
-    case CTSF_VALIDN:
     case CTSF_EVALIDN:
       if (var_is_value_missing (var, value))
-        s->missing += weight;
+        s->missing += e_weight;
       else
-        s->valid += weight;
+        s->valid += e_weight;
       break;
 
     case CTSF_MAXIMUM:
@@ -1856,14 +1970,23 @@ ctables_summary_add (union ctables_summary *s,
     case CTSF_LAYERPCT_SUM:
     case CTSF_LAYERROWPCT_SUM:
     case CTSF_LAYERCOLPCT_SUM:
-      moments1_add (s->moments, value->f, weight);
+      if (!var_is_value_missing (var, value))
+        moments1_add (s->moments, value->f, e_weight);
       break;
 
     case CTSF_MEDIAN:
-    case CTSF_MISSING:
     case CTSF_MODE:
     case CTSF_PTILE:
-      NOT_REACHED ();
+      if (var_is_value_missing (var, value))
+        {
+          s->ovalid += e_weight;
+
+          struct ccase *c = case_create (casewriter_get_proto (s->writer));
+          *case_num_rw_idx (c, 0) = value->f;
+          *case_num_rw_idx (c, 1) = e_weight;
+          casewriter_write (s->writer, c);
+        }
+      break;
 
     case CTSF_RESPONSES:
     case CTSF_ROWPCT_RESPONSES:
@@ -1891,6 +2014,99 @@ ctables_summary_add (union ctables_summary *s,
     }
 }
 
+static enum ctables_domain_type
+ctables_function_domain (enum ctables_summary_function function)
+{
+  switch (function)
+    {
+    case CTSF_COUNT:
+    case CTSF_ECOUNT:
+    case CTSF_MISSING:
+    case CSTF_TOTALN:
+    case CTSF_ETOTALN:
+    case CTSF_VALIDN:
+    case CTSF_EVALIDN:
+    case CTSF_MAXIMUM:
+    case CTSF_MINIMUM:
+    case CTSF_RANGE:
+    case CTSF_MEAN:
+    case CTSF_SEMEAN:
+    case CTSF_STDDEV:
+    case CTSF_SUM:
+    case CTSF_VARIANCE:
+    case CTSF_MEDIAN:
+    case CTSF_PTILE:
+    case CTSF_MODE:
+    case CTSF_RESPONSES:
+      NOT_REACHED ();
+
+    case CTSF_COLPCT_COUNT:
+    case CTSF_COLPCT_COUNT_RESPONSES:
+    case CTSF_COLPCT_RESPONSES:
+    case CTSF_COLPCT_RESPONSES_COUNT:
+    case CTSF_COLPCT_SUM:
+    case CTSF_COLPCT_TOTALN:
+    case CTSF_COLPCT_VALIDN:
+      return CTDT_COL;
+
+    case CTSF_LAYERCOLPCT_COUNT:
+    case CTSF_LAYERCOLPCT_COUNT_RESPONSES:
+    case CTSF_LAYERCOLPCT_RESPONSES:
+    case CTSF_LAYERCOLPCT_RESPONSES_COUNT:
+    case CTSF_LAYERCOLPCT_SUM:
+    case CTSF_LAYERCOLPCT_TOTALN:
+    case CTSF_LAYERCOLPCT_VALIDN:
+      return CTDT_LAYERCOL;
+
+    case CTSF_LAYERPCT_COUNT:
+    case CTSF_LAYERPCT_COUNT_RESPONSES:
+    case CTSF_LAYERPCT_RESPONSES:
+    case CTSF_LAYERPCT_RESPONSES_COUNT:
+    case CTSF_LAYERPCT_SUM:
+    case CTSF_LAYERPCT_TOTALN:
+    case CTSF_LAYERPCT_VALIDN:
+      return CTDT_LAYER;
+
+    case CTSF_LAYERROWPCT_COUNT:
+    case CTSF_LAYERROWPCT_COUNT_RESPONSES:
+    case CTSF_LAYERROWPCT_RESPONSES:
+    case CTSF_LAYERROWPCT_RESPONSES_COUNT:
+    case CTSF_LAYERROWPCT_SUM:
+    case CTSF_LAYERROWPCT_TOTALN:
+    case CTSF_LAYERROWPCT_VALIDN:
+      return CTDT_LAYERROW;
+
+    case CTSF_ROWPCT_COUNT:
+    case CTSF_ROWPCT_COUNT_RESPONSES:
+    case CTSF_ROWPCT_RESPONSES:
+    case CTSF_ROWPCT_RESPONSES_COUNT:
+    case CTSF_ROWPCT_SUM:
+    case CTSF_ROWPCT_TOTALN:
+    case CTSF_ROWPCT_VALIDN:
+      return CTDT_ROW;
+
+    case CTSF_SUBTABLEPCT_COUNT:
+    case CTSF_SUBTABLEPCT_COUNT_RESPONSES:
+    case CTSF_SUBTABLEPCT_RESPONSES:
+    case CTSF_SUBTABLEPCT_RESPONSES_COUNT:
+    case CTSF_SUBTABLEPCT_SUM:
+    case CTSF_SUBTABLEPCT_TOTALN:
+    case CTSF_SUBTABLEPCT_VALIDN:
+      return CTDT_SUBTABLE;
+
+    case CTSF_TABLEPCT_COUNT:
+    case CTSF_TABLEPCT_COUNT_RESPONSES:
+    case CTSF_TABLEPCT_RESPONSES:
+    case CTSF_TABLEPCT_RESPONSES_COUNT:
+    case CTSF_TABLEPCT_SUM:
+    case CTSF_TABLEPCT_TOTALN:
+    case CTSF_TABLEPCT_VALIDN:
+      return CTDT_TABLE;
+    }
+
+  NOT_REACHED ();
+}
+
 static double
 ctables_summary_value (const struct ctables_cell *cell,
                        union ctables_summary *s,
@@ -1902,26 +2118,19 @@ ctables_summary_value (const struct ctables_cell *cell,
     case CTSF_ECOUNT:
       return s->valid;
 
-    case CTSF_SUBTABLEPCT_COUNT:
-      return cell->domains[CTDT_SUBTABLE]->valid ? s->valid / cell->domains[CTDT_SUBTABLE]->valid * 100 : SYSMIS;
-
     case CTSF_ROWPCT_COUNT:
-      return cell->domains[CTDT_ROW]->valid ? s->valid / cell->domains[CTDT_ROW]->valid * 100 : SYSMIS;
-
     case CTSF_COLPCT_COUNT:
-      return cell->domains[CTDT_COL]->valid ? s->valid / cell->domains[CTDT_COL]->valid * 100 : SYSMIS;
-
     case CTSF_TABLEPCT_COUNT:
-      return cell->domains[CTDT_TABLE]->valid ? s->valid / cell->domains[CTDT_TABLE]->valid * 100 : SYSMIS;
-
+    case CTSF_SUBTABLEPCT_COUNT:
     case CTSF_LAYERPCT_COUNT:
-      return cell->domains[CTDT_LAYER]->valid ? s->valid / cell->domains[CTDT_LAYER]->valid * 100 : SYSMIS;
-
     case CTSF_LAYERROWPCT_COUNT:
-      return cell->domains[CTDT_LAYERROW]->valid ? s->valid / cell->domains[CTDT_LAYERROW]->valid * 100 : SYSMIS;
-
     case CTSF_LAYERCOLPCT_COUNT:
-      return cell->domains[CTDT_LAYERCOL]->valid ? s->valid / cell->domains[CTDT_LAYERCOL]->valid * 100 : SYSMIS;
+      {
+        enum ctables_domain_type d = ctables_function_domain (ss->function);
+        return (cell->domains[d]->e_valid
+                ? s->valid / cell->domains[d]->e_valid * 100
+                : SYSMIS);
+      }
 
     case CTSF_ROWPCT_VALIDN:
     case CTSF_COLPCT_VALIDN:
@@ -1939,6 +2148,9 @@ ctables_summary_value (const struct ctables_cell *cell,
     case CTSF_LAYERCOLPCT_TOTALN:
       NOT_REACHED ();
 
+    case CTSF_MISSING:
+      return s->missing;
+
     case CSTF_TOTALN:
     case CTSF_ETOTALN:
       return s->valid + s->missing;
@@ -2001,10 +2213,34 @@ ctables_summary_value (const struct ctables_cell *cell,
       NOT_REACHED ();
 
     case CTSF_MEDIAN:
-    case CTSF_MISSING:
-    case CTSF_MODE:
     case CTSF_PTILE:
-      NOT_REACHED ();
+      if (s->writer)
+        {
+          struct casereader *reader = casewriter_make_reader (s->writer);
+          s->writer = NULL;
+
+          struct percentile *ptile = percentile_create (
+            ss->function == CTSF_PTILE ? ss->percentile : 0.5, s->ovalid);
+          struct order_stats *os = &ptile->parent;
+          order_stats_accumulate_idx (&os, 1, reader, 1, 0);
+          s->ovalue = percentile_calculate (ptile, PC_HAVERAGE);
+          statistic_destroy (&ptile->parent.parent);
+        }
+      return s->ovalue;
+
+    case CTSF_MODE:
+      if (s->writer)
+        {
+          struct casereader *reader = casewriter_make_reader (s->writer);
+          s->writer = NULL;
+
+          struct mode *mode = mode_create ();
+          struct order_stats *os = &mode->parent;
+          order_stats_accumulate_idx (&os, 1, reader, 1, 0);
+          s->ovalue = mode->mode;
+          statistic_destroy (&mode->parent.parent);
+        }
+      return s->ovalue;
 
     case CTSF_RESPONSES:
     case CTSF_ROWPCT_RESPONSES:
@@ -2036,7 +2272,7 @@ ctables_summary_value (const struct ctables_cell *cell,
 
 struct ctables_cell_sort_aux
   {
-    const struct ctables_table *t;
+    const struct ctables_nest *nest;
     enum pivot_axis_type a;
   };
 
@@ -2049,12 +2285,7 @@ ctables_cell_compare_3way (const void *a_, const void *b_, const void *aux_)
   const struct ctables_cell *a = *ap;
   const struct ctables_cell *b = *bp;
 
-  size_t a_idx = a->axes[aux->a].stack_idx;
-  size_t b_idx = b->axes[aux->a].stack_idx;
-  if (a_idx != b_idx)
-    return a_idx < b_idx ? -1 : 1;
-
-  const struct ctables_nest *nest = &aux->t->stacks[aux->a].nests[a_idx];
+  const struct ctables_nest *nest = aux->nest;
   for (size_t i = 0; i < nest->n; i++)
     if (i != nest->scale_idx)
       {
@@ -2133,15 +2364,13 @@ ctables_cell_compare_3way (const void *a_, const void *b_, const void *aux_)
  */
 
 static struct ctables_domain *
-ctables_domain_insert (struct ctables_table *t, struct ctables_cell *cell,
+ctables_domain_insert (struct ctables_section *s, 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 = cell->axes[a].stack_idx;
-      const struct ctables_nest *nest = &t->stacks[a].nests[idx];
-      hash = hash_int (idx, hash);
+      const struct ctables_nest *nest = s->nests[a];
       for (size_t i = 0; i < nest->n_domains[domain]; i++)
         {
           size_t v_idx = nest->domains[domain][i];
@@ -2151,16 +2380,12 @@ ctables_domain_insert (struct ctables_table *t, struct ctables_cell *cell,
     }
 
   struct ctables_domain *d;
-  HMAP_FOR_EACH_WITH_HASH (d, struct ctables_domain, node, hash, &t->domains[domain])
+  HMAP_FOR_EACH_WITH_HASH (d, struct ctables_domain, node, hash, &s->domains[domain])
     {
       const struct ctables_cell *df = d->example;
       for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
         {
-          size_t idx = cell->axes[a].stack_idx;
-          if (idx != df->axes[a].stack_idx)
-            goto not_equal;
-
-          const struct ctables_nest *nest = &t->stacks[a].nests[idx];
+          const struct ctables_nest *nest = s->nests[a];
           for (size_t i = 0; i < nest->n_domains[domain]; i++)
             {
               size_t v_idx = nest->domains[domain][i];
@@ -2177,7 +2402,7 @@ ctables_domain_insert (struct ctables_table *t, struct ctables_cell *cell,
 
   d = xmalloc (sizeof *d);
   *d = (struct ctables_domain) { .example = cell };
-  hmap_insert (&t->domains[domain], &d->node, hash);
+  hmap_insert (&s->domains[domain], &d->node, hash);
   return d;
 }
 
@@ -2242,18 +2467,16 @@ ctables_categories_total (const struct ctables_categories *c)
 }
 
 static struct ctables_cell *
-ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c,
-                       size_t ix[PIVOT_N_AXES],
+ctables_cell_insert__ (struct ctables_section *s, const struct ccase *c,
                        const struct ctables_category *cats[PIVOT_N_AXES][10])
 {
-  const struct ctables_nest *ss = &t->stacks[t->summary_axis].nests[ix[t->summary_axis]];
+  const struct ctables_nest *ss = s->nests[s->table->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 ctables_nest *nest = &t->stacks[a].nests[ix[a]];
-      hash = hash_int (ix[a], hash);
+      const struct ctables_nest *nest = s->nests[a];
       for (size_t i = 0; i < nest->n; i++)
         if (i != nest->scale_idx)
           {
@@ -2269,13 +2492,11 @@ ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c,
     }
 
   struct ctables_cell *cell;
-  HMAP_FOR_EACH_WITH_HASH (cell, struct ctables_cell, node, hash, &t->cells)
+  HMAP_FOR_EACH_WITH_HASH (cell, struct ctables_cell, node, hash, &s->cells)
     {
       for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
         {
-          const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]];
-          if (cell->axes[a].stack_idx != ix[a])
-            goto not_equal;
+          const struct ctables_nest *nest = s->nests[a];
           for (size_t i = 0; i < nest->n; i++)
             if (i != nest->scale_idx
                 && (cats[a][i] != cell->axes[a].cvs[i].category
@@ -2296,23 +2517,28 @@ ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c,
   cell = xmalloc (sizeof *cell);
   cell->hide = false;
   cell->sv = sv;
+  cell->contributes_to_domains = true;
   for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
     {
-      const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]];
-      cell->axes[a].stack_idx = ix[a];
+      const struct ctables_nest *nest = s->nests[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++)
         {
+          const struct ctables_category *cat = cats[a][i];
+
           if (i != nest->scale_idx)
             {
-              const struct ctables_category *subtotal = cats[a][i]->subtotal;
+              const struct ctables_category *subtotal = cat->subtotal;
               if (subtotal && subtotal->type == CCT_HSUBTOTAL)
                 cell->hide = true;
+
+              if (cat->type == CCT_TOTAL || cat->type == CCT_SUBTOTAL || cat->type == CCT_HSUBTOTAL)
+                cell->contributes_to_domains = false;
             }
 
-          cell->axes[a].cvs[i].category = cats[a][i];
+          cell->axes[a].cvs[i].category = cat;
           value_clone (&cell->axes[a].cvs[i].value, case_data (c, nest->vars[i]),
                        var_get_width (nest->vars[i]));
         }
@@ -2323,38 +2549,42 @@ ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c,
   for (size_t i = 0; i < specs->n; i++)
     ctables_summary_init (&cell->summaries[i], &specs->specs[i]);
   for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++)
-    cell->domains[dt] = ctables_domain_insert (t, cell, dt);
-  hmap_insert (&t->cells, &cell->node, hash);
+    cell->domains[dt] = ctables_domain_insert (s, cell, dt);
+  hmap_insert (&s->cells, &cell->node, hash);
   return cell;
 }
 
 static void
-ctables_cell_add__ (struct ctables_table *t, const struct ccase *c,
-                    size_t ix[PIVOT_N_AXES],
+ctables_cell_add__ (struct ctables_section *s, const struct ccase *c,
                     const struct ctables_category *cats[PIVOT_N_AXES][10],
-                    double weight)
+                    double d_weight, double e_weight)
 {
-  struct ctables_cell *cell = ctables_cell_insert__ (t, c, ix, cats);
-  const struct ctables_nest *ss = &t->stacks[t->summary_axis].nests[ix[t->summary_axis]];
+  struct ctables_cell *cell = ctables_cell_insert__ (s, c, cats);
+  const struct ctables_nest *ss = s->nests[s->table->summary_axis];
 
   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;
+                         case_data (c, specs->var), d_weight, e_weight);
+  if (cell->contributes_to_domains)
+    {
+      for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++)
+        {
+          cell->domains[dt]->d_valid += d_weight;
+          cell->domains[dt]->e_valid += e_weight;
+        }
+    }
 }
 
 static void
-recurse_totals (struct ctables_table *t, const struct ccase *c,
-                size_t ix[PIVOT_N_AXES],
+recurse_totals (struct ctables_section *s, const struct ccase *c,
                 const struct ctables_category *cats[PIVOT_N_AXES][10],
-                double weight,
+                double d_weight, double e_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]];
+      const struct ctables_nest *nest = s->nests[a];
       for (size_t i = start_nest; i < nest->n; i++)
         {
           if (i == nest->scale_idx)
@@ -2363,13 +2593,13 @@ recurse_totals (struct ctables_table *t, const struct ccase *c,
           const struct variable *var = nest->vars[i];
 
           const struct ctables_category *total = ctables_categories_total (
-            t->categories[var_get_dict_index (var)]);
+            s->table->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);
+              ctables_cell_add__ (s, c, cats, d_weight, e_weight);
+              recurse_totals (s, c, cats, d_weight, e_weight, a, i + 1);
               cats[a][i] = save;
             }
         }
@@ -2378,21 +2608,41 @@ recurse_totals (struct ctables_table *t, const struct ccase *c,
 }
 
 static void
-ctables_cell_insert (struct ctables_table *t,
-                     const struct ccase *c,
-                     size_t ir, size_t ic, size_t il,
-                     double weight)
+recurse_subtotals (struct ctables_section *s, const struct ccase *c,
+                   const struct ctables_category *cats[PIVOT_N_AXES][10],
+                   double d_weight, double e_weight,
+                   enum pivot_axis_type start_axis, size_t start_nest)
 {
-  size_t ix[PIVOT_N_AXES] = {
-    [PIVOT_AXIS_ROW] = ir,
-    [PIVOT_AXIS_COLUMN] = ic,
-    [PIVOT_AXIS_LAYER] = il,
-  };
+  for (enum pivot_axis_type a = start_axis; a < PIVOT_N_AXES; a++)
+    {
+      const struct ctables_nest *nest = s->nests[a];
+      for (size_t i = start_nest; i < nest->n; i++)
+        {
+          if (i == nest->scale_idx)
+            continue;
+
+          const struct ctables_category *save = cats[a][i];
+          if (save->subtotal)
+            {
+              cats[a][i] = save->subtotal;
+              ctables_cell_add__ (s, c, cats, d_weight, e_weight);
+              recurse_subtotals (s, c, cats, d_weight, e_weight, a, i + 1);
+              cats[a][i] = save;
+            }
+        }
+      start_nest = 0;
+    }
+}
 
+static void
+ctables_cell_insert (struct ctables_section *s,
+                     const struct ccase *c,
+                     double d_weight, double e_weight)
+{
   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]];
+      const struct ctables_nest *nest = s->nests[a];
       for (size_t i = 0; i < nest->n; i++)
         {
           if (i == nest->scale_idx)
@@ -2405,33 +2655,16 @@ ctables_cell_insert (struct ctables_table *t,
             return;
 
           cats[a][i] = ctables_categories_match (
-            t->categories[var_get_dict_index (var)], value, var);
+            s->table->categories[var_get_dict_index (var)], value, var);
           if (!cats[a][i])
             return;
         }
     }
 
-  ctables_cell_add__ (t, c, ix, cats, weight);
-
-  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++)
-        {
-          if (i == nest->scale_idx)
-            continue;
+  ctables_cell_add__ (s, c, cats, d_weight, e_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;
-            }
-        }
-    }
+  recurse_totals (s, c, cats, d_weight, e_weight, 0, 0);
+  recurse_subtotals (s, c, cats, d_weight, e_weight, 0, 0);
 }
 
 struct merge_item
@@ -2452,8 +2685,62 @@ merge_item_compare_3way (const struct merge_item *a, const struct merge_item *b)
   return strcmp (as->label, bs->label);
 }
 
+static struct pivot_value *
+ctables_category_create_label (const struct ctables_category *cat,
+                               const struct variable *var,
+                               const union value *value)
+{
+  return (cat->type == CCT_TOTAL || cat->type == CCT_SUBTOTAL || cat->type == CCT_HSUBTOTAL
+          ? pivot_value_new_user_text (cat->total_label, SIZE_MAX)
+          : pivot_value_new_var_value (var, value));
+}
+
+static struct ctables_value *
+ctables_value_find__ (struct ctables_table *t, const union value *value,
+                      int width, unsigned int hash)
+{
+  struct ctables_value *clv;
+  HMAP_FOR_EACH_WITH_HASH (clv, struct ctables_value, node,
+                           hash, &t->clabels_values_map)
+    if (value_equal (value, &clv->value, width))
+      return clv;
+  return NULL;
+}
+
+static struct ctables_value *
+ctables_value_find (struct ctables_table *t,
+                    const union value *value, int width)
+{
+  return ctables_value_find__ (t, value, width,
+                               value_hash (value, width, 0));
+}
+
+static void
+ctables_table_add_section (struct ctables_table *t, enum pivot_axis_type a,
+                           size_t ix[PIVOT_N_AXES])
+{
+  if (a < PIVOT_N_AXES)
+    {
+      size_t limit = MAX (t->stacks[a].n, 1);
+      for (ix[a] = 0; ix[a] < limit; ix[a]++)
+        ctables_table_add_section (t, a + 1, ix);
+    }
+  else
+    {
+      struct ctables_section *s = &t->sections[t->n_sections++];
+      *s = (struct ctables_section) {
+        .table = t,
+        .cells = HMAP_INITIALIZER (s->cells),
+      };
+      for (a = 0; a < PIVOT_N_AXES; a++)
+        s->nests[a] = t->stacks[a].n ? &t->stacks[a].nests[ix[a]] : NULL;
+      for (size_t i = 0; i < N_CTDTS; i++)
+        hmap_init (&s->domains[i]);
+    }
+}
+
 static void
-ctables_table_output_same_axis (struct ctables *ct, struct ctables_table *t)
+ctables_table_output (struct ctables *ct, struct ctables_table *t)
 {
   struct pivot_table *pt = pivot_table_create__ (
     (t->title
@@ -2467,11 +2754,46 @@ ctables_table_output_same_axis (struct ctables *ct, struct ctables_table *t)
     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++)
+  bool summary_dimension = (t->summary_axis != t->slabels_axis
+                            || (!t->slabels_visible
+                                && t->summary_specs.n > 1));
+  if (summary_dimension)
     {
-      static const char *names[] = {
+      struct pivot_dimension *d = pivot_dimension_create (
+        pt, t->slabels_axis, N_("Statistics"));
+      const struct ctables_summary_spec_set *specs = &t->summary_specs;
+      if (!t->slabels_visible)
+        d->hide_all_labels = true;
+      for (size_t i = 0; i < specs->n; i++)
+        pivot_category_create_leaf (
+          d->root, pivot_value_new_text (specs->specs[i].label));
+    }
+
+  bool categories_dimension = t->clabels_example != NULL;
+  if (categories_dimension)
+    {
+      struct pivot_dimension *d = pivot_dimension_create (
+        pt, t->label_axis[t->clabels_from_axis],
+        t->clabels_from_axis == PIVOT_AXIS_ROW
+        ? N_("Row Categories")
+        : N_("Column Categories"));
+      const struct variable *var = t->clabels_example;
+      const struct ctables_categories *c = t->categories[var_get_dict_index (var)];
+      for (size_t i = 0; i < t->n_clabels_values; i++)
+        {
+          const struct ctables_value *value = t->clabels_values[i];
+          const struct ctables_category *cat = ctables_categories_match (c, &value->value, var);
+          assert (cat != NULL);
+          pivot_category_create_leaf (d->root, ctables_category_create_label (
+                                        cat, t->clabels_example, &value->value));
+        }
+    }
+
+  pivot_table_set_look (pt, ct->look);
+  struct pivot_dimension *d[PIVOT_N_AXES];
+  for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
+    {
+      static const char *names[] = {
         [PIVOT_AXIS_ROW] = N_("Rows"),
         [PIVOT_AXIS_COLUMN] = N_("Columns"),
         [PIVOT_AXIS_LAYER] = N_("Layers"),
@@ -2484,480 +2806,581 @@ ctables_table_output_same_axis (struct ctables *ct, struct ctables_table *t)
 
       assert (t->axes[a]);
 
-      struct ctables_cell **sorted = xnmalloc (t->cells.count, sizeof *sorted);
+      for (size_t i = 0; i < t->stacks[a].n; i++)
+        {
+          struct ctables_nest *nest = &t->stacks[a].nests[i];
+          struct ctables_section **sections = xnmalloc (t->n_sections,
+                                                        sizeof *sections);
+          size_t n_sections = 0;
+
+          size_t n_total_cells = 0;
+          size_t max_depth = 0;
+          for (size_t j = 0; j < t->n_sections; j++)
+            if (t->sections[j].nests[a] == nest)
+              {
+                struct ctables_section *s = &t->sections[j];
+                sections[n_sections++] = s;
+                n_total_cells += s->cells.count;
+
+                size_t depth = s->nests[a]->n;
+                max_depth = MAX (depth, max_depth);
+              }
 
-      struct ctables_cell *cell;
-      size_t n = 0;
-      HMAP_FOR_EACH (cell, struct ctables_cell, node, &t->cells)
-        if (!cell->hide)
-          sorted[n++] = cell;
-      assert (n <= t->cells.count);
-
-      struct ctables_cell_sort_aux aux = { .t = t, .a = a };
-      sort (sorted, n, sizeof *sorted, ctables_cell_compare_3way, &aux);
-
-      size_t max_depth = 0;
-      for (size_t j = 0; j < t->stacks[a].n; j++)
-        if (t->stacks[a].nests[j].n > max_depth)
-          max_depth = t->stacks[a].nests[j].n;
-
-      struct pivot_category **groups = xnmalloc (max_depth, sizeof *groups);
-      struct pivot_category *top = NULL;
-      int prev_leaf = 0;
-      for (size_t j = 0; j < n; j++)
-        {
-          struct ctables_cell *cell = sorted[j];
-          const struct ctables_nest *nest = &t->stacks[a].nests[cell->axes[a].stack_idx];
-
-          size_t n_common = 0;
-          bool new_subtable = false;
-          if (j > 0)
+          struct ctables_cell **sorted = xnmalloc (n_total_cells,
+                                                   sizeof *sorted);
+          size_t n_sorted = 0;
+
+          for (size_t j = 0; j < n_sections; j++)
             {
-              struct ctables_cell *prev = sorted[j - 1];
-              if (prev->axes[a].stack_idx == cell->axes[a].stack_idx)
+              struct ctables_section *s = sections[j];
+
+              struct ctables_cell *cell;
+              HMAP_FOR_EACH (cell, struct ctables_cell, node, &s->cells)
+                if (!cell->hide)
+                  sorted[n_sorted++] = cell;
+              assert (n_sorted <= n_total_cells);
+            }
+
+          struct ctables_cell_sort_aux aux = { .nest = nest, .a = a };
+          sort (sorted, n_sorted, sizeof *sorted, ctables_cell_compare_3way, &aux);
+
+          struct ctables_level
+            {
+              enum ctables_level_type
                 {
-                  for (; n_common < nest->n; n_common++)
-                    if (n_common != nest->scale_idx
-                        && (prev->axes[a].cvs[n_common].category
-                            != cell->axes[a].cvs[n_common].category
-                            || !value_equal (&prev->axes[a].cvs[n_common].value,
-                                             &cell->axes[a].cvs[n_common].value,
-                                             var_get_type (nest->vars[n_common]))))
-                      break;
+                  CTL_VAR,          /* Variable label for nest->vars[var_idx]. */
+                  CTL_CATEGORY,     /* Category for nest->vars[var_idx]. */
+                  CTL_SUMMARY,      /* Summary functions. */
                 }
-              else
-                new_subtable = true;
-            }
-          else
-            new_subtable = true;
+                type;
 
-          if (new_subtable)
+              size_t var_idx;
+            };
+          struct ctables_level *levels = xnmalloc (1 + 2 * max_depth, sizeof *levels);
+          size_t n_levels = 0;
+          for (size_t k = 0; k < nest->n; k++)
             {
-              enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (nest->vars[0])];
-              top = d[a]->root;
+              enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (nest->vars[k])];
               if (vlabel != CTVL_NONE)
-                top = pivot_category_create_group__ (
-                  top, pivot_value_new_variable (nest->vars[0]));
+                {
+                  levels[n_levels++] = (struct ctables_level) {
+                    .type = CTL_VAR,
+                    .var_idx = k,
+                  };
+                }
+
+              if (nest->scale_idx != k
+                  && (k != nest->n - 1 || t->label_axis[a] == a))
+                {
+                  levels[n_levels++] = (struct ctables_level) {
+                    .type = CTL_CATEGORY,
+                    .var_idx = k,
+                  };
+                }
             }
-          if (n_common == nest->n)
+
+          if (!summary_dimension && a == t->slabels_axis)
             {
-              cell->axes[a].leaf = prev_leaf;
-              continue;
+              levels[n_levels++] = (struct ctables_level) {
+                .type = CTL_SUMMARY,
+                .var_idx = SIZE_MAX,
+              };
             }
 
-          for (size_t k = n_common; k < nest->n; k++)
+          /* 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 pivot_category **groups = xnmalloc (1 + 2 * max_depth, sizeof *groups);
+          int prev_leaf = 0;
+          for (size_t j = 0; j < n_sorted; j++)
             {
-              struct pivot_category *parent = k > 0 ? groups[k - 1] : top;
-
-              struct pivot_value *label
-                = (k == nest->scale_idx ? NULL
-                   : (cell->axes[a].cvs[k].category->type == CCT_TOTAL
-                      || cell->axes[a].cvs[k].category->type == CCT_SUBTOTAL
-                      || cell->axes[a].cvs[k].category->type == CCT_HSUBTOTAL)
-                   ? pivot_value_new_user_text (cell->axes[a].cvs[k].category->total_label,
-                                                SIZE_MAX)
-                   : pivot_value_new_var_value (nest->vars[k],
-                                                &cell->axes[a].cvs[k].value));
-              if (k == nest->n - 1)
+              struct ctables_cell *cell = sorted[j];
+              struct ctables_cell *prev = j > 0 ? sorted[j - 1] : NULL;
+
+              size_t n_common = 0;
+              if (j > 0)
+                {
+                  for (; n_common < n_levels; n_common++)
+                    {
+                      const struct ctables_level *level = &levels[n_common];
+                      if (level->type == CTL_CATEGORY)
+                        {
+                          size_t var_idx = level->var_idx;
+                          const struct ctables_category *c = cell->axes[a].cvs[var_idx].category;
+                          if (prev->axes[a].cvs[var_idx].category != c)
+                            break;
+                          else if (c->type != CCT_SUBTOTAL
+                                   && c->type != CCT_HSUBTOTAL
+                                   && c->type != CCT_TOTAL
+                                   && !value_equal (&prev->axes[a].cvs[var_idx].value,
+                                                    &cell->axes[a].cvs[var_idx].value,
+                                                    var_get_type (nest->vars[var_idx])))
+                            break;
+                        }
+                    }
+                }
+
+              for (size_t k = n_common; k < n_levels; k++)
                 {
-                  if (a == t->summary_axis)
+                  const struct ctables_level *level = &levels[k];
+                  struct pivot_category *parent = k ? groups[k - 1] : d[a]->root;
+                  if (level->type == CTL_SUMMARY)
                     {
-                      if (label)
-                        parent = pivot_category_create_group__ (parent, label);
-                      const struct ctables_summary_spec_set *specs = &nest->specs[cell->sv];
+                      assert (k == n_levels - 1);
+
+                      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 == 0)
+                          if (!m)
                             prev_leaf = leaf;
                         }
                     }
                   else
                     {
-                      /* This assertion is true as long as the summary axis
-                         is the axis where the summaries are displayed. */
-                      assert (label);
+                      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 ();
 
-                      prev_leaf = pivot_category_create_leaf (parent, label);
+                      if (k == n_levels - 1)
+                        prev_leaf = pivot_category_create_leaf (parent, label);
+                      else
+                        groups[k] = pivot_category_create_group__ (parent, label);
                     }
-                  break;
                 }
 
-              if (label)
-                parent = pivot_category_create_group__ (parent, label);
-
-              enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (nest->vars[k + 1])];
-              if (vlabel != CTVL_NONE)
-                parent = pivot_category_create_group__ (
-                  parent, pivot_value_new_variable (nest->vars[k + 1]));
-              groups[k] = parent;
+              cell->axes[a].leaf = prev_leaf;
             }
-
-          cell->axes[a].leaf = prev_leaf;
+          free (sorted);
+          free (groups);
         }
-      free (sorted);
-      free (groups);
     }
-  struct ctables_cell *cell;
-  HMAP_FOR_EACH (cell, struct ctables_cell, node, &t->cells)
+
+  for (size_t i = 0; i < t->n_sections; i++)
     {
-      if (cell->hide)
-        continue;
+      struct ctables_section *s = &t->sections[i];
 
-      const struct ctables_nest *nest = &t->stacks[t->summary_axis].nests[cell->axes[t->summary_axis].stack_idx];
-      const struct ctables_summary_spec_set *specs = &nest->specs[cell->sv];
-      for (size_t j = 0; j < specs->n; j++)
+      struct ctables_cell *cell;
+      HMAP_FOR_EACH (cell, struct ctables_cell, node, &s->cells)
         {
-          size_t dindexes[3];
-          size_t n_dindexes = 0;
+          if (cell->hide)
+            continue;
 
-          for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
-            if (d[a])
-              {
-                int leaf = cell->axes[a].leaf;
-                if (a == t->summary_axis)
-                  leaf += j;
-                dindexes[n_dindexes++] = leaf;
-              }
+          const struct ctables_nest *specs_nest = s->nests[t->summary_axis];
+          const struct ctables_summary_spec_set *specs = &specs_nest->specs[cell->sv];
+          for (size_t j = 0; j < specs->n; j++)
+            {
+              size_t dindexes[5];
+              size_t n_dindexes = 0;
 
-          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);
+              if (summary_dimension)
+                dindexes[n_dindexes++] = specs->specs[j].axis_idx;
+
+              if (categories_dimension)
+                {
+                  const struct ctables_nest *clabels_nest = s->nests[t->clabels_from_axis];
+                  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 void
-ctables_table_output_different_axis (struct ctables *ct, struct ctables_table *t)
+static bool
+ctables_check_label_position (struct ctables_table *t, enum pivot_axis_type a)
 {
-  struct pivot_table *pt = pivot_table_create__ (
-    (t->title
-     ? pivot_value_new_user_text (t->title, SIZE_MAX)
-     : pivot_value_new_text (N_("Custom Tables"))),
-    "Custom Tables");
-  if (t->caption)
-    pivot_table_set_caption (
-      pt, pivot_value_new_user_text (t->caption, SIZE_MAX));
-  if (t->corner)
-    pivot_table_set_caption (
-      pt, pivot_value_new_user_text (t->corner, SIZE_MAX));
-
-  pivot_table_set_look (pt, ct->look);
-  struct pivot_dimension *d[PIVOT_N_AXES];
-  for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
-    {
-      static const char *names[] = {
-        [PIVOT_AXIS_ROW] = N_("Rows"),
-        [PIVOT_AXIS_COLUMN] = N_("Columns"),
-        [PIVOT_AXIS_LAYER] = N_("Layers"),
-      };
-      d[a] = (t->axes[a] || a == t->summary_axis
-              ? pivot_dimension_create (pt, a, names[a])
-              : NULL);
-      if (!d[a])
-        continue;
+  enum pivot_axis_type label_pos = t->label_axis[a];
+  if (label_pos == a)
+    return true;
 
-      assert (t->axes[a]);
+  t->clabels_from_axis = a;
 
-      struct ctables_cell **sorted = xnmalloc (t->cells.count, sizeof *sorted);
+  const char *subcommand_name = a == PIVOT_AXIS_ROW ? "ROWLABELS" : "COLLABELS";
+  const char *pos_name = label_pos == PIVOT_AXIS_LAYER ? "LAYER" : "OPPOSITE";
 
-      struct ctables_cell *cell;
-      size_t n = 0;
-      HMAP_FOR_EACH (cell, struct ctables_cell, node, &t->cells)
-        if (!cell->hide)
-          sorted[n++] = cell;
-      assert (n <= t->cells.count);
-
-      struct ctables_cell_sort_aux aux = { .t = t, .a = a };
-      sort (sorted, n, sizeof *sorted, ctables_cell_compare_3way, &aux);
-
-      size_t max_depth = 0;
-      for (size_t j = 0; j < t->stacks[a].n; j++)
-        if (t->stacks[a].nests[j].n > max_depth)
-          max_depth = t->stacks[a].nests[j].n;
-
-      struct pivot_category **groups = xnmalloc (max_depth, sizeof *groups);
-      struct pivot_category *top = NULL;
-      int prev_leaf = 0;
-      for (size_t j = 0; j < n; j++)
-        {
-          struct ctables_cell *cell = sorted[j];
-          const struct ctables_nest *nest = &t->stacks[a].nests[cell->axes[a].stack_idx];
-
-          size_t n_common = 0;
-          bool new_subtable = false;
-          if (j > 0)
-            {
-              struct ctables_cell *prev = sorted[j - 1];
-              if (prev->axes[a].stack_idx == cell->axes[a].stack_idx)
-                {
-                  for (; n_common < nest->n; n_common++)
-                    if (n_common != nest->scale_idx
-                        && (prev->axes[a].cvs[n_common].category
-                            != cell->axes[a].cvs[n_common].category
-                            || !value_equal (&prev->axes[a].cvs[n_common].value,
-                                             &cell->axes[a].cvs[n_common].value,
-                                             var_get_type (nest->vars[n_common]))))
-                      break;
-                }
-              else
-                new_subtable = true;
-            }
-          else
-            new_subtable = true;
+  const struct ctables_stack *stack = &t->stacks[a];
+  if (!stack->n)
+    return true;
 
-          if (new_subtable)
-            {
-              enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (nest->vars[0])];
-              top = d[a]->root;
-              if (vlabel != CTVL_NONE)
-                top = pivot_category_create_group__ (
-                  top, pivot_value_new_variable (nest->vars[0]));
-            }
-          if (n_common == nest->n)
-            {
-              cell->axes[a].leaf = prev_leaf;
-              continue;
-            }
+  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 k = n_common; k < nest->n; k++)
-            {
-              struct pivot_category *parent = k > 0 ? groups[k - 1] : top;
-
-              struct pivot_value *label
-                = (k == nest->scale_idx ? NULL
-                   : (cell->axes[a].cvs[k].category->type == CCT_TOTAL
-                      || cell->axes[a].cvs[k].category->type == CCT_SUBTOTAL
-                      || cell->axes[a].cvs[k].category->type == CCT_HSUBTOTAL)
-                   ? pivot_value_new_user_text (cell->axes[a].cvs[k].category->total_label,
-                                                SIZE_MAX)
-                   : pivot_value_new_var_value (nest->vars[k],
-                                                &cell->axes[a].cvs[k].value));
-              if (k == nest->n - 1)
-                {
-                  if (a == t->slabels_axis)
-                    {
-                      if (label)
-                        parent = pivot_category_create_group__ (parent, label);
-                      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 == 0)
-                            prev_leaf = leaf;
-                        }
-                    }
-                  else
-                    {
-                      prev_leaf = pivot_category_create_leaf (parent, label ? label : pivot_value_new_user_text ("text", SIZE_MAX));
-                    }
-                  break;
-                }
-
-              if (label)
-                parent = pivot_category_create_group__ (parent, label);
+  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;
+    }
 
-              enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (nest->vars[k + 1])];
-              if (vlabel != CTVL_NONE)
-                parent = pivot_category_create_group__ (
-                  parent, pivot_value_new_variable (nest->vars[k + 1]));
-              groups[k] = parent;
-            }
+  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)];
 
-          cell->axes[a].leaf = prev_leaf;
+      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;
         }
-      free (sorted);
-      free (groups);
     }
-  pivot_table_submit (pt);
-}
 
+  return true;
+}
 
 static bool
-ctables_execute (struct dataset *ds, struct ctables *ct)
+ctables_prepare_table (struct ctables_table *t)
 {
-  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->stacks[a] = enumerate_fts (a, t->axes[a]);
+  for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
+    if (t->axes[a])
+      {
+        t->stacks[a] = enumerate_fts (a, t->axes[a]);
 
-            for (size_t j = 0; j < t->stacks[a].n; j++)
+        for (size_t j = 0; j < t->stacks[a].n; j++)
+          {
+            struct ctables_nest *nest = &t->stacks[a].nests[j];
+            for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++)
               {
-                struct 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++)
                   {
-                    nest->domains[dt] = xmalloc (nest->n * sizeof *nest->domains[dt]);
-                    nest->n_domains[dt] = 0;
+                    if (k == nest->scale_idx)
+                      continue;
 
-                    for (size_t k = 0; k < nest->n; k++)
+                    switch (dt)
                       {
-                        if (k == nest->scale_idx)
-                          continue;
+                      case CTDT_TABLE:
+                        continue;
 
-                        switch (dt)
+                      case CTDT_LAYER:
+                        if (a != PIVOT_AXIS_LAYER)
+                          continue;
+                        break;
+
+                      case CTDT_SUBTABLE:
+                      case CTDT_ROW:
+                      case CTDT_COL:
+                        if (dt == CTDT_SUBTABLE ? a != PIVOT_AXIS_LAYER
+                            : dt == CTDT_ROW ? a == PIVOT_AXIS_COLUMN
+                            : a == PIVOT_AXIS_ROW)
                           {
-                          case CTDT_TABLE:
-                            continue;
-
-                          case CTDT_LAYER:
-                            if (a != PIVOT_AXIS_LAYER)
+                            if (k == nest->n - 1
+                                || (nest->scale_idx == nest->n - 1
+                                    && k == nest->n - 2))
                               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;
                           }
+                        break;
 
-                        nest->domains[dt][nest->n_domains[dt]++] = k;
+                      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 };
-          }
+      }
+    else
+      {
+        struct ctables_nest *nest = xmalloc (sizeof *nest);
+        *nest = (struct ctables_nest) { .n = 0 };
+        t->stacks[a] = (struct ctables_stack) { .nests = nest, .n = 1 };
+      }
 
-      struct ctables_stack *stack = &t->stacks[t->summary_axis];
-      for (size_t i = 0; i < stack->n; i++)
+  struct ctables_stack *stack = &t->stacks[t->summary_axis];
+  for (size_t i = 0; i < stack->n; i++)
+    {
+      struct ctables_nest *nest = &stack->nests[i];
+      if (!nest->specs[CSV_CELL].n)
         {
-          struct 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];
+          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]);
+          ctables_summary_spec_set_clone (&nest->specs[CSV_TOTAL],
+                                          &nest->specs[CSV_CELL]);
         }
+      else if (!nest->specs[CSV_TOTAL].n)
+        ctables_summary_spec_set_clone (&nest->specs[CSV_TOTAL],
+                                        &nest->specs[CSV_CELL]);
+    }
 
-      struct ctables_summary_spec_set *merged = &t->summary_specs;
-      struct merge_item *items = xnmalloc (2 * stack->n, sizeof *items);
-      size_t n_left = 0;
-      for (size_t j = 0; j < stack->n; j++)
-        {
-          const struct ctables_nest *nest = &stack->nests[j];
-          if (nest->n)
-            for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++)
-              items[n_left++] = (struct merge_item) { .set = &nest->specs[sv] };
-        }
+  struct ctables_summary_spec_set *merged = &t->summary_specs;
+  struct merge_item *items = xnmalloc (2 * stack->n, sizeof *items);
+  size_t n_left = 0;
+  for (size_t j = 0; j < stack->n; j++)
+    {
+      const struct ctables_nest *nest = &stack->nests[j];
+      if (nest->n)
+        for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++)
+          items[n_left++] = (struct merge_item) { .set = &nest->specs[sv] };
+    }
 
-      while (n_left > 0)
-        {
-          struct merge_item min = items[0];
-          for (size_t j = 1; j < n_left; j++)
-            if (merge_item_compare_3way (&items[j], &min) < 0)
-              min = items[j];
+  while (n_left > 0)
+    {
+      struct merge_item min = items[0];
+      for (size_t j = 1; j < n_left; j++)
+        if (merge_item_compare_3way (&items[j], &min) < 0)
+          min = items[j];
 
-          if (merged->n >= merged->allocated)
-            merged->specs = x2nrealloc (merged->specs, &merged->allocated,
-                                        sizeof *merged->specs);
-          merged->specs[merged->n++] = min.set->specs[min.ofs];
+      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; )
+      for (size_t j = 0; j < n_left; )
+        {
+          if (merge_item_compare_3way (&items[j], &min) == 0)
             {
-              if (merge_item_compare_3way (&items[j], &min) == 0)
+              struct merge_item *item = &items[j];
+              item->set->specs[item->ofs].axis_idx = merged->n - 1;
+              if (++item->ofs >= item->set->n)
                 {
-                  struct merge_item *item = &items[j];
-                  item->set->specs[item->ofs].axis_idx = merged->n - 1;
-                  if (++item->ofs >= item->set->n)
-                    {
-                      items[j] = items[--n_left];
-                      continue;
-                    }
+                  items[j] = items[--n_left];
+                  continue;
                 }
-              j++;
             }
+          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 < merged->n; j++)
+    printf ("%s\n", ctables_summary_function_name (merged->specs[j].function));
 
-      for (size_t j = 0; j < stack->n; j++)
+  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_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");
-            }
+          const struct ctables_summary_spec_set *specs = &nest->specs[sv];
+          for (size_t k = 0; k < specs->n; k++)
+            printf ("(%s, %zu) ", ctables_summary_function_name (specs->specs[k].function),
+                    specs->specs[k].axis_idx);
+          printf ("\n");
         }
+    }
 #endif
+
+  return (ctables_check_label_position (t, PIVOT_AXIS_ROW)
+          && ctables_check_label_position (t, PIVOT_AXIS_COLUMN));
+}
+
+static void
+ctables_insert_clabels_values (struct ctables_table *t, const struct ccase *c,
+                               enum pivot_axis_type a)
+{
+  struct ctables_stack *stack = &t->stacks[a];
+  for (size_t i = 0; i < stack->n; i++)
+    {
+      const struct ctables_nest *nest = &stack->nests[i];
+      const struct variable *var = nest->vars[nest->n - 1];
+      int width = var_get_width (var);
+      const union value *value = case_data (c, var);
+
+      if (var_is_numeric (var) && value->f == SYSMIS)
+        continue;
+
+      if (!ctables_categories_match (t->categories [var_get_dict_index (var)],
+                                     value, var))
+        continue;
+
+      unsigned int hash = value_hash (value, width, 0);
+
+      struct ctables_value *clv = ctables_value_find__ (t, value, width, hash);
+      if (!clv)
+        {
+          clv = xmalloc (sizeof *clv);
+          value_clone (&clv->value, value, width);
+          hmap_insert (&t->clabels_values_map, &clv->node, hash);
+        }
+    }
+}
+
+static int
+compare_clabels_values_3way (const void *a_, const void *b_, const void *width_)
+{
+  const struct ctables_value *const *ap = a_;
+  const struct ctables_value *const *bp = b_;
+  const struct ctables_value *a = *ap;
+  const struct ctables_value *b = *bp;
+  const int *width = width_;
+  return value_compare_3way (&a->value, &b->value, *width);
+}
+
+static void
+ctables_sort_clabels_values (struct ctables_table *t)
+{
+  int width = var_get_width (t->clabels_example);
+
+  size_t n = hmap_count (&t->clabels_values_map);
+  t->clabels_values = xnmalloc (n, sizeof *t->clabels_values);
+
+  struct ctables_value *clv;
+  size_t i = 0;
+  HMAP_FOR_EACH (clv, struct ctables_value, node, &t->clabels_values_map)
+    t->clabels_values[i++] = clv;
+  t->n_clabels_values = n;
+  assert (i == n);
+
+  sort (t->clabels_values, n, sizeof *t->clabels_values,
+        compare_clabels_values_3way, &width);
+
+  for (size_t i = 0; i < n; i++)
+    t->clabels_values[i]->leaf = i;
+}
+
+static bool
+ctables_execute (struct dataset *ds, struct ctables *ct)
+{
+  for (size_t i = 0; i < ct->n_tables; i++)
+    {
+      struct ctables_table *t = ct->tables[i];
+      t->sections = xnmalloc (MAX (1, t->stacks[PIVOT_AXIS_ROW].n) *
+                              MAX (1, t->stacks[PIVOT_AXIS_COLUMN].n) *
+                              MAX (1, t->stacks[PIVOT_AXIS_LAYER].n),
+                              sizeof *t->sections);
+      size_t ix[PIVOT_N_AXES];
+      ctables_table_add_section (t, 0, ix);
     }
 
-  struct casereader *input = casereader_create_filter_weight (proc_open (ds),
-                                                              dataset_dict (ds),
-                                                              NULL, NULL);
+  struct casereader *input = proc_open (ds);
   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;
+      double d_weight = dict_get_case_weight (dataset_dict (ds), c,
+                                              &warn_on_invalid);
+      double e_weight = (ct->e_weight
+                         ? var_force_valid_weight (ct->e_weight,
+                                                   case_num (c, ct->e_weight),
+                                                   &warn_on_invalid)
+                         : d_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 (size_t j = 0; j < t->n_sections; j++)
+            ctables_cell_insert (&t->sections[j], c, d_weight, e_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);
@@ -2965,10 +3388,11 @@ ctables_execute (struct dataset *ds, struct ctables *ct)
   for (size_t i = 0; i < ct->n_tables; i++)
     {
       struct ctables_table *t = ct->tables[i];
-      if (t->summary_axis == t->slabels_axis)
-        ctables_table_output_same_axis (ct, ct->tables[i]);
-      else
-        ctables_table_output_different_axis (ct, ct->tables[i]);
+
+      if (t->clabels_example)
+        ctables_sort_clabels_values (t);
+
+      ctables_table_output (ct, ct->tables[i]);
     }
   return proc_commit (ds);
 }
@@ -3152,8 +3576,8 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds)
           if (!lex_force_match_id (lexer, "VARIABLE"))
             goto error;
           lex_match (lexer, T_EQUALS);
-          ct->base_weight = parse_variable (lexer, dataset_dict (ds));
-          if (!ct->base_weight)
+          ct->e_weight = parse_variable (lexer, dataset_dict (ds));
+          if (!ct->e_weight)
             goto error;
         }
       else if (lex_match_id (lexer, "HIDESMALLCOUNTS"))
@@ -3207,17 +3631,19 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds)
 
       struct ctables_table *t = xmalloc (sizeof *t);
       *t = (struct ctables_table) {
-        .cells = HMAP_INITIALIZER (t->cells),
         .slabels_axis = PIVOT_AXIS_COLUMN,
         .slabels_visible = true,
-        .row_labels = CTLP_NORMAL,
-        .col_labels = CTLP_NORMAL,
+        .clabels_values_map = HMAP_INITIALIZER (t->clabels_values_map),
+        .label_axis = {
+          [PIVOT_AXIS_ROW] = PIVOT_AXIS_ROW,
+          [PIVOT_AXIS_COLUMN] = PIVOT_AXIS_COLUMN,
+          [PIVOT_AXIS_LAYER] = PIVOT_AXIS_LAYER,
+        },
+        .clabels_from_axis = PIVOT_AXIS_LAYER, 
         .categories = categories,
         .n_categories = n_vars,
         .cilevel = 95,
       };
-      for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++)
-        hmap_init (&t->domains[dt]);
       ct->tables[ct->n_tables++] = t;
 
       lex_match (lexer, T_EQUALS);
@@ -3299,7 +3725,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;
 
@@ -3342,14 +3772,17 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds)
               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");
@@ -3360,9 +3793,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");
@@ -3637,12 +4070,15 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds)
             break;
         }
 
-      if (t->row_labels != CTLP_NORMAL && t->col_labels != CTLP_NORMAL)
+      if (t->label_axis[PIVOT_AXIS_ROW] != PIVOT_AXIS_ROW
+          && t->label_axis[PIVOT_AXIS_COLUMN] != PIVOT_AXIS_COLUMN)
         {
           msg (SE, _("ROWLABELS and COLLABELS may not both be specified."));
           goto error;
         }
 
+      if (!ctables_prepare_table (t))
+        goto error;
     }
   while (lex_token (lexer) != T_ENDCMD);