X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Fctables.c;h=d6b5a0ca0c119c9764e49377d65a286466f5dcf8;hb=063c177c238c65c15c906507acb1d4199c220ab5;hp=8dcd682f10d2d667682928e0126ee8687382c525;hpb=82bb2efcfd8fe17cb2d5caeb8edf26612fe0ca4c;p=pspp

diff --git a/src/language/stats/ctables.c b/src/language/stats/ctables.c
index 8dcd682f10..d6b5a0ca0c 100644
--- a/src/language/stats/ctables.c
+++ b/src/language/stats/ctables.c
@@ -19,9 +19,11 @@
 #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"
@@ -33,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"
@@ -168,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
@@ -186,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;
@@ -193,7 +201,7 @@ struct ctables_cell
 
     struct
       {
-        size_t stack_idx;
+        size_t nest_idx;
         struct ctables_cell_value
           {
             const struct ctables_category *category;
@@ -224,7 +232,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;
@@ -314,6 +322,7 @@ struct ctables_value
   {
     struct hmap_node node;
     union value value;
+    int leaf;
   };
 
 struct ctables_table
@@ -327,7 +336,7 @@ struct ctables_table
 
     const struct variable *clabels_example;
     struct hmap clabels_values_map;
-    union value *clabels_values;
+    struct ctables_value **clabels_values;
     size_t n_clabels_values;
 
     enum pivot_axis_type slabels_axis;
@@ -1679,7 +1688,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
@@ -1711,6 +1728,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:
@@ -1740,10 +1758,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:
@@ -1800,6 +1831,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:
@@ -1827,10 +1859,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:
@@ -1862,11 +1894,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:
@@ -1889,14 +1929,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:
@@ -1924,14 +1963,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:
@@ -1959,6 +2007,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,
@@ -1970,26 +2111,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:
@@ -2007,6 +2141,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;
@@ -2069,10 +2206,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:
@@ -2117,8 +2278,8 @@ ctables_cell_compare_3way (const void *a_, const void *b_, const void *aux_)
   const struct ctables_cell *a = *ap;
   const struct ctables_cell *b = *bp;
 
-  size_t a_idx = a->axes[aux->a].stack_idx;
-  size_t b_idx = b->axes[aux->a].stack_idx;
+  size_t a_idx = a->axes[aux->a].nest_idx;
+  size_t b_idx = b->axes[aux->a].nest_idx;
   if (a_idx != b_idx)
     return a_idx < b_idx ? -1 : 1;
 
@@ -2207,7 +2368,7 @@ ctables_domain_insert (struct ctables_table *t, struct ctables_cell *cell,
   size_t hash = 0;
   for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
     {
-      size_t idx = cell->axes[a].stack_idx;
+      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 < nest->n_domains[domain]; i++)
@@ -2224,8 +2385,8 @@ ctables_domain_insert (struct ctables_table *t, struct ctables_cell *cell,
       const struct ctables_cell *df = d->example;
       for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
         {
-          size_t idx = cell->axes[a].stack_idx;
-          if (idx != df->axes[a].stack_idx)
+          size_t idx = cell->axes[a].nest_idx;
+          if (idx != df->axes[a].nest_idx)
             goto not_equal;
 
           const struct ctables_nest *nest = &t->stacks[a].nests[idx];
@@ -2342,7 +2503,7 @@ ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c,
       for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
         {
           const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]];
-          if (cell->axes[a].stack_idx != ix[a])
+          if (cell->axes[a].nest_idx != ix[a])
             goto not_equal;
           for (size_t i = 0; i < nest->n; i++)
             if (i != nest->scale_idx
@@ -2364,23 +2525,29 @@ 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];
+      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++)
         {
+          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]));
         }
@@ -2400,7 +2567,7 @@ 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)
+                    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]];
@@ -2408,16 +2575,22 @@ ctables_cell_add__ (struct ctables_table *t, const struct ccase *c,
   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],
                 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++)
@@ -2436,8 +2609,8 @@ recurse_totals (struct ctables_table *t, const struct ccase *c,
             {
               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__ (t, c, ix, cats, d_weight, e_weight);
+              recurse_totals (t, c, ix, cats, d_weight, e_weight, a, i + 1);
               cats[a][i] = save;
             }
         }
@@ -2446,47 +2619,16 @@ 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_table *t, const struct ccase *c,
+                   size_t ix[PIVOT_N_AXES],
+                   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,
-  };
-
-  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++)
-        {
-          if (i == nest->scale_idx)
-            continue;
-
-          const struct variable *var = nest->vars[i];
-          const union value *value = case_data (c, var);
-
-          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;
-        }
-    }
-
-  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++)
+  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 = 0; i < nest->n; i++)
+      for (size_t i = start_nest; i < nest->n; i++)
         {
           if (i == nest->scale_idx)
             continue;
@@ -2495,208 +2637,65 @@ ctables_cell_insert (struct ctables_table *t,
           if (save->subtotal)
             {
               cats[a][i] = save->subtotal;
-              ctables_cell_add__ (t, c, ix, cats, weight);
+              ctables_cell_add__ (t, c, ix, cats, d_weight, e_weight);
+              recurse_subtotals (t, c, ix, cats, d_weight, e_weight, a, i + 1);
               cats[a][i] = save;
             }
         }
+      start_nest = 0;
     }
 }
 
-struct merge_item
-  {
-    const struct ctables_summary_spec_set *set;
-    size_t ofs;
-  };
-
-static int
-merge_item_compare_3way (const struct merge_item *a, const struct merge_item *b)
-{
-  const struct ctables_summary_spec *as = &a->set->specs[a->ofs];
-  const struct ctables_summary_spec *bs = &b->set->specs[b->ofs];
-  if (as->function != bs->function)
-    return as->function > bs->function ? 1 : -1;
-  else if (as->percentile != bs->percentile)
-    return as->percentile < bs->percentile ? 1 : -1;
-  return strcmp (as->label, bs->label);
-}
-
 static void
-ctables_table_output_same_axis (struct ctables *ct, struct ctables_table *t)
+ctables_cell_insert (struct ctables_table *t,
+                     const struct ccase *c,
+                     size_t ix[PIVOT_N_AXES],
+                     double d_weight, double e_weight)
 {
-  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];
+  const struct ctables_category *cats[PIVOT_N_AXES][10];
   for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
     {
-      static const char *names[] = {
-        [PIVOT_AXIS_ROW] = N_("Rows"),
-        [PIVOT_AXIS_COLUMN] = N_("Columns"),
-        [PIVOT_AXIS_LAYER] = N_("Layers"),
-      };
-      d[a] = (t->axes[a] || a == t->summary_axis
-              ? pivot_dimension_create (pt, a, names[a])
-              : NULL);
-      if (!d[a])
-        continue;
-
-      assert (t->axes[a]);
-
-      struct ctables_cell **sorted = xnmalloc (t->cells.count, sizeof *sorted);
-
-      struct ctables_cell *cell;
-      size_t n = 0;
-      HMAP_FOR_EACH (cell, struct ctables_cell, node, &t->cells)
-        if (!cell->hide)
-          sorted[n++] = cell;
-      assert (n <= t->cells.count);
-
-      struct ctables_cell_sort_aux aux = { .t = t, .a = a };
-      sort (sorted, n, sizeof *sorted, ctables_cell_compare_3way, &aux);
-
-      size_t max_depth = 0;
-      for (size_t j = 0; j < t->stacks[a].n; j++)
-        if (t->stacks[a].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++)
+      const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]];
+      for (size_t i = 0; i < nest->n; i++)
         {
-          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;
-
-          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;
-            }
-
-          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->summary_axis)
-                    {
-                      if (label)
-                        parent = pivot_category_create_group__ (parent, label);
-                      const struct ctables_summary_spec_set *specs = &nest->specs[cell->sv];
-                      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
-                    {
-                      /* This assertion is true as long as the summary axis
-                         is the axis where the summaries are displayed. */
-                      assert (label);
-
-                      prev_leaf = pivot_category_create_leaf (parent, label);
-                    }
-                  break;
-                }
+          if (i == nest->scale_idx)
+            continue;
 
-              if (label)
-                parent = pivot_category_create_group__ (parent, label);
+          const struct variable *var = nest->vars[i];
+          const union value *value = case_data (c, var);
 
-              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;
-            }
+          if (var_is_numeric (var) && value->f == SYSMIS)
+            return;
 
-          cell->axes[a].leaf = prev_leaf;
+          cats[a][i] = ctables_categories_match (
+            t->categories[var_get_dict_index (var)], value, var);
+          if (!cats[a][i])
+            return;
         }
-      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 *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++)
-        {
-          size_t dindexes[3];
-          size_t n_dindexes = 0;
+  ctables_cell_add__ (t, c, ix, cats, d_weight, e_weight);
 
-          for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
-            if (d[a])
-              {
-                int leaf = cell->axes[a].leaf;
-                if (a == t->summary_axis)
-                  leaf += j;
-                dindexes[n_dindexes++] = leaf;
-              }
-
-          double d = ctables_summary_value (cell, &cell->summaries[j], &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);
-        }
-    }
+  recurse_totals (t, c, ix, cats, d_weight, e_weight, 0, 0);
+  recurse_subtotals (t, c, ix, cats, d_weight, e_weight, 0, 0);
+}
 
-  pivot_table_submit (pt);
+struct merge_item
+  {
+    const struct ctables_summary_spec_set *set;
+    size_t ofs;
+  };
+
+static int
+merge_item_compare_3way (const struct merge_item *a, const struct merge_item *b)
+{
+  const struct ctables_summary_spec *as = &a->set->specs[a->ofs];
+  const struct ctables_summary_spec *bs = &b->set->specs[b->ofs];
+  if (as->function != bs->function)
+    return as->function > bs->function ? 1 : -1;
+  else if (as->percentile != bs->percentile)
+    return as->percentile < bs->percentile ? 1 : -1;
+  return strcmp (as->label, bs->label);
 }
 
 static struct pivot_value *
@@ -2709,8 +2708,28 @@ ctables_category_create_label (const struct ctables_category *cat,
           : pivot_value_new_var_value (var, value));
 }
 
+static struct ctables_value *
+ctables_value_find__ (struct ctables_table *t, const union value *value,
+                      int width, unsigned int hash)
+{
+  struct ctables_value *clv;
+  HMAP_FOR_EACH_WITH_HASH (clv, struct ctables_value, node,
+                           hash, &t->clabels_values_map)
+    if (value_equal (value, &clv->value, width))
+      return clv;
+  return NULL;
+}
+
+static struct ctables_value *
+ctables_value_find (struct ctables_table *t,
+                    const union value *value, int width)
+{
+  return ctables_value_find__ (t, value, width,
+                               value_hash (value, width, 0));
+}
+
 static void
-ctables_table_output_different_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
@@ -2724,17 +2743,23 @@ ctables_table_output_different_axis (struct ctables *ct, struct ctables_table *t
     pivot_table_set_caption (
       pt, pivot_value_new_user_text (t->corner, SIZE_MAX));
 
-  if (t->summary_axis != t->slabels_axis)
+  bool summary_dimension = (t->summary_axis != t->slabels_axis
+                            || (!t->slabels_visible
+                                && t->summary_specs.n > 1));
+  if (summary_dimension)
     {
       struct pivot_dimension *d = pivot_dimension_create (
-        pt, t->slabels_axis, N_("Summaries"));
+        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));
     }
 
-  if (t->clabels_example)
+  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],
@@ -2745,15 +2770,11 @@ ctables_table_output_different_axis (struct ctables *ct, struct ctables_table *t
       const struct ctables_categories *c = t->categories[var_get_dict_index (var)];
       for (size_t i = 0; i < t->n_clabels_values; i++)
         {
-          const union value *value = &t->clabels_values[i];
-          const struct ctables_category *cat = ctables_categories_match (c, value, var);
-          if (!cat)
-            {
-              /* XXX probably missing */
-              continue;
-            }
+          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));
+                                        cat, t->clabels_example, &value->value));
         }
     }
 
@@ -2832,19 +2853,17 @@ ctables_table_output_different_axis (struct ctables *ct, struct ctables_table *t
         {
           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].stack_idx];
+          const struct ctables_nest *nest = &t->stacks[a].nests[cell->axes[a].nest_idx];
 
-          bool new_subtable = !prev || prev->axes[a].stack_idx != cell->axes[a].stack_idx;
+          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++)
                 {
                   enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (nest->vars[k])];
                   if (vlabel != CTVL_NONE)
                     {
-                      printf (" var(%s)", var_get_name (nest->vars[k]));
                       levels[n_levels++] = (struct ctables_level) {
                         .type = CTL_VAR,
                         .var_idx = k,
@@ -2854,7 +2873,6 @@ ctables_table_output_different_axis (struct ctables *ct, struct ctables_table *t
                   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,
@@ -2862,31 +2880,33 @@ ctables_table_output_different_axis (struct ctables *ct, struct ctables_table *t
                     }
                 }
 
-              if (a == t->slabels_axis && a == t->summary_axis)
+              if (!summary_dimension && a == t->slabels_axis)
                 {
-                  printf (" summary");
                   levels[n_levels++] = (struct ctables_level) {
                     .type = CTL_SUMMARY,
                     .var_idx = SIZE_MAX,
                   };
                 }
-              printf ("\n");
             }
 
           size_t n_common = 0;
           if (!new_subtable)
             {
-              for (; n_common < nest->n; n_common++)
+              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;
-                      if (prev->axes[a].cvs[var_idx].category
-                          != cell->axes[a].cvs[var_idx].category
-                          || !value_equal (&prev->axes[a].cvs[var_idx].value,
-                                           &cell->axes[a].cvs[var_idx].value,
-                                           var_get_type (nest->vars[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;
                     }
                 }
@@ -2898,10 +2918,16 @@ ctables_table_output_different_axis (struct ctables *ct, struct ctables_table *t
               struct pivot_category *parent = k ? groups[k - 1] : d[a]->root;
               if (level->type == CTL_SUMMARY)
                 {
+                  assert (k == n_levels - 1);
+
                   const struct ctables_summary_spec_set *specs = &t->summary_specs;
                   for (size_t m = 0; m < specs->n; m++)
-                    pivot_category_create_leaf (
-                      parent, pivot_value_new_text (specs->specs[m].label));
+                    {
+                      int leaf = pivot_category_create_leaf (
+                        parent, pivot_value_new_text (specs->specs[m].label));
+                      if (!m)
+                        prev_leaf = leaf;
+                    }
                 }
               else
                 {
@@ -2919,7 +2945,7 @@ ctables_table_output_different_axis (struct ctables *ct, struct ctables_table *t
                     NOT_REACHED ();
 
                   if (k == n_levels - 1)
-                    pivot_category_create_leaf (parent, label);
+                    prev_leaf = pivot_category_create_leaf (parent, label);
                   else
                     groups[k] = pivot_category_create_group__ (parent, label);
                 }
@@ -2930,11 +2956,140 @@ ctables_table_output_different_axis (struct ctables *ct, struct ctables_table *t
       free (sorted);
       free (groups);
     }
+
+  struct ctables_cell *cell;
+  HMAP_FOR_EACH (cell, struct ctables_cell, node, &t->cells)
+    {
+      if (cell->hide)
+        continue;
+
+      const struct ctables_nest *specs_nest = &t->stacks[t->summary_axis].nests[cell->axes[t->summary_axis].nest_idx];
+      const struct ctables_summary_spec_set *specs = &specs_nest->specs[cell->sv];
+      for (size_t j = 0; j < specs->n; j++)
+        {
+          size_t dindexes[5];
+          size_t n_dindexes = 0;
+
+          if (summary_dimension)
+            dindexes[n_dindexes++] = specs->specs[j].axis_idx;
+
+          if (categories_dimension)
+            {
+              const struct ctables_nest *clabels_nest = &t->stacks[t->clabels_from_axis].nests[cell->axes[t->clabels_from_axis].nest_idx];
+              const struct variable *var = clabels_nest->vars[clabels_nest->n - 1];
+              const union value *value = &cell->axes[t->clabels_from_axis].cvs[clabels_nest->n - 1].value;
+              const struct ctables_value *ctv = ctables_value_find (t, value, var_get_width (var));
+              assert (ctv != NULL);
+              dindexes[n_dindexes++] = ctv->leaf;
+            }
+
+          for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
+            if (d[a])
+              {
+                int leaf = cell->axes[a].leaf;
+                if (a == t->summary_axis && !summary_dimension)
+                  leaf += j;
+                dindexes[n_dindexes++] = leaf;
+              }
+
+          double d = ctables_summary_value (cell, &cell->summaries[j], &specs->specs[j]);
+          struct pivot_value *value = pivot_value_new_number (d);
+          value->numeric.format = specs->specs[j].format;
+          pivot_table_put (pt, dindexes, n_dindexes, value);
+        }
+    }
+
   pivot_table_submit (pt);
 }
 
+static bool
+ctables_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";
 
-static void
+  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++)
@@ -3088,6 +3243,9 @@ ctables_prepare_table (struct ctables_table *t)
         }
     }
 #endif
+
+  return (ctables_check_label_position (t, PIVOT_AXIS_ROW)
+          && ctables_check_label_position (t, PIVOT_AXIS_COLUMN));
 }
 
 static void
@@ -3098,32 +3256,38 @@ ctables_insert_clabels_values (struct ctables_table *t, const struct ccase *c,
   for (size_t i = 0; i < stack->n; i++)
     {
       const struct ctables_nest *nest = &stack->nests[i];
-      const struct variable *v = nest->vars[nest->n - 1];
-      int width = var_get_width (v);
-      const union value *value = case_data (c, v);
-      unsigned int hash = value_hash (value, width, 0);
+      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;
 
-      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))
-          goto next_stack;
+      if (!ctables_categories_match (t->categories [var_get_dict_index (var)],
+                                     value, var))
+        continue;
 
-      clv = xmalloc (sizeof *clv);
-      value_clone (&clv->value, value, width);
-      hmap_insert (&t->clabels_values_map, &clv->node, hash);
+      unsigned int hash = value_hash (value, width, 0);
 
-    next_stack: ;
+      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 union value *a = a_;
-  const union value *b = b_;
+  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, b, *width);
+  return value_compare_3way (&a->value, &b->value, *width);
 }
 
 static void
@@ -3134,31 +3298,35 @@ ctables_sort_clabels_values (struct ctables_table *t)
   size_t n = hmap_count (&t->clabels_values_map);
   t->clabels_values = xnmalloc (n, sizeof *t->clabels_values);
 
-  const struct ctables_value *clv;
+  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->value;
+    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);
+  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++)
         {
@@ -3167,7 +3335,15 @@ ctables_execute (struct dataset *ds, struct ctables *ct)
           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);
+                {
+                  size_t ix[PIVOT_N_AXES] = {
+                    [PIVOT_AXIS_ROW] = ir,
+                    [PIVOT_AXIS_COLUMN] = ic,
+                    [PIVOT_AXIS_LAYER] = il,
+                  };
+
+                  ctables_cell_insert (t, c, ix, d_weight, e_weight);
+                }
 
           for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
             if (t->label_axis[a] != a)
@@ -3183,101 +3359,11 @@ ctables_execute (struct dataset *ds, struct ctables *ct)
       if (t->clabels_example)
         ctables_sort_clabels_values (t);
 
-      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]);
+      ctables_table_output (ct, ct->tables[i]);
     }
   return proc_commit (ds);
 }
 
-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;
-}
-
 int
 cmd_ctables (struct lexer *lexer, struct dataset *ds)
 {
@@ -3457,8 +3543,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"))
@@ -3609,7 +3695,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;
 
@@ -3957,10 +4047,8 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds)
           goto error;
         }
 
-      ctables_prepare_table (t);
-
-      ctables_check_label_position (t, PIVOT_AXIS_ROW);
-      ctables_check_label_position (t, PIVOT_AXIS_COLUMN);
+      if (!ctables_prepare_table (t))
+        goto error;
     }
   while (lex_token (lexer) != T_ENDCMD);