+ case CTSF_STDDEV:
+ {
+ double variance;
+ moments1_calculate (s->moments, NULL, NULL, &variance, NULL, NULL);
+ return variance != SYSMIS ? sqrt (variance) : SYSMIS;
+ }
+
+ case CTSF_SUM:
+ {
+ double weight, mean;
+ moments1_calculate (s->moments, &weight, &mean, NULL, NULL, NULL);
+ return weight != SYSMIS && mean != SYSMIS ? weight * mean : SYSMIS;
+ }
+
+ case CTSF_VARIANCE:
+ {
+ double variance;
+ moments1_calculate (s->moments, NULL, NULL, &variance, NULL, NULL);
+ return variance;
+ }
+
+ case CTSF_ROWPCT_SUM:
+ case CTSF_COLPCT_SUM:
+ case CTSF_TABLEPCT_SUM:
+ case CTSF_SUBTABLEPCT_SUM:
+ case CTSF_LAYERPCT_SUM:
+ case CTSF_LAYERROWPCT_SUM:
+ case CTSF_LAYERCOLPCT_SUM:
+ NOT_REACHED ();
+
+ case CTSF_MEDIAN:
+ case CTSF_MISSING:
+ case CTSF_MODE:
+ case CTSF_PTILE:
+ NOT_REACHED ();
+
+ case CTSF_RESPONSES:
+ case CTSF_ROWPCT_RESPONSES:
+ case CTSF_COLPCT_RESPONSES:
+ case CTSF_TABLEPCT_RESPONSES:
+ case CTSF_SUBTABLEPCT_RESPONSES:
+ case CTSF_LAYERPCT_RESPONSES:
+ case CTSF_LAYERROWPCT_RESPONSES:
+ case CTSF_LAYERCOLPCT_RESPONSES:
+ case CTSF_ROWPCT_RESPONSES_COUNT:
+ case CTSF_COLPCT_RESPONSES_COUNT:
+ case CTSF_TABLEPCT_RESPONSES_COUNT:
+ case CTSF_SUBTABLEPCT_RESPONSES_COUNT:
+ case CTSF_LAYERPCT_RESPONSES_COUNT:
+ case CTSF_LAYERROWPCT_RESPONSES_COUNT:
+ case CTSF_LAYERCOLPCT_RESPONSES_COUNT:
+ case CTSF_ROWPCT_COUNT_RESPONSES:
+ case CTSF_COLPCT_COUNT_RESPONSES:
+ case CTSF_TABLEPCT_COUNT_RESPONSES:
+ case CTSF_SUBTABLEPCT_COUNT_RESPONSES:
+ case CTSF_LAYERPCT_COUNT_RESPONSES:
+ case CTSF_LAYERROWPCT_COUNT_RESPONSES:
+ case CTSF_LAYERCOLPCT_COUNT_RESPONSES:
+ NOT_REACHED ();
+ }
+
+ NOT_REACHED ();
+}
+
+struct ctables_cell_sort_aux
+ {
+ const struct ctables_table *t;
+ enum pivot_axis_type a;
+ };
+
+static int
+ctables_cell_compare_3way (const void *a_, const void *b_, const void *aux_)
+{
+ const struct ctables_cell_sort_aux *aux = aux_;
+ struct ctables_cell *const *ap = a_;
+ struct ctables_cell *const *bp = b_;
+ const struct ctables_cell *a = *ap;
+ const struct ctables_cell *b = *bp;
+
+ size_t a_idx = a->axes[aux->a].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];
+ for (size_t i = 0; i < nest->n; i++)
+ if (i != nest->scale_idx)
+ {
+ const struct variable *var = nest->vars[i];
+ const struct ctables_cell_value *a_cv = &a->axes[aux->a].cvs[i];
+ const struct ctables_cell_value *b_cv = &b->axes[aux->a].cvs[i];
+ if (a_cv->category != b_cv->category)
+ return a_cv->category > b_cv->category ? 1 : -1;
+
+ const union value *a_val = &a_cv->value;
+ const union value *b_val = &b_cv->value;
+ switch (a_cv->category->type)
+ {
+ case CCT_NUMBER:
+ case CCT_STRING:
+ case CCT_SUBTOTAL:
+ case CCT_HSUBTOTAL:
+ case CCT_TOTAL:
+ /* Must be equal. */
+ continue;
+
+ case CCT_RANGE:
+ case CCT_MISSING:
+ case CCT_OTHERNM:
+ {
+ int cmp = value_compare_3way (a_val, b_val, var_get_width (var));
+ if (cmp)
+ return cmp;
+ }
+ break;
+
+ case CCT_VALUE:
+ {
+ int cmp = value_compare_3way (a_val, b_val, var_get_width (var));
+ if (cmp)
+ return a_cv->category->sort_ascending ? cmp : -cmp;
+ }
+ break;
+
+ case CCT_LABEL:
+ {
+ const char *a_label = var_lookup_value_label (var, a_val);
+ const char *b_label = var_lookup_value_label (var, b_val);
+ int cmp = (a_label
+ ? (b_label ? strcmp (a_label, b_label) : 1)
+ : (b_label ? -1 : value_compare_3way (
+ a_val, b_val, var_get_width (var))));
+ if (cmp)
+ return a_cv->category->sort_ascending ? cmp : -cmp;
+ }
+ break;
+
+ case CCT_FUNCTION:
+ NOT_REACHED ();
+ }
+ }
+ return 0;
+}
+
+/* Algorithm:
+
+ For each row:
+ For each ctables_table:
+ For each combination of row vars:
+ For each combination of column vars:
+ For each combination of layer vars:
+ Add entry
+ Make a table of row values:
+ Sort entries by row values
+ Assign a 0-based index to each actual value
+ Construct a dimension
+ Make a table of column values
+ Make a table of layer values
+ For each entry:
+ Fill the table entry using the indexes from before.
+ */
+
+static struct ctables_domain *
+ctables_domain_insert (struct ctables_table *t, struct ctables_cell *cell,
+ enum ctables_domain_type domain)
+{
+ size_t hash = 0;
+ for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
+ {
+ size_t idx = cell->axes[a].stack_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++)
+ {
+ size_t v_idx = nest->domains[domain][i];
+ hash = value_hash (&cell->axes[a].cvs[v_idx].value,
+ var_get_width (nest->vars[v_idx]), hash);
+ }
+ }
+
+ struct ctables_domain *d;
+ HMAP_FOR_EACH_WITH_HASH (d, struct ctables_domain, node, hash, &t->domains[domain])
+ {
+ const struct ctables_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];
+ for (size_t i = 0; i < nest->n_domains[domain]; i++)
+ {
+ size_t v_idx = nest->domains[domain][i];
+ if (!value_equal (&df->axes[a].cvs[v_idx].value,
+ &cell->axes[a].cvs[v_idx].value,
+ var_get_width (nest->vars[v_idx])))
+ goto not_equal;
+ }
+ }
+ return d;
+
+ not_equal: ;
+ }
+
+ d = xmalloc (sizeof *d);
+ *d = (struct ctables_domain) { .example = cell };
+ hmap_insert (&t->domains[domain], &d->node, hash);
+ return d;
+}
+
+static const struct ctables_category *
+ctables_categories_match (const struct ctables_categories *c,
+ const union value *v, const struct variable *var)
+{
+ const struct ctables_category *othernm = NULL;
+ for (size_t i = c->n_cats; i-- > 0; )
+ {
+ const struct ctables_category *cat = &c->cats[i];
+ switch (cat->type)
+ {
+ case CCT_NUMBER:
+ if (cat->number == v->f)
+ return cat;
+ break;
+
+ case CCT_STRING:
+ NOT_REACHED ();
+
+ case CCT_RANGE:
+ if ((cat->range[0] == -DBL_MAX || v->f >= cat->range[0])
+ && (cat->range[1] == DBL_MAX || v->f <= cat->range[1]))
+ return cat;
+ break;
+
+ case CCT_MISSING:
+ if (var_is_value_missing (var, v))
+ return cat;
+ break;
+
+ case CCT_OTHERNM:
+ if (!othernm)
+ othernm = cat;
+ break;
+
+ case CCT_SUBTOTAL:
+ case CCT_HSUBTOTAL:
+ case CCT_TOTAL:
+ break;
+
+ case CCT_VALUE:
+ case CCT_LABEL:
+ case CCT_FUNCTION:
+ return (cat->include_missing || !var_is_value_missing (var, v) ? cat
+ : NULL);
+ }
+ }
+
+ return var_is_value_missing (var, v) ? NULL : othernm;
+}
+
+static const struct ctables_category *
+ctables_categories_total (const struct ctables_categories *c)
+{
+ const struct ctables_category *first = &c->cats[0];
+ const struct ctables_category *last = &c->cats[c->n_cats - 1];
+ return (first->type == CCT_TOTAL ? first
+ : last->type == CCT_TOTAL ? last
+ : NULL);
+}
+
+static struct ctables_cell *
+ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c,
+ size_t ix[PIVOT_N_AXES],
+ const struct ctables_category *cats[PIVOT_N_AXES][10])
+{
+ const struct ctables_nest *ss = &t->stacks[t->summary_axis].nests[ix[t->summary_axis]];
+
+ size_t hash = 0;
+ enum ctables_summary_variant sv = CSV_CELL;
+ for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
+ {
+ const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]];
+ hash = hash_int (ix[a], hash);
+ for (size_t i = 0; i < nest->n; i++)
+ if (i != nest->scale_idx)
+ {
+ hash = hash_pointer (cats[a][i], hash);
+ if (cats[a][i]->type != CCT_TOTAL
+ && cats[a][i]->type != CCT_SUBTOTAL
+ && cats[a][i]->type != CCT_HSUBTOTAL)
+ hash = value_hash (case_data (c, nest->vars[i]),
+ var_get_width (nest->vars[i]), hash);
+ else
+ sv = CSV_TOTAL;
+ }
+ }
+
+ struct ctables_cell *cell;
+ HMAP_FOR_EACH_WITH_HASH (cell, struct ctables_cell, node, hash, &t->cells)
+ {
+ for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
+ {
+ const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]];
+ if (cell->axes[a].stack_idx != ix[a])
+ goto not_equal;
+ for (size_t i = 0; i < nest->n; i++)
+ if (i != nest->scale_idx
+ && (cats[a][i] != cell->axes[a].cvs[i].category
+ || (cats[a][i]->type != CCT_TOTAL
+ && cats[a][i]->type != CCT_SUBTOTAL
+ && cats[a][i]->type != CCT_HSUBTOTAL
+ && !value_equal (case_data (c, nest->vars[i]),
+ &cell->axes[a].cvs[i].value,
+ var_get_width (nest->vars[i])))))
+ goto not_equal;
+ }
+
+ return cell;
+
+ not_equal: ;
+ }
+
+ cell = xmalloc (sizeof *cell);
+ cell->hide = false;
+ cell->sv = sv;
+ 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].cvs = (nest->n
+ ? xnmalloc (nest->n, sizeof *cell->axes[a].cvs)
+ : NULL);
+ for (size_t i = 0; i < nest->n; i++)
+ {
+ if (i != nest->scale_idx)
+ {
+ const struct ctables_category *subtotal = cats[a][i]->subtotal;
+ if (subtotal && subtotal->type == CCT_HSUBTOTAL)
+ cell->hide = true;
+ }
+
+ cell->axes[a].cvs[i].category = cats[a][i];
+ value_clone (&cell->axes[a].cvs[i].value, case_data (c, nest->vars[i]),
+ var_get_width (nest->vars[i]));
+ }
+ }
+
+ const struct ctables_summary_spec_set *specs = &ss->specs[cell->sv];
+ cell->summaries = xmalloc (specs->n * sizeof *cell->summaries);
+ for (size_t i = 0; i < specs->n; i++)
+ ctables_summary_init (&cell->summaries[i], &specs->specs[i]);
+ for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++)
+ cell->domains[dt] = ctables_domain_insert (t, cell, dt);
+ hmap_insert (&t->cells, &cell->node, hash);
+ return cell;
+}
+
+static void
+ctables_cell_add__ (struct ctables_table *t, const struct ccase *c,
+ size_t ix[PIVOT_N_AXES],
+ const struct ctables_category *cats[PIVOT_N_AXES][10],
+ double weight)
+{
+ struct ctables_cell *cell = ctables_cell_insert__ (t, c, ix, cats);
+ const struct ctables_nest *ss = &t->stacks[t->summary_axis].nests[ix[t->summary_axis]];
+
+ 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;
+}
+
+static void
+recurse_totals (struct ctables_table *t, const struct ccase *c,
+ size_t ix[PIVOT_N_AXES],
+ const struct ctables_category *cats[PIVOT_N_AXES][10],
+ double weight,
+ enum pivot_axis_type start_axis, size_t start_nest)
+{
+ for (enum pivot_axis_type a = start_axis; a < PIVOT_N_AXES; a++)
+ {
+ const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]];
+ for (size_t i = start_nest; i < nest->n; i++)
+ {
+ if (i == nest->scale_idx)
+ continue;
+
+ const struct variable *var = nest->vars[i];
+
+ const struct ctables_category *total = ctables_categories_total (
+ t->categories[var_get_dict_index (var)]);
+ if (total)
+ {
+ const struct ctables_category *save = cats[a][i];
+ cats[a][i] = total;
+ ctables_cell_add__ (t, c, ix, cats, weight);
+ recurse_totals (t, c, ix, cats, weight, a, i + 1);
+ cats[a][i] = save;
+ }
+ }
+ start_nest = 0;
+ }
+}
+
+static void
+ctables_cell_insert (struct ctables_table *t,
+ const struct ccase *c,
+ size_t ir, size_t ic, size_t il,
+ double weight)
+{
+ size_t ix[PIVOT_N_AXES] = {
+ [PIVOT_AXIS_ROW] = ir,
+ [PIVOT_AXIS_COLUMN] = ic,
+ [PIVOT_AXIS_LAYER] = il,
+ };
+
+ 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++)
+ {
+ 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 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;
+ }
+ }
+ }
+}
+
+struct merge_item
+ {
+ const struct ctables_summary_spec_set *set;
+ size_t ofs;
+ };
+
+static int
+merge_item_compare_3way (const struct merge_item *a, const struct merge_item *b)
+{
+ const struct ctables_summary_spec *as = &a->set->specs[a->ofs];
+ const struct ctables_summary_spec *bs = &b->set->specs[b->ofs];
+ if (as->function != bs->function)
+ return as->function > bs->function ? 1 : -1;
+ else if (as->percentile != bs->percentile)
+ return as->percentile < bs->percentile ? 1 : -1;
+ return strcmp (as->label, bs->label);
+}
+
+static struct pivot_value *
+ctables_category_create_label (const struct ctables_category *cat,
+ const struct variable *var,
+ const union value *value)
+{
+ return (cat->type == CCT_TOTAL || cat->type == CCT_SUBTOTAL || cat->type == CCT_HSUBTOTAL
+ ? pivot_value_new_user_text (cat->total_label, SIZE_MAX)
+ : pivot_value_new_var_value (var, value));
+}
+
+static void
+ctables_table_output_different_axis (struct ctables *ct, struct ctables_table *t)
+{
+ struct pivot_table *pt = pivot_table_create__ (
+ (t->title
+ ? pivot_value_new_user_text (t->title, SIZE_MAX)
+ : pivot_value_new_text (N_("Custom Tables"))),
+ "Custom Tables");
+ if (t->caption)
+ pivot_table_set_caption (
+ pt, pivot_value_new_user_text (t->caption, SIZE_MAX));
+ if (t->corner)
+ pivot_table_set_caption (
+ pt, pivot_value_new_user_text (t->corner, SIZE_MAX));
+
+ if (t->summary_axis != t->slabels_axis)
+ {
+ struct pivot_dimension *d = pivot_dimension_create (
+ pt, t->slabels_axis, N_("Summaries"));
+ const struct ctables_summary_spec_set *specs = &t->summary_specs;
+ for (size_t i = 0; i < specs->n; i++)
+ pivot_category_create_leaf (
+ d->root, pivot_value_new_text (specs->specs[i].label));
+ }
+
+ if (t->clabels_example)
+ {
+ 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 union value *value = &t->clabels_values[i];
+ const struct ctables_category *cat = ctables_categories_match (c, value, var);
+ if (!cat)
+ {
+ /* XXX probably missing */
+ continue;
+ }
+ pivot_category_create_leaf (d->root, ctables_category_create_label (
+ cat, t->clabels_example, 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"),
+ };
+ d[a] = (t->axes[a] || a == t->summary_axis
+ ? pivot_dimension_create (pt, a, names[a])
+ : NULL);
+ if (!d[a])
+ continue;
+
+ assert (t->axes[a]);
+
+ struct ctables_cell **sorted = xnmalloc (t->cells.count, sizeof *sorted);
+ size_t n_sorted = 0;
+
+ struct ctables_cell *cell;
+ HMAP_FOR_EACH (cell, struct ctables_cell, node, &t->cells)
+ if (!cell->hide)
+ sorted[n_sorted++] = cell;
+ assert (n_sorted <= t->cells.count);
+
+ struct ctables_cell_sort_aux aux = { .t = t, .a = a };
+ sort (sorted, n_sorted, sizeof *sorted, ctables_cell_compare_3way, &aux);
+
+ size_t max_depth = 0;
+ for (size_t j = 0; j < t->stacks[a].n; j++)
+ if (t->stacks[a].nests[j].n > max_depth)
+ max_depth = t->stacks[a].nests[j].n;
+
+ /* Pivot categories:
+
+ - variable label for nest->vars[0], if vlabel != CTVL_NONE
+ - category for nest->vars[0], if nest->scale_idx != 0
+ - variable label for nest->vars[1], if vlabel != CTVL_NONE
+ - category for nest->vars[1], if nest->scale_idx != 1
+ ...
+ - variable label for nest->vars[n - 1], if vlabel != CTVL_NONE
+ - category for nest->vars[n - 1], if t->label_axis[a] == a && nest->scale_idx != n - 1.
+ - summary function, if 'a == t->slabels_axis && a ==
+ t->summary_axis'.
+
+ Additional dimensions:
+
+ - If 'a == t->slabels_axis && a != t->summary_axis', add a summary
+ dimension.
+ - If 't->label_axis[b] == a' for some 'b != a', add a category
+ dimension to 'a'.
+ */
+
+ struct ctables_level
+ {
+ enum ctables_level_type
+ {
+ CTL_VAR, /* Variable label for nest->vars[var_idx]. */
+ CTL_CATEGORY, /* Category for nest->vars[var_idx]. */
+ CTL_SUMMARY, /* Summary functions. */
+ }
+ type;
+
+ size_t var_idx;
+ };
+ struct ctables_level *levels = xnmalloc (1 + 2 * max_depth, sizeof *levels);
+ size_t n_levels = 0;
+
+ struct pivot_category **groups = xnmalloc (1 + 2 * max_depth, sizeof *groups);
+ int prev_leaf = 0;
+ for (size_t j = 0; j < n_sorted; j++)
+ {
+ struct ctables_cell *cell = sorted[j];
+ struct ctables_cell *prev = j > 0 ? sorted[j - 1] : NULL;
+ const struct ctables_nest *nest = &t->stacks[a].nests[cell->axes[a].stack_idx];
+
+ bool new_subtable = !prev || prev->axes[a].stack_idx != cell->axes[a].stack_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,
+ };
+ }
+
+ if (nest->scale_idx != k
+ && (k != nest->n - 1 || t->label_axis[a] == a))
+ {
+ printf (" category(%s)", var_get_name (nest->vars[k]));
+ levels[n_levels++] = (struct ctables_level) {
+ .type = CTL_CATEGORY,
+ .var_idx = k,
+ };
+ }
+ }
+
+ if (a == t->slabels_axis && a == t->summary_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 < 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)
+ {
+ break;
+ }
+ else if (!value_equal (&prev->axes[a].cvs[var_idx].value,
+ &cell->axes[a].cvs[var_idx].value,
+ var_get_type (nest->vars[var_idx])))
+ {
+ break;
+ }
+ }
+ }
+ }
+
+ for (size_t k = n_common; k < n_levels; k++)
+ {
+ const struct ctables_level *level = &levels[k];
+ struct pivot_category *parent = k ? groups[k - 1] : d[a]->root;
+ if (level->type == CTL_SUMMARY)
+ {
+ const struct ctables_summary_spec_set *specs = &t->summary_specs;
+ for (size_t m = 0; m < specs->n; m++)
+ pivot_category_create_leaf (
+ parent, pivot_value_new_text (specs->specs[m].label));
+ }
+ else
+ {
+ const struct variable *var = nest->vars[level->var_idx];
+ struct pivot_value *label;
+ if (level->type == CTL_VAR)
+ label = pivot_value_new_variable (var);
+ else if (level->type == CTL_CATEGORY)
+ {
+ const struct ctables_cell_value *cv = &cell->axes[a].cvs[level->var_idx];
+ label = ctables_category_create_label (cv->category,
+ var, &cv->value);
+ }
+ else
+ NOT_REACHED ();
+
+ if (k == n_levels - 1)
+ pivot_category_create_leaf (parent, label);
+ else
+ groups[k] = pivot_category_create_group__ (parent, label);
+ }
+ }
+
+ cell->axes[a].leaf = prev_leaf;
+ }
+ free (sorted);
+ free (groups);
+ }
+ pivot_table_submit (pt);
+}
+
+
+static void
+ctables_prepare_table (struct ctables_table *t)
+{
+ for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
+ if (t->axes[a])
+ {
+ t->stacks[a] = enumerate_fts (a, t->axes[a]);
+
+ for (size_t j = 0; j < t->stacks[a].n; j++)
+ {
+ 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++)
+ {
+ if (k == nest->scale_idx)
+ continue;
+
+ switch (dt)
+ {
+ case CTDT_TABLE:
+ continue;
+
+ case CTDT_LAYER:
+ if (a != PIVOT_AXIS_LAYER)
+ continue;
+ break;
+
+ case CTDT_SUBTABLE:
+ case CTDT_ROW:
+ case CTDT_COL:
+ if (dt == CTDT_SUBTABLE ? a != PIVOT_AXIS_LAYER
+ : dt == CTDT_ROW ? a == PIVOT_AXIS_COLUMN
+ : a == PIVOT_AXIS_ROW)
+ {
+ if (k == nest->n - 1
+ || (nest->scale_idx == nest->n - 1
+ && k == nest->n - 2))
+ continue;
+ }
+ break;
+
+ case CTDT_LAYERROW:
+ if (a == PIVOT_AXIS_COLUMN)
+ continue;
+ break;
+
+ case CTDT_LAYERCOL:
+ if (a == PIVOT_AXIS_ROW)
+ continue;
+ break;
+ }
+
+ nest->domains[dt][nest->n_domains[dt]++] = k;
+ }
+ }
+ }
+ }
+ else
+ {
+ struct ctables_nest *nest = xmalloc (sizeof *nest);
+ *nest = (struct ctables_nest) { .n = 0 };
+ t->stacks[a] = (struct ctables_stack) { .nests = nest, .n = 1 };
+ }
+
+ struct ctables_stack *stack = &t->stacks[t->summary_axis];
+ for (size_t i = 0; i < stack->n; i++)
+ {
+ struct ctables_nest *nest = &stack->nests[i];
+ if (!nest->specs[CSV_CELL].n)
+ {
+ struct ctables_summary_spec_set *specs = &nest->specs[CSV_CELL];
+ specs->specs = xmalloc (sizeof *specs->specs);
+ specs->n = 1;
+
+ enum ctables_summary_function function
+ = specs->var ? CTSF_MEAN : CTSF_COUNT;
+ struct ctables_var var = { .is_mrset = false, .var = specs->var };
+
+ *specs->specs = (struct ctables_summary_spec) {
+ .function = function,
+ .format = ctables_summary_default_format (function, &var),
+ .label = ctables_summary_default_label (function, 0),
+ };
+ if (!specs->var)
+ specs->var = nest->vars[0];
+
+ ctables_summary_spec_set_clone (&nest->specs[CSV_TOTAL],
+ &nest->specs[CSV_CELL]);
+ }
+ else if (!nest->specs[CSV_TOTAL].n)
+ ctables_summary_spec_set_clone (&nest->specs[CSV_TOTAL],
+ &nest->specs[CSV_CELL]);
+ }
+
+ 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];
+
+ if (merged->n >= merged->allocated)
+ merged->specs = x2nrealloc (merged->specs, &merged->allocated,
+ sizeof *merged->specs);
+ merged->specs[merged->n++] = min.set->specs[min.ofs];
+
+ for (size_t j = 0; j < n_left; )
+ {
+ if (merge_item_compare_3way (&items[j], &min) == 0)
+ {
+ struct merge_item *item = &items[j];
+ item->set->specs[item->ofs].axis_idx = merged->n - 1;
+ if (++item->ofs >= item->set->n)