X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Fctables.c;h=9dd1fd55a6b43346250bb43b8ed13f7ada6002dc;hb=f5711a3a6d3f28e53513269e774bfa1e8274c1c5;hp=d6b5a0ca0c119c9764e49377d65a286466f5dcf8;hpb=c4b05a4eee788ba23c784e8c077995940eee96a7;p=pspp diff --git a/src/language/stats/ctables.c b/src/language/stats/ctables.c index d6b5a0ca0c..9dd1fd55a6 100644 --- a/src/language/stats/ctables.c +++ b/src/language/stats/ctables.c @@ -33,6 +33,7 @@ #include "libpspp/assertion.h" #include "libpspp/hash-functions.h" #include "libpspp/hmap.h" +#include "libpspp/i18n.h" #include "libpspp/message.h" #include "libpspp/string-array.h" #include "math/mode.h" @@ -188,8 +189,8 @@ enum ctables_summary_variant struct ctables_cell { - /* In struct ctables's 'cells' hmap. Indexed by all the values in all the - axes (except the scalar variable, if any). */ + /* In struct ctables_section's 'cells' hmap. Indexed by all the values in + all the axes (except the scalar variable, if any). */ struct hmap_node node; /* The domains that contain this cell. */ @@ -199,9 +200,8 @@ struct ctables_cell bool hide; enum ctables_summary_variant sv; - struct + struct ctables_cell_axis { - size_t nest_idx; struct ctables_cell_value { const struct ctables_category *category; @@ -217,6 +217,7 @@ struct ctables_cell struct ctables { + const struct dictionary *dict; struct pivot_table_look *look; /* If this is NULL, zeros are displayed using the normal print format. @@ -230,6 +231,8 @@ struct ctables /* Indexed by variable dictionary index. */ enum ctables_vlabel *vlabels; + struct hmap postcomputes; /* Contains "struct ctables_postcompute"s. */ + bool mrsets_count_duplicates; /* MRSETS. */ bool smissing_listwise; /* SMISSING. */ struct variable *e_weight; /* WEIGHT. */ @@ -242,25 +245,36 @@ struct ctables struct ctables_postcompute { struct hmap_node hmap_node; /* In struct ctables's 'pcompute' hmap. */ - const char *name; /* Name, without leading &. */ + char *name; /* Name, without leading &. */ - struct ctables_postcompute_expr *expr; + struct msg_location *location; /* Location of definition. */ + struct ctables_pcexpr *expr; char *label; - /* XXX FORMAT */ + struct ctables_summary_spec_set *specs; bool hide_source_cats; }; -struct ctables_postcompute_expr +struct ctables_pcexpr { + /* Precedence table: + + () + ** + - + * / + - + + */ enum ctables_postcompute_op { /* Terminals. */ - CTPO_CAT_NUMBER, - CTPO_CAT_STRING, - CTPO_CAT_RANGE, - CTPO_CAT_MISSING, - /* XXX OTHERNM */ - /* XXX SUBTOTAL and HSUBTOTAL */ + CTPO_CONSTANT, /* 5 */ + CTPO_CAT_NUMBER, /* [5] */ + CTPO_CAT_STRING, /* ["STRING"] */ + CTPO_CAT_RANGE, /* [LO THRU 5] */ + CTPO_CAT_MISSING, /* MISSING */ + CTPO_CAT_OTHERNM, /* OTHERNM */ + CTPO_CAT_SUBTOTAL, /* SUBTOTAL */ + CTPO_CAT_TOTAL, /* TOTAL */ /* Nonterminals. */ CTPO_ADD, @@ -268,24 +282,39 @@ struct ctables_postcompute_expr CTPO_MUL, CTPO_DIV, CTPO_POW, + CTPO_NEG, } op; union { - /* CTPO_CAT_NUMBER, CTPO_NUMBER. */ + /* CTPO_CAT_NUMBER. */ double number; - /* CTPO_CAT_RANGE. + /* CTPO_CAT_STRING. */ + char *string; - XXX what about string ranges? */ + /* CTPO_CAT_RANGE. */ double range[2]; - /* CTPO_ADD, CTPO_SUB, CTPO_MUL, CTPO_DIV, CTPO_POW. */ - struct ctables_postcompute_expr *subs[2]; + /* CTPO_CAT_SUBTOTAL. */ + size_t subtotal_index; + + /* Two elements: CTPO_ADD, CTPO_SUB, CTPO_MUL, CTPO_DIV, CTPO_POW. + One element: CTPO_NEG. */ + struct ctables_pcexpr *subs[2]; }; + + /* Source location. */ + int ofs[2]; + struct msg_location *location; }; +static void ctables_pcexpr_destroy (struct ctables_pcexpr *); +static struct ctables_pcexpr *ctables_pcexpr_allocate_binary ( + enum ctables_postcompute_op, struct ctables_pcexpr *sub0, + struct ctables_pcexpr *sub1); + struct ctables_summary_spec_set { struct ctables_summary_spec *specs; @@ -325,14 +354,30 @@ struct ctables_value int leaf; }; +struct ctables_section_value + { + struct hmap_node node; + union value value; + }; + +struct ctables_section + { + struct ctables_table *table; + struct ctables_nest *nests[PIVOT_N_AXES]; + struct hmap *occurrences[PIVOT_N_AXES]; + struct hmap cells; /* Contains "struct ctable_cell"s. */ + struct hmap domains[N_CTDTS]; /* Contains "struct ctable_domain"s. */ + }; + struct ctables_table { + struct ctables *ctables; struct ctables_axis *axes[PIVOT_N_AXES]; struct ctables_stack stacks[PIVOT_N_AXES]; + struct ctables_section *sections; + size_t n_sections; enum pivot_axis_type summary_axis; struct ctables_summary_spec_set summary_specs; - struct hmap cells; - struct hmap domains[N_CTDTS]; const struct variable *clabels_example; struct hmap clabels_values_map; @@ -404,16 +449,19 @@ struct ctables_category { enum ctables_category_type { + /* Explicit category lists. */ CCT_NUMBER, CCT_STRING, CCT_RANGE, CCT_MISSING, CCT_OTHERNM, + /* Totals and subtotals. */ CCT_SUBTOTAL, CCT_HSUBTOTAL, CCT_TOTAL, + /* Implicit category lists. */ CCT_VALUE, CCT_LABEL, CCT_FUNCTION, @@ -1266,7 +1314,7 @@ ctables_table_parse_categories (struct lexer *lexer, struct dictionary *dict, return false; struct ctables_categories *c = xmalloc (sizeof *c); - *c = (struct ctables_categories) { .n_refs = n_vars }; + *c = (struct ctables_categories) { .n_refs = n_vars, .show_empty = true }; for (size_t i = 0; i < n_vars; i++) { struct ctables_categories **cp @@ -1308,8 +1356,6 @@ ctables_table_parse_categories (struct lexer *lexer, struct dictionary *dict, lex_get (lexer); if (lex_match_id (lexer, "THRU")) { - cat->type = CCT_RANGE; - cat->range[0] = number; if (lex_match_id (lexer, "HI")) *cat = cct_range (number, DBL_MAX); else @@ -2265,7 +2311,7 @@ ctables_summary_value (const struct ctables_cell *cell, struct ctables_cell_sort_aux { - const struct ctables_table *t; + const struct ctables_nest *nest; enum pivot_axis_type a; }; @@ -2278,12 +2324,7 @@ ctables_cell_compare_3way (const void *a_, const void *b_, const void *aux_) const struct ctables_cell *a = *ap; const struct ctables_cell *b = *bp; - size_t a_idx = a->axes[aux->a].nest_idx; - size_t b_idx = b->axes[aux->a].nest_idx; - if (a_idx != b_idx) - return a_idx < b_idx ? -1 : 1; - - const struct ctables_nest *nest = &aux->t->stacks[aux->a].nests[a_idx]; + const struct ctables_nest *nest = aux->nest; for (size_t i = 0; i < nest->n; i++) if (i != nest->scale_idx) { @@ -2362,15 +2403,13 @@ ctables_cell_compare_3way (const void *a_, const void *b_, const void *aux_) */ static struct ctables_domain * -ctables_domain_insert (struct ctables_table *t, struct ctables_cell *cell, +ctables_domain_insert (struct ctables_section *s, struct ctables_cell *cell, enum ctables_domain_type domain) { size_t hash = 0; for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) { - size_t idx = cell->axes[a].nest_idx; - const struct ctables_nest *nest = &t->stacks[a].nests[idx]; - hash = hash_int (idx, hash); + const struct ctables_nest *nest = s->nests[a]; for (size_t i = 0; i < nest->n_domains[domain]; i++) { size_t v_idx = nest->domains[domain][i]; @@ -2380,16 +2419,12 @@ ctables_domain_insert (struct ctables_table *t, struct ctables_cell *cell, } struct ctables_domain *d; - HMAP_FOR_EACH_WITH_HASH (d, struct ctables_domain, node, hash, &t->domains[domain]) + HMAP_FOR_EACH_WITH_HASH (d, struct ctables_domain, node, hash, &s->domains[domain]) { const struct ctables_cell *df = d->example; for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) { - size_t idx = cell->axes[a].nest_idx; - if (idx != df->axes[a].nest_idx) - goto not_equal; - - const struct ctables_nest *nest = &t->stacks[a].nests[idx]; + const struct ctables_nest *nest = s->nests[a]; for (size_t i = 0; i < nest->n_domains[domain]; i++) { size_t v_idx = nest->domains[domain][i]; @@ -2406,7 +2441,7 @@ ctables_domain_insert (struct ctables_table *t, struct ctables_cell *cell, d = xmalloc (sizeof *d); *d = (struct ctables_domain) { .example = cell }; - hmap_insert (&t->domains[domain], &d->node, hash); + hmap_insert (&s->domains[domain], &d->node, hash); return d; } @@ -2471,18 +2506,16 @@ ctables_categories_total (const struct ctables_categories *c) } static struct ctables_cell * -ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c, - size_t ix[PIVOT_N_AXES], +ctables_cell_insert__ (struct ctables_section *s, const struct ccase *c, const struct ctables_category *cats[PIVOT_N_AXES][10]) { - const struct ctables_nest *ss = &t->stacks[t->summary_axis].nests[ix[t->summary_axis]]; + const struct ctables_nest *ss = s->nests[s->table->summary_axis]; size_t hash = 0; enum ctables_summary_variant sv = CSV_CELL; for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) { - const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]]; - hash = hash_int (ix[a], hash); + const struct ctables_nest *nest = s->nests[a]; for (size_t i = 0; i < nest->n; i++) if (i != nest->scale_idx) { @@ -2498,13 +2531,11 @@ ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c, } struct ctables_cell *cell; - HMAP_FOR_EACH_WITH_HASH (cell, struct ctables_cell, node, hash, &t->cells) + HMAP_FOR_EACH_WITH_HASH (cell, struct ctables_cell, node, hash, &s->cells) { for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) { - const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]]; - if (cell->axes[a].nest_idx != ix[a]) - goto not_equal; + const struct ctables_nest *nest = s->nests[a]; for (size_t i = 0; i < nest->n; i++) if (i != nest->scale_idx && (cats[a][i] != cell->axes[a].cvs[i].category @@ -2528,8 +2559,7 @@ ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c, 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].nest_idx = ix[a]; + const struct ctables_nest *nest = s->nests[a]; cell->axes[a].cvs = (nest->n ? xnmalloc (nest->n, sizeof *cell->axes[a].cvs) : NULL); @@ -2558,19 +2588,18 @@ ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c, for (size_t i = 0; i < specs->n; i++) ctables_summary_init (&cell->summaries[i], &specs->specs[i]); for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++) - cell->domains[dt] = ctables_domain_insert (t, cell, dt); - hmap_insert (&t->cells, &cell->node, hash); + cell->domains[dt] = ctables_domain_insert (s, cell, dt); + hmap_insert (&s->cells, &cell->node, hash); return cell; } static void -ctables_cell_add__ (struct ctables_table *t, const struct ccase *c, - size_t ix[PIVOT_N_AXES], +ctables_cell_add__ (struct ctables_section *s, const struct ccase *c, const struct ctables_category *cats[PIVOT_N_AXES][10], double d_weight, double e_weight) { - struct ctables_cell *cell = ctables_cell_insert__ (t, c, ix, cats); - const struct ctables_nest *ss = &t->stacks[t->summary_axis].nests[ix[t->summary_axis]]; + struct ctables_cell *cell = ctables_cell_insert__ (s, c, cats); + const struct ctables_nest *ss = s->nests[s->table->summary_axis]; const struct ctables_summary_spec_set *specs = &ss->specs[cell->sv]; for (size_t i = 0; i < specs->n; i++) @@ -2587,15 +2616,14 @@ ctables_cell_add__ (struct ctables_table *t, const struct ccase *c, } static void -recurse_totals (struct ctables_table *t, const struct ccase *c, - size_t ix[PIVOT_N_AXES], +recurse_totals (struct ctables_section *s, const struct ccase *c, const struct ctables_category *cats[PIVOT_N_AXES][10], double d_weight, double e_weight, enum pivot_axis_type start_axis, size_t start_nest) { for (enum pivot_axis_type a = start_axis; a < PIVOT_N_AXES; a++) { - const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]]; + const struct ctables_nest *nest = s->nests[a]; for (size_t i = start_nest; i < nest->n; i++) { if (i == nest->scale_idx) @@ -2604,13 +2632,13 @@ recurse_totals (struct ctables_table *t, const struct ccase *c, const struct variable *var = nest->vars[i]; const struct ctables_category *total = ctables_categories_total ( - t->categories[var_get_dict_index (var)]); + s->table->categories[var_get_dict_index (var)]); if (total) { const struct ctables_category *save = cats[a][i]; cats[a][i] = total; - ctables_cell_add__ (t, c, ix, cats, d_weight, e_weight); - recurse_totals (t, c, ix, cats, d_weight, e_weight, a, i + 1); + ctables_cell_add__ (s, c, cats, d_weight, e_weight); + recurse_totals (s, c, cats, d_weight, e_weight, a, i + 1); cats[a][i] = save; } } @@ -2619,15 +2647,14 @@ recurse_totals (struct ctables_table *t, const struct ccase *c, } static void -recurse_subtotals (struct ctables_table *t, const struct ccase *c, - size_t ix[PIVOT_N_AXES], +recurse_subtotals (struct ctables_section *s, const struct ccase *c, const struct ctables_category *cats[PIVOT_N_AXES][10], double d_weight, double e_weight, enum pivot_axis_type start_axis, size_t start_nest) { for (enum pivot_axis_type a = start_axis; a < PIVOT_N_AXES; a++) { - const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]]; + const struct ctables_nest *nest = s->nests[a]; for (size_t i = start_nest; i < nest->n; i++) { if (i == nest->scale_idx) @@ -2637,8 +2664,8 @@ recurse_subtotals (struct ctables_table *t, const struct ccase *c, if (save->subtotal) { cats[a][i] = save->subtotal; - ctables_cell_add__ (t, c, ix, cats, d_weight, e_weight); - recurse_subtotals (t, c, ix, cats, d_weight, e_weight, a, i + 1); + ctables_cell_add__ (s, c, cats, d_weight, e_weight); + recurse_subtotals (s, c, cats, d_weight, e_weight, a, i + 1); cats[a][i] = save; } } @@ -2647,15 +2674,33 @@ recurse_subtotals (struct ctables_table *t, const struct ccase *c, } static void -ctables_cell_insert (struct ctables_table *t, +ctables_add_occurrence (const struct variable *var, + const union value *value, + struct hmap *occurrences) +{ + int width = var_get_width (var); + unsigned int hash = value_hash (value, width, 0); + + struct ctables_section_value *sv; + HMAP_FOR_EACH_WITH_HASH (sv, struct ctables_section_value, node, hash, + occurrences) + if (value_equal (value, &sv->value, width)) + return; + + sv = xmalloc (sizeof *sv); + value_clone (&sv->value, value, width); + hmap_insert (occurrences, &sv->node, hash); +} + +static void +ctables_cell_insert (struct ctables_section *s, const struct ccase *c, - size_t ix[PIVOT_N_AXES], double d_weight, double e_weight) { - const struct ctables_category *cats[PIVOT_N_AXES][10]; + const struct ctables_category *cats[PIVOT_N_AXES][10]; /* XXX */ for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) { - const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]]; + const struct ctables_nest *nest = s->nests[a]; for (size_t i = 0; i < nest->n; i++) { if (i == nest->scale_idx) @@ -2668,16 +2713,28 @@ ctables_cell_insert (struct ctables_table *t, return; cats[a][i] = ctables_categories_match ( - t->categories[var_get_dict_index (var)], value, var); + s->table->categories[var_get_dict_index (var)], value, var); if (!cats[a][i]) return; } } - ctables_cell_add__ (t, c, ix, cats, d_weight, e_weight); + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + { + const struct ctables_nest *nest = s->nests[a]; + for (size_t i = 0; i < nest->n; i++) + if (i != nest->scale_idx) + { + const struct variable *var = nest->vars[i]; + const union value *value = case_data (c, var); + ctables_add_occurrence (var, value, &s->occurrences[a][i]); + } + } + + ctables_cell_add__ (s, c, cats, d_weight, e_weight); - recurse_totals (t, c, ix, cats, d_weight, e_weight, 0, 0); - recurse_subtotals (t, c, ix, cats, d_weight, e_weight, 0, 0); + recurse_totals (s, c, cats, d_weight, e_weight, 0, 0); + recurse_subtotals (s, c, cats, d_weight, e_weight, 0, 0); } struct merge_item @@ -2728,6 +2785,37 @@ ctables_value_find (struct ctables_table *t, value_hash (value, width, 0)); } +static void +ctables_table_add_section (struct ctables_table *t, enum pivot_axis_type a, + size_t ix[PIVOT_N_AXES]) +{ + if (a < PIVOT_N_AXES) + { + size_t limit = MAX (t->stacks[a].n, 1); + for (ix[a] = 0; ix[a] < limit; ix[a]++) + ctables_table_add_section (t, a + 1, ix); + } + else + { + struct ctables_section *s = &t->sections[t->n_sections++]; + *s = (struct ctables_section) { + .table = t, + .cells = HMAP_INITIALIZER (s->cells), + }; + for (a = 0; a < PIVOT_N_AXES; a++) + if (t->stacks[a].n) + { + struct ctables_nest *nest = &t->stacks[a].nests[ix[a]]; + s->nests[a] = nest; + s->occurrences[a] = xnmalloc (nest->n, sizeof *s->occurrences[a]); + for (size_t i = 0; i < nest->n; i++) + hmap_init (&s->occurrences[a][i]); + } + for (size_t i = 0; i < N_CTDTS; i++) + hmap_init (&s->domains[i]); + } +} + static void ctables_table_output (struct ctables *ct, struct ctables_table *t) { @@ -2795,207 +2883,228 @@ ctables_table_output (struct ctables *ct, struct ctables_table *t) assert (t->axes[a]); - struct ctables_cell **sorted = xnmalloc (t->cells.count, sizeof *sorted); - size_t n_sorted = 0; + for (size_t i = 0; i < t->stacks[a].n; i++) + { + struct ctables_nest *nest = &t->stacks[a].nests[i]; + struct ctables_section **sections = xnmalloc (t->n_sections, + sizeof *sections); + size_t n_sections = 0; + + size_t n_total_cells = 0; + size_t max_depth = 0; + for (size_t j = 0; j < t->n_sections; j++) + if (t->sections[j].nests[a] == nest) + { + struct ctables_section *s = &t->sections[j]; + sections[n_sections++] = s; + n_total_cells += s->cells.count; - 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 + size_t depth = s->nests[a]->n; + max_depth = MAX (depth, max_depth); + } + + struct ctables_cell **sorted = xnmalloc (n_total_cells, + sizeof *sorted); + size_t n_sorted = 0; + + for (size_t j = 0; j < n_sections; j++) { - CTL_VAR, /* Variable label for nest->vars[var_idx]. */ - CTL_CATEGORY, /* Category for nest->vars[var_idx]. */ - CTL_SUMMARY, /* Summary functions. */ - } - type; + struct ctables_section *s = sections[j]; - size_t var_idx; - }; - struct ctables_level *levels = xnmalloc (1 + 2 * max_depth, sizeof *levels); - size_t n_levels = 0; + struct ctables_cell *cell; + HMAP_FOR_EACH (cell, struct ctables_cell, node, &s->cells) + if (!cell->hide) + sorted[n_sorted++] = cell; + assert (n_sorted <= n_total_cells); + } - struct pivot_category **groups = xnmalloc (1 + 2 * max_depth, sizeof *groups); - int prev_leaf = 0; - for (size_t j = 0; j < n_sorted; j++) - { - struct ctables_cell *cell = sorted[j]; - struct ctables_cell *prev = j > 0 ? sorted[j - 1] : NULL; - const struct ctables_nest *nest = &t->stacks[a].nests[cell->axes[a].nest_idx]; + struct ctables_cell_sort_aux aux = { .nest = nest, .a = a }; + sort (sorted, n_sorted, sizeof *sorted, ctables_cell_compare_3way, &aux); - bool new_subtable = !prev || prev->axes[a].nest_idx != cell->axes[a].nest_idx; - if (new_subtable) + struct ctables_level { - n_levels = 0; - for (size_t k = 0; k < nest->n; k++) + enum ctables_level_type { - enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (nest->vars[k])]; - if (vlabel != CTVL_NONE) - { - levels[n_levels++] = (struct ctables_level) { - .type = CTL_VAR, - .var_idx = k, - }; - } + CTL_VAR, /* Variable label for nest->vars[var_idx]. */ + CTL_CATEGORY, /* Category for nest->vars[var_idx]. */ + CTL_SUMMARY, /* Summary functions. */ + } + type; - if (nest->scale_idx != k - && (k != nest->n - 1 || t->label_axis[a] == a)) - { - levels[n_levels++] = (struct ctables_level) { - .type = CTL_CATEGORY, - .var_idx = k, - }; - } + size_t var_idx; + }; + struct ctables_level *levels = xnmalloc (1 + 2 * max_depth, sizeof *levels); + size_t n_levels = 0; + for (size_t k = 0; k < nest->n; k++) + { + enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (nest->vars[k])]; + if (vlabel != CTVL_NONE) + { + levels[n_levels++] = (struct ctables_level) { + .type = CTL_VAR, + .var_idx = k, + }; } - if (!summary_dimension && a == t->slabels_axis) + if (nest->scale_idx != k + && (k != nest->n - 1 || t->label_axis[a] == a)) { levels[n_levels++] = (struct ctables_level) { - .type = CTL_SUMMARY, - .var_idx = SIZE_MAX, + .type = CTL_CATEGORY, + .var_idx = k, }; } } - size_t n_common = 0; - if (!new_subtable) + if (!summary_dimension && a == t->slabels_axis) { - for (; n_common < n_levels; n_common++) - { - const struct ctables_level *level = &levels[n_common]; - if (level->type == CTL_CATEGORY) - { - size_t var_idx = level->var_idx; - const struct ctables_category *c = cell->axes[a].cvs[var_idx].category; - if (prev->axes[a].cvs[var_idx].category != c) - break; - else if (c->type != CCT_SUBTOTAL - && c->type != CCT_HSUBTOTAL - && c->type != CCT_TOTAL - && !value_equal (&prev->axes[a].cvs[var_idx].value, - &cell->axes[a].cvs[var_idx].value, - var_get_type (nest->vars[var_idx]))) - break; - } - } + levels[n_levels++] = (struct ctables_level) { + .type = CTL_SUMMARY, + .var_idx = SIZE_MAX, + }; } - for (size_t k = n_common; k < n_levels; k++) + /* Pivot categories: + + - variable label for nest->vars[0], if vlabel != CTVL_NONE + - category for nest->vars[0], if nest->scale_idx != 0 + - variable label for nest->vars[1], if vlabel != CTVL_NONE + - category for nest->vars[1], if nest->scale_idx != 1 + ... + - variable label for nest->vars[n - 1], if vlabel != CTVL_NONE + - category for nest->vars[n - 1], if t->label_axis[a] == a && nest->scale_idx != n - 1. + - summary function, if 'a == t->slabels_axis && a == + t->summary_axis'. + + Additional dimensions: + + - If 'a == t->slabels_axis && a != t->summary_axis', add a summary + dimension. + - If 't->label_axis[b] == a' for some 'b != a', add a category + dimension to 'a'. + */ + + + struct pivot_category **groups = xnmalloc (1 + 2 * max_depth, sizeof *groups); + int prev_leaf = 0; + for (size_t j = 0; j < n_sorted; j++) { - const struct ctables_level *level = &levels[k]; - struct pivot_category *parent = k ? groups[k - 1] : d[a]->root; - if (level->type == CTL_SUMMARY) - { - assert (k == n_levels - 1); + struct ctables_cell *cell = sorted[j]; + struct ctables_cell *prev = j > 0 ? sorted[j - 1] : NULL; - const struct ctables_summary_spec_set *specs = &t->summary_specs; - for (size_t m = 0; m < specs->n; m++) + size_t n_common = 0; + if (j > 0) + { + for (; n_common < n_levels; n_common++) { - int leaf = pivot_category_create_leaf ( - parent, pivot_value_new_text (specs->specs[m].label)); - if (!m) - prev_leaf = leaf; + const struct ctables_level *level = &levels[n_common]; + if (level->type == CTL_CATEGORY) + { + size_t var_idx = level->var_idx; + const struct ctables_category *c = cell->axes[a].cvs[var_idx].category; + if (prev->axes[a].cvs[var_idx].category != c) + break; + else if (c->type != CCT_SUBTOTAL + && c->type != CCT_HSUBTOTAL + && c->type != CCT_TOTAL + && !value_equal (&prev->axes[a].cvs[var_idx].value, + &cell->axes[a].cvs[var_idx].value, + var_get_type (nest->vars[var_idx]))) + break; + } } } - else + + for (size_t k = n_common; k < n_levels; k++) { - 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_level *level = &levels[k]; + struct pivot_category *parent = k ? groups[k - 1] : d[a]->root; + if (level->type == CTL_SUMMARY) { - const struct ctables_cell_value *cv = &cell->axes[a].cvs[level->var_idx]; - label = ctables_category_create_label (cv->category, - var, &cv->value); + assert (k == n_levels - 1); + + const struct ctables_summary_spec_set *specs = &t->summary_specs; + for (size_t m = 0; m < specs->n; m++) + { + int leaf = pivot_category_create_leaf ( + parent, pivot_value_new_text (specs->specs[m].label)); + if (!m) + prev_leaf = leaf; + } } else - NOT_REACHED (); + { + 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) - prev_leaf = pivot_category_create_leaf (parent, label); - else - groups[k] = pivot_category_create_group__ (parent, label); + if (k == n_levels - 1) + prev_leaf = pivot_category_create_leaf (parent, label); + else + groups[k] = pivot_category_create_group__ (parent, label); + } } - } - cell->axes[a].leaf = prev_leaf; + cell->axes[a].leaf = prev_leaf; + } + free (sorted); + free (groups); } - free (sorted); - free (groups); } - struct ctables_cell *cell; - HMAP_FOR_EACH (cell, struct ctables_cell, node, &t->cells) + for (size_t i = 0; i < t->n_sections; i++) { - if (cell->hide) - continue; + struct ctables_section *s = &t->sections[i]; - const struct ctables_nest *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++) + struct ctables_cell *cell; + HMAP_FOR_EACH (cell, struct ctables_cell, node, &s->cells) { - size_t dindexes[5]; - size_t n_dindexes = 0; - - if (summary_dimension) - dindexes[n_dindexes++] = specs->specs[j].axis_idx; + if (cell->hide) + continue; - if (categories_dimension) + 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++) { - 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; - } + size_t dindexes[5]; + size_t n_dindexes = 0; - 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; - } + if (summary_dimension) + dindexes[n_dindexes++] = specs->specs[j].axis_idx; - double d = ctables_summary_value (cell, &cell->summaries[j], &specs->specs[j]); - struct pivot_value *value = pivot_value_new_number (d); - value->numeric.format = specs->specs[j].format; - pivot_table_put (pt, dindexes, n_dindexes, value); + if (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); + } } } @@ -3312,9 +3421,134 @@ ctables_sort_clabels_values (struct ctables_table *t) 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; @@ -3332,18 +3566,8 @@ ctables_execute (struct dataset *ds, struct ctables *ct) { struct ctables_table *t = ct->tables[i]; - for (size_t ir = 0; ir < t->stacks[PIVOT_AXIS_ROW].n; ir++) - for (size_t ic = 0; ic < t->stacks[PIVOT_AXIS_COLUMN].n; ic++) - for (size_t il = 0; il < t->stacks[PIVOT_AXIS_LAYER].n; il++) - { - 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 (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) @@ -3359,10 +3583,547 @@ ctables_execute (struct dataset *ds, struct ctables *ct) 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); } + +/* 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 *); + +static struct ctables_pcexpr +ctpo_cat_range (double low, double high) +{ + return (struct ctables_pcexpr) { + .op = CTPO_CAT_RANGE, + .range = { low, high }, + }; +} + +static struct ctables_pcexpr * +parse_primary (struct lexer *lexer) +{ + int start_ofs = lex_ofs (lexer); + struct ctables_pcexpr e; + if (lex_is_number (lexer)) + { + e = (struct ctables_pcexpr) { .op = CTPO_CONSTANT, + .number = lex_number (lexer) }; + lex_get (lexer); + } + else if (lex_match_id (lexer, "MISSING")) + e = (struct ctables_pcexpr) { .op = CTPO_CAT_MISSING }; + else if (lex_match_id (lexer, "OTHERNM")) + e = (struct ctables_pcexpr) { .op = CTPO_CAT_OTHERNM }; + else if (lex_match_id (lexer, "TOTAL")) + e = (struct ctables_pcexpr) { .op = CTPO_CAT_TOTAL }; + else if (lex_match_id (lexer, "SUBTOTAL")) + { + size_t subtotal_index = 0; + if (lex_match (lexer, T_LBRACK)) + { + if (!lex_force_int_range (lexer, "SUBTOTAL", 1, LONG_MAX)) + return NULL; + subtotal_index = lex_integer (lexer); + lex_get (lexer); + if (!lex_force_match (lexer, T_RBRACK)) + return NULL; + } + e = (struct ctables_pcexpr) { .op = CTPO_CAT_SUBTOTAL, + .subtotal_index = subtotal_index }; + } + else if (lex_match (lexer, T_LBRACK)) + { + if (lex_match_id (lexer, "LO")) + { + if (!lex_force_match_id (lexer, "THRU") || lex_force_num (lexer)) + return false; + e = ctpo_cat_range (-DBL_MAX, lex_number (lexer)); + lex_get (lexer); + } + else if (lex_is_number (lexer)) + { + double number = lex_number (lexer); + lex_get (lexer); + if (lex_match_id (lexer, "THRU")) + { + if (lex_match_id (lexer, "HI")) + e = ctpo_cat_range (number, DBL_MAX); + else + { + if (!lex_force_num (lexer)) + return false; + e = ctpo_cat_range (number, lex_number (lexer)); + lex_get (lexer); + } + } + else + e = (struct ctables_pcexpr) { .op = CTPO_CAT_NUMBER, + .number = number }; + } + else if (lex_is_string (lexer)) + { + e = (struct ctables_pcexpr) { + .op = CTPO_CAT_STRING, + .string = ss_xstrdup (lex_tokss (lexer)), + }; + lex_get (lexer); + } + else + { + lex_error (lexer, NULL); + return NULL; + } + + if (!lex_force_match (lexer, T_RBRACK)) + { + if (e.op == CTPO_CAT_STRING) + free (e.string); + return NULL; + } + } + else if (lex_match (lexer, T_LPAREN)) + { + struct ctables_pcexpr *ep = parse_add (lexer); + if (!ep) + return NULL; + if (!lex_force_match (lexer, T_RPAREN)) + { + ctables_pcexpr_destroy (ep); + return NULL; + } + return ep; + } + else + { + lex_error (lexer, NULL); + return NULL; + } + + e.ofs[0] = start_ofs; + e.ofs[1] = lex_ofs (lexer) - 1; + return xmemdup (&e, sizeof e); +} + +static struct ctables_pcexpr * +ctables_pcexpr_allocate_neg (struct ctables_pcexpr *sub, + struct lexer *lexer, int start_ofs) +{ + struct ctables_pcexpr *e = xmalloc (sizeof *e); + *e = (struct ctables_pcexpr) { + .op = CTPO_NEG, + .subs = { sub }, + .ofs = { start_ofs, lex_ofs (lexer) - 1 }, + }; + return e; +} + +static struct ctables_pcexpr * +parse_exp (struct lexer *lexer) +{ + static const struct operator op = { T_EXP, CTPO_POW }; + + const char *chain_warning = + _("The exponentiation operator (`**') is left-associative: " + "`a**b**c' equals `(a**b)**c', not `a**(b**c)'. " + "To disable this warning, insert parentheses."); + + if (lex_token (lexer) != T_NEG_NUM || lex_next_token (lexer, 1) != T_EXP) + return parse_binary_operators (lexer, &op, 1, + parse_primary, chain_warning); + + /* Special case for situations like "-5**6", which must be parsed as + -(5**6). */ + + int start_ofs = lex_ofs (lexer); + struct ctables_pcexpr *lhs = xmalloc (sizeof *lhs); + *lhs = (struct ctables_pcexpr) { + .op = CTPO_CONSTANT, + .number = -lex_tokval (lexer), + .ofs = { start_ofs, lex_ofs (lexer) }, + }; + lex_get (lexer); + + struct ctables_pcexpr *node = parse_binary_operators__ ( + lexer, &op, 1, parse_primary, chain_warning, lhs); + if (!node) + return NULL; + + return ctables_pcexpr_allocate_neg (node, lexer, start_ofs); +} + +/* Parses the unary minus level. */ +static struct ctables_pcexpr * +parse_neg (struct lexer *lexer) +{ + int start_ofs = lex_ofs (lexer); + if (!lex_match (lexer, T_DASH)) + return parse_exp (lexer); + + struct ctables_pcexpr *inner = parse_neg (lexer); + if (!inner) + return NULL; + + return ctables_pcexpr_allocate_neg (inner, lexer, start_ofs); +} + +/* Parses the multiplication and division level. */ +static struct ctables_pcexpr * +parse_mul (struct lexer *lexer) +{ + static const struct operator ops[] = + { + { T_ASTERISK, CTPO_MUL }, + { T_SLASH, CTPO_DIV }, + }; + + return parse_binary_operators (lexer, ops, sizeof ops / sizeof *ops, + parse_neg, NULL); +} + +/* Parses the addition and subtraction level. */ +static struct ctables_pcexpr * +parse_add (struct lexer *lexer) +{ + static const struct operator ops[] = + { + { T_PLUS, CTPO_ADD }, + { T_DASH, CTPO_SUB }, + { T_NEG_NUM, CTPO_ADD }, + }; + + return parse_binary_operators (lexer, ops, sizeof ops / sizeof *ops, + parse_mul, NULL); +} + +static struct ctables_postcompute * +ctables_find_postcompute (struct ctables *ct, const char *name) +{ + struct ctables_postcompute *pc; + HMAP_FOR_EACH_WITH_HASH (pc, struct ctables_postcompute, hmap_node, + utf8_hash_case_string (name, 0), &ct->postcomputes) + if (!utf8_strcasecmp (pc->name, name)) + return pc; + return NULL; +} + +static bool +ctables_parse_pcompute (struct lexer *lexer, struct ctables *ct) +{ + int start_ofs = lex_ofs (lexer) - 1; + + if (!lex_force_match (lexer, T_AND) || !lex_force_id (lexer)) + return false; + + char *name = ss_xstrdup (lex_tokss (lexer)); + + lex_get (lexer); + if (!lex_force_match (lexer, T_EQUALS) + || !lex_force_match_id (lexer, "EXPR") + || !lex_force_match (lexer, T_LPAREN)) + { + free (name); + return false; + } + + struct ctables_pcexpr *expr = parse_add (lexer); + if (!expr || !lex_force_match (lexer, T_RPAREN)) + { + free (name); + return false; + } + + struct msg_location *location = lex_ofs_location (lexer, start_ofs, + lex_ofs (lexer) - 1); + + struct ctables_postcompute *pc = ctables_find_postcompute (ct, name); + if (pc) + { + msg_at (SW, location, _("New definition of &%s will override the " + "previous definition."), + pc->name); + msg_at (SN, pc->location, _("This is the previous definition.")); + + ctables_pcexpr_destroy (pc->expr); + msg_location_destroy (pc->location); + free (name); + } + else + { + pc = xmalloc (sizeof *pc); + *pc = (struct ctables_postcompute) { .name = name }; + hmap_insert (&ct->postcomputes, &pc->hmap_node, + utf8_hash_case_string (pc->name, 0)); + } + pc->expr = expr; + pc->location = location; + return true; +} + +static bool +ctables_parse_pproperties_format (struct lexer *lexer, + struct ctables_summary_spec_set *sss) +{ + *sss = (struct ctables_summary_spec_set) { .n = 0 }; + + while (lex_token (lexer) != T_ENDCMD && lex_token (lexer) != T_SLASH + && !(lex_token (lexer) == T_ID + && (lex_id_match (ss_cstr ("LABEL"), lex_tokss (lexer)) + || lex_id_match (ss_cstr ("HIDESOURCECATS"), + lex_tokss (lexer))))) + { + /* Parse function. */ + enum ctables_summary_function function; + if (!parse_ctables_summary_function (lexer, &function)) + goto error; + + /* Parse percentile. */ + double percentile = 0; + if (function == CTSF_PTILE) + { + if (!lex_force_num_range_closed (lexer, "PTILE", 0, 100)) + goto error; + percentile = lex_number (lexer); + lex_get (lexer); + } + + /* Parse format. */ + struct fmt_spec format; + if (!parse_format_specifier (lexer, &format) + || !fmt_check_output (&format) + || !fmt_check_type_compat (&format, VAL_NUMERIC)) + goto error; + + if (sss->n >= sss->allocated) + sss->specs = x2nrealloc (sss->specs, &sss->allocated, + sizeof *sss->specs); + sss->specs[sss->n++] = (struct ctables_summary_spec) { + .function = function, + .percentile = percentile, + .format = format, + }; + } + return true; + +error: + ctables_summary_spec_set_uninit (sss); + return false; +} + +static bool +ctables_parse_pproperties (struct lexer *lexer, struct ctables *ct) +{ + struct ctables_postcompute **pcs = NULL; + size_t n_pcs = 0; + size_t allocated_pcs = 0; + + while (lex_match (lexer, T_AND)) + { + if (!lex_force_id (lexer)) + goto error; + struct ctables_postcompute *pc + = ctables_find_postcompute (ct, lex_tokcstr (lexer)); + if (!pc) + { + msg (SE, _("Unknown computed category &%s."), lex_tokcstr (lexer)); + goto error; + } + lex_get (lexer); + + if (n_pcs >= allocated_pcs) + pcs = x2nrealloc (pcs, &allocated_pcs, sizeof *pcs); + pcs[n_pcs++] = pc; + } + + while (lex_token (lexer) != T_SLASH && lex_token (lexer) != T_ENDCMD) + { + if (lex_match_id (lexer, "LABEL")) + { + lex_match (lexer, T_EQUALS); + if (!lex_force_string (lexer)) + goto error; + + for (size_t i = 0; i < n_pcs; i++) + { + free (pcs[i]->label); + pcs[i]->label = ss_xstrdup (lex_tokss (lexer)); + } + + lex_get (lexer); + } + else if (lex_match_id (lexer, "FORMAT")) + { + lex_match (lexer, T_EQUALS); + + struct ctables_summary_spec_set sss; + if (!ctables_parse_pproperties_format (lexer, &sss)) + goto error; + + for (size_t i = 0; i < n_pcs; i++) + { + if (pcs[i]->specs) + ctables_summary_spec_set_uninit (pcs[i]->specs); + else + pcs[i]->specs = xmalloc (sizeof *pcs[i]->specs); + ctables_summary_spec_set_clone (pcs[i]->specs, &sss); + } + ctables_summary_spec_set_uninit (&sss); + } + else if (lex_match_id (lexer, "HIDESOURCECATS")) + { + lex_match (lexer, T_EQUALS); + bool hide_source_cats; + if (!parse_bool (lexer, &hide_source_cats)) + goto error; + for (size_t i = 0; i < n_pcs; i++) + pcs[i]->hide_source_cats = hide_source_cats; + } + else + { + lex_error_expecting (lexer, "LABEL", "FORMAT", "HIDESOURCECATS"); + goto error; + } + } + free (pcs); + return true; + +error: + free (pcs); + return false; +} int cmd_ctables (struct lexer *lexer, struct dataset *ds) @@ -3375,9 +4136,11 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) struct ctables *ct = xmalloc (sizeof *ct); *ct = (struct ctables) { + .dict = dataset_dict (ds), .look = pivot_table_look_unshare (pivot_table_look_ref ( pivot_table_look_get_default ())), .vlabels = vlabels, + .postcomputes = HMAP_INITIALIZER (ct->postcomputes), .hide_threshold = 5, }; ct->look->omit_empty = false; @@ -3537,7 +4300,16 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) goto error; } } - /* XXX PCOMPUTE */ + else if (lex_match_id (lexer, "PCOMPUTE")) + { + if (!ctables_parse_pcompute (lexer, ct)) + goto error; + } + else if (lex_match_id (lexer, "PPROPERTIES")) + { + if (!ctables_parse_pproperties (lexer, ct)) + goto error; + } else if (lex_match_id (lexer, "WEIGHT")) { if (!lex_force_match_id (lexer, "VARIABLE")) @@ -3589,6 +4361,7 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) .n_refs = n_vars, .cats = cat, .n_cats = 1, + .show_empty = true, }; struct ctables_categories **categories = xnmalloc (n_vars, @@ -3598,7 +4371,7 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) struct ctables_table *t = xmalloc (sizeof *t); *t = (struct ctables_table) { - .cells = HMAP_INITIALIZER (t->cells), + .ctables = ct, .slabels_axis = PIVOT_AXIS_COLUMN, .slabels_visible = true, .clabels_values_map = HMAP_INITIALIZER (t->clabels_values_map), @@ -3612,8 +4385,6 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) .n_categories = n_vars, .cilevel = 95, }; - for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++) - hmap_init (&t->domains[dt]); ct->tables[ct->n_tables++] = t; lex_match (lexer, T_EQUALS);