+ 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;
+
+ 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 bool
+ctables_check_label_position (struct ctables_table *t, enum pivot_axis_type a)
+{
+ enum pivot_axis_type label_pos = t->label_axis[a];
+ if (label_pos == a)
+ return true;
+
+ t->clabels_from_axis = a;
+
+ const char *subcommand_name = a == PIVOT_AXIS_ROW ? "ROWLABELS" : "COLLABELS";
+ const char *pos_name = label_pos == PIVOT_AXIS_LAYER ? "LAYER" : "OPPOSITE";
+
+ const struct ctables_stack *stack = &t->stacks[a];
+ if (!stack->n)
+ return true;
+
+ const struct ctables_nest *n0 = &stack->nests[0];
+ assert (n0->n > 0);
+ const struct variable *v0 = n0->vars[n0->n - 1];
+ struct ctables_categories *c0 = t->categories[var_get_dict_index (v0)];
+ t->clabels_example = v0;
+
+ for (size_t i = 0; i < c0->n_cats; i++)
+ if (c0->cats[i].type == CCT_FUNCTION)
+ {
+ msg (SE, _("%s=%s is not allowed with sorting based "
+ "on a summary function."),
+ subcommand_name, pos_name);
+ return false;
+ }
+ if (n0->n - 1 == n0->scale_idx)
+ {
+ msg (SE, _("%s=%s requires the variables to be moved to be categorical, "
+ "but %s is a scale variable."),
+ subcommand_name, pos_name, var_get_name (v0));
+ return false;
+ }
+
+ for (size_t i = 1; i < stack->n; i++)
+ {
+ const struct ctables_nest *ni = &stack->nests[i];
+ assert (ni->n > 0);
+ const struct variable *vi = ni->vars[ni->n - 1];
+ struct ctables_categories *ci = t->categories[var_get_dict_index (vi)];
+
+ if (ni->n - 1 == ni->scale_idx)
+ {
+ msg (SE, _("%s=%s requires the variables to be moved to be "
+ "categorical, but %s is a scale variable."),
+ subcommand_name, pos_name, var_get_name (vi));
+ return false;
+ }
+ if (var_get_width (v0) != var_get_width (vi))
+ {
+ msg (SE, _("%s=%s requires the variables to be "
+ "moved to have the same width, but %s has "
+ "width %d and %s has width %d."),
+ subcommand_name, pos_name,
+ var_get_name (v0), var_get_width (v0),
+ var_get_name (vi), var_get_width (vi));
+ return false;
+ }
+ if (!val_labs_equal (var_get_value_labels (v0),
+ var_get_value_labels (vi)))
+ {
+ msg (SE, _("%s=%s requires the variables to be "
+ "moved to have the same value labels, but %s "
+ "and %s have different value labels."),
+ subcommand_name, pos_name,
+ var_get_name (v0), var_get_name (vi));
+ return false;
+ }
+ if (!ctables_categories_equal (c0, ci))
+ {
+ msg (SE, _("%s=%s requires the variables to be "
+ "moved to have the same category "
+ "specifications, but %s and %s have different "
+ "category specifications."),
+ subcommand_name, pos_name,
+ var_get_name (v0), var_get_name (vi));
+ return false;
+ }
+ }
+
+ return true;
+}
+
+static bool
+ctables_prepare_table (struct ctables_table *t)
+{
+ for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
+ if (t->axes[a])
+ {
+ t->stacks[a] = enumerate_fts (a, t->axes[a]);
+
+ for (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)
+ {
+ items[j] = items[--n_left];
+ continue;
+ }
+ }
+ j++;
+ }
+ }
+
+#if 0
+ for (size_t j = 0; j < merged->n; j++)
+ printf ("%s\n", ctables_summary_function_name (merged->specs[j].function));
+
+ for (size_t j = 0; j < stack->n; j++)
+ {
+ const struct ctables_nest *nest = &stack->nests[j];
+ for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++)
+ {
+ const struct ctables_summary_spec_set *specs = &nest->specs[sv];
+ for (size_t k = 0; k < specs->n; k++)
+ printf ("(%s, %zu) ", ctables_summary_function_name (specs->specs[k].function),
+ specs->specs[k].axis_idx);
+ printf ("\n");
+ }
+ }
+#endif
+
+ return (ctables_check_label_position (t, PIVOT_AXIS_ROW)
+ && ctables_check_label_position (t, PIVOT_AXIS_COLUMN));
+}
+
+static void
+ctables_insert_clabels_values (struct ctables_table *t, const struct ccase *c,
+ enum pivot_axis_type a)
+{
+ struct ctables_stack *stack = &t->stacks[a];
+ for (size_t i = 0; i < stack->n; i++)
+ {
+ const struct ctables_nest *nest = &stack->nests[i];
+ const struct variable *var = nest->vars[nest->n - 1];
+ int width = var_get_width (var);
+ const union value *value = case_data (c, var);
+
+ if (var_is_numeric (var) && value->f == SYSMIS)
+ continue;
+
+ if (!ctables_categories_match (t->categories [var_get_dict_index (var)],
+ value, var))
+ continue;
+
+ unsigned int hash = value_hash (value, width, 0);
+
+ struct ctables_value *clv = ctables_value_find__ (t, value, width, hash);
+ if (!clv)
+ {
+ clv = xmalloc (sizeof *clv);
+ value_clone (&clv->value, value, width);
+ hmap_insert (&t->clabels_values_map, &clv->node, hash);
+ }
+ }
+}
+
+static int
+compare_clabels_values_3way (const void *a_, const void *b_, const void *width_)
+{
+ const struct ctables_value *const *ap = a_;
+ const struct ctables_value *const *bp = b_;
+ const struct ctables_value *a = *ap;
+ const struct ctables_value *b = *bp;
+ const int *width = width_;
+ return value_compare_3way (&a->value, &b->value, *width);
+}
+
+static void
+ctables_sort_clabels_values (struct ctables_table *t)
+{
+ int width = var_get_width (t->clabels_example);
+
+ size_t n = hmap_count (&t->clabels_values_map);
+ t->clabels_values = xnmalloc (n, sizeof *t->clabels_values);
+
+ struct ctables_value *clv;
+ size_t i = 0;
+ HMAP_FOR_EACH (clv, struct ctables_value, node, &t->clabels_values_map)
+ t->clabels_values[i++] = clv;
+ t->n_clabels_values = n;
+ assert (i == n);
+
+ sort (t->clabels_values, n, sizeof *t->clabels_values,
+ compare_clabels_values_3way, &width);
+
+ for (size_t i = 0; i < n; i++)
+ t->clabels_values[i]->leaf = i;
+}
+
+static void
+ctables_add_category_occurrences (const struct variable *var,
+ struct hmap *occurrences,
+ const struct ctables_categories *cats)
+{
+ const struct val_labs *val_labs = var_get_value_labels (var);
+
+ for (size_t i = 0; i < cats->n_cats; i++)
+ {
+ const struct ctables_category *c = &cats->cats[i];
+ switch (c->type)
+ {
+ case CCT_NUMBER:
+ ctables_add_occurrence (var, &(const union value) { .f = c->number },
+ occurrences);
+ break;
+
+ case CCT_STRING:
+ abort (); /* XXX */
+
+ case CCT_RANGE:
+ assert (var_is_numeric (var));
+ for (const struct val_lab *vl = val_labs_first (val_labs); vl;
+ vl = val_labs_next (val_labs, vl))
+ if (vl->value.f >= c->range[0] && vl->value.f <= c->range[1])
+ ctables_add_occurrence (var, &vl->value, occurrences);
+ break;
+
+ case CCT_MISSING:
+ for (const struct val_lab *vl = val_labs_first (val_labs); vl;
+ vl = val_labs_next (val_labs, vl))
+ if (var_is_value_missing (var, &vl->value))
+ ctables_add_occurrence (var, &vl->value, occurrences);
+ break;
+
+ case CCT_OTHERNM:
+ for (const struct val_lab *vl = val_labs_first (val_labs); vl;
+ vl = val_labs_next (val_labs, vl))
+ ctables_add_occurrence (var, &vl->value, occurrences);
+ break;
+
+ case CCT_SUBTOTAL:
+ case CCT_HSUBTOTAL:
+ case CCT_TOTAL:
+ break;
+
+ case CCT_VALUE:
+ case CCT_LABEL:
+ case CCT_FUNCTION:
+ for (const struct val_lab *vl = val_labs_first (val_labs); vl;
+ vl = val_labs_next (val_labs, vl))
+ if (c->include_missing || !var_is_value_missing (var, &vl->value))
+ ctables_add_occurrence (var, &vl->value, occurrences);
+ break;
+ }
+ }
+}
+
+static void
+ctables_section_recurse_add_empty_categories (
+ struct ctables_section *s,
+ const struct ctables_category *cats[PIVOT_N_AXES][10], struct ccase *c,
+ enum pivot_axis_type a, size_t a_idx)
+{
+ if (a >= PIVOT_N_AXES)
+ ctables_cell_insert__ (s, c, cats);
+ else if (!s->nests[a] || a_idx >= s->nests[a]->n)
+ ctables_section_recurse_add_empty_categories (s, cats, c, a + 1, 0);
+ else
+ {
+ const struct variable *var = s->nests[a]->vars[a_idx];
+ int width = var_get_width (var);
+ const struct hmap *occurrences = &s->occurrences[a][a_idx];
+ const struct ctables_section_value *sv;
+ HMAP_FOR_EACH (sv, struct ctables_section_value, node, occurrences)
+ {
+ union value *value = case_data_rw (c, var);
+ value_destroy (value, width);
+ value_clone (value, &sv->value, width);
+ cats[a][a_idx] = ctables_categories_match (
+ s->table->categories[var_get_dict_index (var)], value, var);
+ assert (cats[a][a_idx] != NULL);
+ ctables_section_recurse_add_empty_categories (s, cats, c, a, a_idx + 1);
+ }
+ }
+}
+
+static void
+ctables_section_add_empty_categories (struct ctables_section *s)
+{
+ bool show_empty = false;
+ for (size_t a = 0; a < PIVOT_N_AXES; a++)
+ if (s->nests[a])
+ for (size_t k = 0; k < s->nests[a]->n; k++)
+ if (k != s->nests[a]->scale_idx)
+ {
+ const struct variable *var = s->nests[a]->vars[k];
+ const struct ctables_categories *cats = s->table->categories[
+ var_get_dict_index (var)];
+ if (cats->show_empty)
+ {
+ show_empty = true;
+ ctables_add_category_occurrences (var, &s->occurrences[a][k], cats);
+ }
+ }
+ if (!show_empty)
+ return;
+
+ const struct ctables_category *cats[PIVOT_N_AXES][10]; /* XXX */
+ struct ccase *c = case_create (dict_get_proto (s->table->ctables->dict));
+ ctables_section_recurse_add_empty_categories (s, cats, c, 0, 0);
+ case_unref (c);
+}
+
+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 = proc_open (ds);
+ bool warn_on_invalid = true;
+ for (struct ccase *c = casereader_read (input); c;
+ case_unref (c), c = casereader_read (input))
+ {
+ 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 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);
+
+ for (size_t i = 0; i < ct->n_tables; i++)
+ {
+ struct ctables_table *t = ct->tables[i];
+
+ if (t->clabels_example)
+ ctables_sort_clabels_values (t);
+
+ for (size_t j = 0; j < t->n_sections; j++)
+ ctables_section_add_empty_categories (&t->sections[j]);
+
+ ctables_table_output (ct, ct->tables[i]);
+ }
+ return proc_commit (ds);
+}
+\f
+/* Postcomputes. */
+
+typedef struct ctables_pcexpr *parse_recursively_func (struct lexer *);
+
+static void
+ctables_pcexpr_destroy (struct ctables_pcexpr *e)
+{
+ if (e)
+ {
+ switch (e->op)
+ {
+ case CTPO_CAT_STRING:
+ free (e->string);
+ break;
+
+ case CTPO_ADD:
+ case CTPO_SUB:
+ case CTPO_MUL:
+ case CTPO_DIV:
+ case CTPO_POW:
+ case CTPO_NEG:
+ for (size_t i = 0; i < 2; i++)
+ ctables_pcexpr_destroy (e->subs[i]);
+ break;
+
+ case CTPO_CONSTANT:
+ case CTPO_CAT_NUMBER:
+ case CTPO_CAT_RANGE:
+ case CTPO_CAT_MISSING:
+ case CTPO_CAT_OTHERNM:
+ case CTPO_CAT_SUBTOTAL:
+ case CTPO_CAT_TOTAL:
+ break;
+ }
+
+ msg_location_destroy (e->location);
+ free (e);
+ }
+}
+
+static struct ctables_pcexpr *
+ctables_pcexpr_allocate_binary (enum ctables_postcompute_op op,
+ struct ctables_pcexpr *sub0,
+ struct ctables_pcexpr *sub1)
+{
+ struct ctables_pcexpr *e = xmalloc (sizeof *e);
+ *e = (struct ctables_pcexpr) {
+ .op = op,
+ .subs = { sub0, sub1 },
+ .ofs = { sub0->ofs[0], sub1->ofs[1] }
+ };
+ return e;
+}
+
+static struct msg_location *
+ctables_pcexpr_location (struct lexer *lexer, const struct ctables_pcexpr *e_)
+{
+ if (!e_->location)
+ {
+ struct ctables_pcexpr *e = CONST_CAST (struct ctables_pcexpr *, e_);
+ e->location = lex_ofs_location (lexer, e->ofs[0], e->ofs[1]);
+ }
+ return e_->location;
+}
+
+/* How to parse an operator. */
+struct operator
+ {
+ enum token_type token;
+ enum ctables_postcompute_op op;
+ };
+
+static const struct operator *
+match_operator (struct lexer *lexer, const struct operator ops[], size_t n_ops)
+{
+ for (const struct operator *op = ops; op < ops + n_ops; op++)
+ if (lex_token (lexer) == op->token)
+ {
+ if (op->token != T_NEG_NUM)
+ lex_get (lexer);
+
+ return op;
+ }
+
+ return NULL;
+}
+
+static struct ctables_pcexpr *
+parse_binary_operators__ (struct lexer *lexer,
+ const struct operator ops[], size_t n_ops,
+ parse_recursively_func *parse_next_level,
+ const char *chain_warning,
+ struct ctables_pcexpr *lhs)
+{
+ for (int op_count = 0; ; op_count++)
+ {
+ const struct operator *op = match_operator (lexer, ops, n_ops);
+ if (!op)
+ {
+ if (op_count > 1 && chain_warning)
+ msg_at (SW, ctables_pcexpr_location (lexer, lhs),
+ "%s", chain_warning);
+
+ return lhs;
+ }
+
+ struct ctables_pcexpr *rhs = parse_next_level (lexer);
+ if (!rhs)
+ {
+ ctables_pcexpr_destroy (lhs);
+ return NULL;
+ }
+
+ lhs = ctables_pcexpr_allocate_binary (op->op, lhs, rhs);
+ }
+}
+
+static struct ctables_pcexpr *
+parse_binary_operators (struct lexer *lexer,
+ const struct operator ops[], size_t n_ops,
+ parse_recursively_func *parse_next_level,
+ const char *chain_warning)
+{
+ struct ctables_pcexpr *lhs = parse_next_level (lexer);
+ if (!lhs)
+ return NULL;
+
+ return parse_binary_operators__ (lexer, ops, n_ops, parse_next_level,
+ chain_warning, lhs);
+}
+
+static struct ctables_pcexpr *parse_add (struct lexer *);