X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;ds=sidebyside;f=src%2Flanguage%2Fstats%2Fctables.c;h=51493b0012a3c268310ea085c15fe150eb628d38;hb=f42cd385428298f9ee9795a3296e32363a9b0baa;hp=0ff1a4d41dfcfd948284013f208be84c485a1639;hpb=ea3637b10a3202c68a7c825e1a1956666874454d;p=pspp diff --git a/src/language/stats/ctables.c b/src/language/stats/ctables.c index 0ff1a4d41d..51493b0012 100644 --- a/src/language/stats/ctables.c +++ b/src/language/stats/ctables.c @@ -17,6 +17,7 @@ #include #include +#include #include "data/casereader.h" #include "data/casewriter.h" @@ -33,6 +34,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" @@ -197,6 +199,7 @@ struct ctables_cell struct ctables_domain *domains[N_CTDTS]; bool hide; + bool postcompute; enum ctables_summary_variant sv; struct ctables_cell_axis @@ -230,6 +233,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. */ @@ -239,28 +244,42 @@ struct ctables size_t n_tables; }; +static struct ctables_postcompute *ctables_find_postcompute (struct ctables *, + const char *name); + 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 +287,38 @@ 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. */ + 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,7 +358,7 @@ struct ctables_value int leaf; }; -struct ctables_section_value +struct ctables_occurrence { struct hmap_node node; union value value; @@ -426,10 +459,10 @@ struct ctables_category CCT_RANGE, CCT_MISSING, CCT_OTHERNM, + CCT_POSTCOMPUTE, /* Totals and subtotals. */ CCT_SUBTOTAL, - CCT_HSUBTOTAL, CCT_TOTAL, /* Implicit category lists. */ @@ -441,12 +474,21 @@ struct ctables_category struct ctables_category *subtotal; + bool hide; + union { double number; /* CCT_NUMBER. */ char *string; /* CCT_STRING. */ double range[2]; /* CCT_RANGE. */ - char *total_label; /* CCT_SUBTOTAL, CCT_HSUBTOTAL, CCT_TOTAL. */ + + struct + { + char *total_label; /* CCT_SUBTOTAL, CCT_TOTAL. */ + bool hide_subcategories; /* CCT_SUBTOTAL. */ + }; + + const struct ctables_postcompute *pc; /* CCT_POSTCOMPUTE. */ /* CCT_VALUE, CCT_LABEL, CCT_FUNCTION. */ struct @@ -460,6 +502,10 @@ struct ctables_category double percentile; }; }; + + /* Source location. This is null for CCT_TOTAL, CCT_VALUE, CCT_LABEL, + CCT_FUNCTION. */ + struct msg_location *location; }; static void @@ -474,6 +520,7 @@ ctables_category_uninit (struct ctables_category *cat) case CCT_RANGE: case CCT_MISSING: case CCT_OTHERNM: + case CCT_POSTCOMPUTE: break; case CCT_STRING: @@ -481,7 +528,6 @@ ctables_category_uninit (struct ctables_category *cat) break; case CCT_SUBTOTAL: - case CCT_HSUBTOTAL: case CCT_TOTAL: free (cat->total_label); break; @@ -515,8 +561,10 @@ ctables_category_equal (const struct ctables_category *a, case CCT_OTHERNM: return true; + case CCT_POSTCOMPUTE: + return a->pc == b->pc; + case CCT_SUBTOTAL: - case CCT_HSUBTOTAL: case CCT_TOTAL: return !strcmp (a->total_label, b->total_label); @@ -1271,9 +1319,257 @@ cct_range (double low, double high) }; } +static bool +ctables_table_parse_subtotal (struct lexer *lexer, bool hide_subcategories, + struct ctables_category *cat) +{ + char *total_label; + if (lex_match (lexer, T_EQUALS)) + { + if (!lex_force_string (lexer)) + return false; + + total_label = ss_xstrdup (lex_tokss (lexer)); + lex_get (lexer); + } + else + total_label = xstrdup (_("Subtotal")); + + *cat = (struct ctables_category) { + .type = CCT_SUBTOTAL, + .hide_subcategories = hide_subcategories, + .total_label = total_label + }; + return true; +} + +static bool +ctables_table_parse_explicit_category (struct lexer *lexer, struct ctables *ct, + struct ctables_category *cat) +{ + if (lex_match_id (lexer, "OTHERNM")) + *cat = (struct ctables_category) { .type = CCT_OTHERNM }; + else if (lex_match_id (lexer, "MISSING")) + *cat = (struct ctables_category) { .type = CCT_MISSING }; + else if (lex_match_id (lexer, "SUBTOTAL")) + return ctables_table_parse_subtotal (lexer, false, cat); + else if (lex_match_id (lexer, "HSUBTOTAL")) + return ctables_table_parse_subtotal (lexer, true, cat); + else if (lex_match_id (lexer, "LO")) + { + if (!lex_force_match_id (lexer, "THRU") || lex_force_num (lexer)) + return false; + *cat = cct_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")) + *cat = cct_range (number, DBL_MAX); + else + { + if (!lex_force_num (lexer)) + return false; + *cat = cct_range (number, lex_number (lexer)); + lex_get (lexer); + } + } + else + *cat = (struct ctables_category) { + .type = CCT_NUMBER, + .number = number + }; + } + else if (lex_is_string (lexer)) + { + *cat = (struct ctables_category) { + .type = CCT_STRING, + .string = ss_xstrdup (lex_tokss (lexer)), + }; + lex_get (lexer); + } + else if (lex_match (lexer, T_AND)) + { + if (!lex_force_id (lexer)) + return false; + struct ctables_postcompute *pc = ctables_find_postcompute ( + ct, lex_tokcstr (lexer)); + if (!pc) + { + struct msg_location *loc = lex_get_location (lexer, -1, 0); + msg_at (SE, loc, _("Unknown postcompute &%s."), + lex_tokcstr (lexer)); + msg_location_destroy (loc); + return false; + } + lex_get (lexer); + + *cat = (struct ctables_category) { .type = CCT_POSTCOMPUTE, .pc = pc }; + } + else + { + lex_error (lexer, NULL); + return false; + } + + return true; +} + +static struct ctables_category * +ctables_find_category_for_postcompute (const struct ctables_categories *cats, + const struct ctables_pcexpr *e) +{ + struct ctables_category *best = NULL; + size_t n_subtotals = 0; + for (size_t i = 0; i < cats->n_cats; i++) + { + struct ctables_category *cat = &cats->cats[i]; + switch (e->op) + { + case CTPO_CAT_NUMBER: + if (cat->type == CCT_NUMBER && cat->number == e->number) + best = cat; + break; + + case CTPO_CAT_STRING: + if (cat->type == CCT_STRING && !strcmp (cat->string, e->string)) + best = cat; + break; + + case CTPO_CAT_RANGE: + if (cat->type == CCT_RANGE + && cat->range[0] == e->range[0] + && cat->range[1] == e->range[1]) + best = cat; + break; + + case CTPO_CAT_MISSING: + if (cat->type == CCT_MISSING) + best = cat; + break; + + case CTPO_CAT_OTHERNM: + if (cat->type == CCT_OTHERNM) + best = cat; + break; + + case CTPO_CAT_SUBTOTAL: + if (cat->type == CCT_SUBTOTAL) + { + n_subtotals++; + if (e->subtotal_index == n_subtotals) + return cat; + else if (e->subtotal_index == 0) + best = cat; + } + break; + + case CTPO_CAT_TOTAL: + if (cat->type == CCT_TOTAL) + return cat; + break; + + case CTPO_CONSTANT: + case CTPO_ADD: + case CTPO_SUB: + case CTPO_MUL: + case CTPO_DIV: + case CTPO_POW: + case CTPO_NEG: + NOT_REACHED (); + } + } + if (e->op == CTPO_CAT_SUBTOTAL && e->subtotal_index == 0 && n_subtotals > 1) + return NULL; + return best; +} + +static bool +ctables_recursive_check_postcompute (const struct ctables_pcexpr *e, + struct ctables_category *pc_cat, + const struct ctables_categories *cats, + const struct msg_location *cats_location) +{ + switch (e->op) + { + case CTPO_CAT_NUMBER: + case CTPO_CAT_STRING: + case CTPO_CAT_RANGE: + case CTPO_CAT_MISSING: + case CTPO_CAT_OTHERNM: + case CTPO_CAT_SUBTOTAL: + case CTPO_CAT_TOTAL: + { + struct ctables_category *cat = ctables_find_category_for_postcompute ( + cats, e); + if (!cat) + { + if (e->op == CTPO_CAT_SUBTOTAL && e->subtotal_index == 0) + { + size_t n_subtotals = 0; + for (size_t i = 0; i < cats->n_cats; i++) + n_subtotals += cats->cats[i].type == CCT_SUBTOTAL; + if (n_subtotals > 1) + { + msg_at (SE, cats_location, + ngettext ("These categories include %zu instance " + "of SUBTOTAL or HSUBTOTAL, so references " + "from computed categories must refer to " + "subtotals by position.", + "These categories include %zu instances " + "of SUBTOTAL or HSUBTOTAL, so references " + "from computed categories must refer to " + "subtotals by position.", + n_subtotals), + n_subtotals); + msg_at (SN, e->location, + _("This is the reference that lacks a position.")); + return NULL; + } + } + + msg_at (SE, pc_cat->location, + _("Computed category &%s references a category not included " + "in the category list."), + pc_cat->pc->name); + msg_at (SN, e->location, _("This is the missing category.")); + msg_at (SN, cats_location, + _("To fix the problem, add the missing category to the " + "list of categories here.")); + return false; + } + if (pc_cat->pc->hide_source_cats) + cat->hide = true; + return true; + } + + case CTPO_CONSTANT: + return true; + + 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++) + if (e->subs[i] && !ctables_recursive_check_postcompute ( + e->subs[i], pc_cat, cats, cats_location)) + return false; + return true; + + default: + NOT_REACHED (); + } +} + static bool ctables_table_parse_categories (struct lexer *lexer, struct dictionary *dict, - struct ctables_table *t) + struct ctables *ct, struct ctables_table *t) { if (!lex_match_id (lexer, "VARIABLES")) return false; @@ -1285,7 +1581,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 @@ -1298,85 +1594,33 @@ ctables_table_parse_categories (struct lexer *lexer, struct dictionary *dict, size_t allocated_cats = 0; if (lex_match (lexer, T_LBRACK)) { + int cats_start_ofs = lex_ofs (lexer); do { if (c->n_cats >= allocated_cats) c->cats = x2nrealloc (c->cats, &allocated_cats, sizeof *c->cats); + int start_ofs = lex_ofs (lexer); struct ctables_category *cat = &c->cats[c->n_cats]; - if (lex_match_id (lexer, "OTHERNM")) - cat->type = CCT_OTHERNM; - else if (lex_match_id (lexer, "MISSING")) - cat->type = CCT_MISSING; - else if (lex_match_id (lexer, "SUBTOTAL")) - *cat = (struct ctables_category) - { .type = CCT_SUBTOTAL, .total_label = NULL }; - else if (lex_match_id (lexer, "HSUBTOTAL")) - *cat = (struct ctables_category) - { .type = CCT_HSUBTOTAL, .total_label = NULL }; - else if (lex_match_id (lexer, "LO")) - { - if (!lex_force_match_id (lexer, "THRU") || lex_force_num (lexer)) - return false; - *cat = cct_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")) - { - cat->type = CCT_RANGE; - cat->range[0] = number; - if (lex_match_id (lexer, "HI")) - *cat = cct_range (number, DBL_MAX); - else - { - if (!lex_force_num (lexer)) - return false; - *cat = cct_range (number, lex_number (lexer)); - lex_get (lexer); - } - } - else - *cat = (struct ctables_category) { - .type = CCT_NUMBER, - .number = number - }; - } - else if (lex_is_string (lexer)) - { - *cat = (struct ctables_category) { - .type = CCT_STRING, - .string = ss_xstrdup (lex_tokss (lexer)), - }; - lex_get (lexer); - } - else - { - lex_error (lexer, NULL); - return false; - } - - if (cat->type == CCT_SUBTOTAL || cat->type == CCT_HSUBTOTAL) - { - if (lex_match (lexer, T_EQUALS)) - { - if (!lex_force_string (lexer)) - return false; - - cat->total_label = ss_xstrdup (lex_tokss (lexer)); - lex_get (lexer); - } - else - cat->total_label = xstrdup (_("Subtotal")); - } - + if (!ctables_table_parse_explicit_category (lexer, ct, cat)) + return false; + cat->location = lex_ofs_location (lexer, start_ofs, lex_ofs (lexer) - 1); c->n_cats++; + lex_match (lexer, T_COMMA); } while (!lex_match (lexer, T_RBRACK)); + + struct msg_location *cats_location + = lex_ofs_location (lexer, cats_start_ofs, lex_ofs (lexer) - 1); + for (size_t i = 0; i < c->n_cats; i++) + { + struct ctables_category *cat = &c->cats[i]; + if (cat->type == CCT_POSTCOMPUTE + && !ctables_recursive_check_postcompute (cat->pc->expr, cat, + c, cats_location)) + return false; + } } struct ctables_category cat = { @@ -1509,8 +1753,7 @@ ctables_table_parse_categories (struct lexer *lexer, struct dictionary *dict, if (!c->n_cats) { if (c->n_cats >= allocated_cats) - c->cats = x2nrealloc (c->cats, &allocated_cats, - sizeof *c->cats); + c->cats = x2nrealloc (c->cats, &allocated_cats, sizeof *c->cats); c->cats[c->n_cats++] = cat; } @@ -1551,8 +1794,10 @@ ctables_table_parse_categories (struct lexer *lexer, struct dictionary *dict, cat->subtotal = subtotal; break; + case CCT_POSTCOMPUTE: + break; + case CCT_SUBTOTAL: - case CCT_HSUBTOTAL: subtotal = cat; break; @@ -2314,8 +2559,8 @@ ctables_cell_compare_3way (const void *a_, const void *b_, const void *aux_) case CCT_NUMBER: case CCT_STRING: case CCT_SUBTOTAL: - case CCT_HSUBTOTAL: case CCT_TOTAL: + case CCT_POSTCOMPUTE: /* Must be equal. */ continue; @@ -2447,13 +2692,15 @@ ctables_categories_match (const struct ctables_categories *c, return cat; break; + case CCT_POSTCOMPUTE: + break; + case CCT_OTHERNM: if (!othernm) othernm = cat; break; case CCT_SUBTOTAL: - case CCT_HSUBTOTAL: case CCT_TOTAL: break; @@ -2482,8 +2729,6 @@ static struct ctables_cell * 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 = 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++) @@ -2495,7 +2740,7 @@ ctables_cell_insert__ (struct ctables_section *s, const struct ccase *c, 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) + && cats[a][i]->type != CCT_POSTCOMPUTE) hash = value_hash (case_data (c, nest->vars[i]), var_get_width (nest->vars[i]), hash); else @@ -2514,7 +2759,7 @@ ctables_cell_insert__ (struct ctables_section *s, const struct ccase *c, && (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 + && cats[a][i]->type != CCT_POSTCOMPUTE && !value_equal (case_data (c, nest->vars[i]), &cell->axes[a].cvs[i].value, var_get_width (nest->vars[i]))))) @@ -2530,6 +2775,7 @@ ctables_cell_insert__ (struct ctables_section *s, const struct ccase *c, cell->hide = false; cell->sv = sv; cell->contributes_to_domains = true; + cell->postcompute = false; for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) { const struct ctables_nest *nest = s->nests[a]; @@ -2539,15 +2785,18 @@ ctables_cell_insert__ (struct ctables_section *s, const struct ccase *c, 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 = cat->subtotal; - if (subtotal && subtotal->type == CCT_HSUBTOTAL) + if (cat->hide || (subtotal && subtotal->hide_subcategories)) cell->hide = true; - if (cat->type == CCT_TOTAL || cat->type == CCT_SUBTOTAL || cat->type == CCT_HSUBTOTAL) + if (cat->type == CCT_TOTAL + || cat->type == CCT_SUBTOTAL + || cat->type == CCT_POSTCOMPUTE) cell->contributes_to_domains = false; + if (cat->type == CCT_POSTCOMPUTE) + cell->postcompute = true; } cell->axes[a].cvs[i].category = cat; @@ -2556,6 +2805,7 @@ ctables_cell_insert__ (struct ctables_section *s, const struct ccase *c, } } + const struct ctables_nest *ss = s->nests[s->table->summary_axis]; 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++) @@ -2654,15 +2904,15 @@ ctables_add_occurrence (const struct variable *var, 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, + struct ctables_occurrence *o; + HMAP_FOR_EACH_WITH_HASH (o, struct ctables_occurrence, node, hash, occurrences) - if (value_equal (value, &sv->value, width)) + if (value_equal (value, &o->value, width)) return; - sv = xmalloc (sizeof *sv); - value_clone (&sv->value, value, width); - hmap_insert (occurrences, &sv->node, hash); + o = xmalloc (sizeof *o); + value_clone (&o->value, value, width); + hmap_insert (occurrences, &o->node, hash); } static void @@ -2733,8 +2983,10 @@ 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 + return (cat->type == CCT_TOTAL || cat->type == CCT_SUBTOTAL ? pivot_value_new_user_text (cat->total_label, SIZE_MAX) + : cat->type == CCT_POSTCOMPUTE && cat->pc->label + ? pivot_value_new_user_text (cat->pc->label, SIZE_MAX) : pivot_value_new_var_value (var, value)); } @@ -2789,61 +3041,296 @@ ctables_table_add_section (struct ctables_table *t, enum pivot_axis_type a, } } -static void -ctables_table_output (struct ctables *ct, struct ctables_table *t) +static double +ctpo_add (double a, double b) { - 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)); + return a + b; +} - bool summary_dimension = (t->summary_axis != t->slabels_axis - || (!t->slabels_visible - && t->summary_specs.n > 1)); - if (summary_dimension) +static double +ctpo_sub (double a, double b) +{ + return a - b; +} + +static double +ctpo_mul (double a, double b) +{ + return a * b; +} + +static double +ctpo_div (double a, double b) +{ + return b ? a / b : SYSMIS; +} + +static double +ctpo_pow (double a, double b) +{ + int save_errno = errno; + errno = 0; + double result = pow (a, b); + if (errno) + result = SYSMIS; + errno = save_errno; + return result; +} + +static double +ctpo_neg (double a, double b UNUSED) +{ + return -a; +} + +struct ctables_pcexpr_evaluate_ctx + { + const struct ctables_cell *cell; + const struct ctables_section *section; + const struct ctables_categories *cats; + enum pivot_axis_type pc_a; + size_t pc_a_idx; + }; + +static double ctables_pcexpr_evaluate ( + const struct ctables_pcexpr_evaluate_ctx *, const struct ctables_pcexpr *); + +static double +ctables_pcexpr_evaluate_nonterminal ( + const struct ctables_pcexpr_evaluate_ctx *ctx, + const struct ctables_pcexpr *e, size_t n_args, + double evaluate (double, double)) +{ + double args[2] = { 0, 0 }; + for (size_t i = 0; i < n_args; i++) { - struct pivot_dimension *d = pivot_dimension_create ( - pt, t->slabels_axis, N_("Statistics")); - const struct ctables_summary_spec_set *specs = &t->summary_specs; - if (!t->slabels_visible) - d->hide_all_labels = true; - for (size_t i = 0; i < specs->n; i++) - pivot_category_create_leaf ( - d->root, pivot_value_new_text (specs->specs[i].label)); + args[i] = ctables_pcexpr_evaluate (ctx, e->subs[i]); + if (!isfinite (args[i]) || args[i] == SYSMIS) + return SYSMIS; } + return evaluate (args[0], args[1]); +} - bool categories_dimension = t->clabels_example != NULL; - if (categories_dimension) +static double +ctables_pcexpr_evaluate_category (const struct ctables_pcexpr_evaluate_ctx *ctx, + const struct ctables_cell_value *pc_cv) +{ + const struct ctables_section *s = ctx->section; + + size_t hash = 0; + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) { - struct pivot_dimension *d = pivot_dimension_create ( - pt, t->label_axis[t->clabels_from_axis], - t->clabels_from_axis == PIVOT_AXIS_ROW - ? N_("Row Categories") - : N_("Column Categories")); - const struct variable *var = t->clabels_example; - const struct ctables_categories *c = t->categories[var_get_dict_index (var)]; - for (size_t i = 0; i < t->n_clabels_values; i++) - { - const struct ctables_value *value = t->clabels_values[i]; - const struct ctables_category *cat = ctables_categories_match (c, &value->value, var); - assert (cat != NULL); - pivot_category_create_leaf (d->root, ctables_category_create_label ( - cat, t->clabels_example, &value->value)); - } + const struct ctables_nest *nest = s->nests[a]; + for (size_t i = 0; i < nest->n; i++) + if (i != nest->scale_idx) + { + const struct ctables_cell_value *cv + = (a == ctx->pc_a && i == ctx->pc_a_idx ? pc_cv + : &ctx->cell->axes[a].cvs[i]); + hash = hash_pointer (cv->category, hash); + if (cv->category->type != CCT_TOTAL + && cv->category->type != CCT_SUBTOTAL + && cv->category->type != CCT_POSTCOMPUTE) + hash = value_hash (&cv->value, + var_get_width (nest->vars[i]), hash); + } } - 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++) + struct ctables_cell *tc; + HMAP_FOR_EACH_WITH_HASH (tc, struct ctables_cell, node, hash, &s->cells) { - static const char *names[] = { + 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 ctables_cell_value *p_cv + = (a == ctx->pc_a && i == ctx->pc_a_idx ? pc_cv + : &ctx->cell->axes[a].cvs[i]); + const struct ctables_cell_value *t_cv = &tc->axes[a].cvs[i]; + if (p_cv->category != t_cv->category + || (p_cv->category->type != CCT_TOTAL + && p_cv->category->type != CCT_SUBTOTAL + && p_cv->category->type != CCT_POSTCOMPUTE + && !value_equal (&p_cv->value, + &t_cv->value, + var_get_width (nest->vars[i])))) + goto not_equal; + } + } + + goto found; + + not_equal: ; + } + return 0; + +found: ; + const struct ctables_table *t = s->table; + const struct ctables_nest *specs_nest = s->nests[t->summary_axis]; + const struct ctables_summary_spec_set *specs = &specs_nest->specs[tc->sv]; + size_t j = 0 /* XXX */; + return ctables_summary_value (tc, &tc->summaries[j], &specs->specs[j]); +} + +static double +ctables_pcexpr_evaluate (const struct ctables_pcexpr_evaluate_ctx *ctx, + const struct ctables_pcexpr *e) +{ + switch (e->op) + { + case CTPO_CONSTANT: + return e->number; + + case CTPO_CAT_RANGE: + { + struct ctables_cell_value cv = { + .category = ctables_find_category_for_postcompute (ctx->cats, e) + }; + assert (cv.category != NULL); + + struct hmap *occurrences = &ctx->section->occurrences[ctx->pc_a][ctx->pc_a_idx]; + const struct ctables_occurrence *o; + + double sum = 0.0; + const struct variable *var = ctx->section->nests[ctx->pc_a]->vars[ctx->pc_a_idx]; + HMAP_FOR_EACH (o, struct ctables_occurrence, node, occurrences) + if (ctables_categories_match (ctx->cats, &o->value, var) == cv.category) + { + cv.value = o->value; + sum += ctables_pcexpr_evaluate_category (ctx, &cv); + } + return sum; + } + + case CTPO_CAT_NUMBER: + case CTPO_CAT_STRING: + case CTPO_CAT_MISSING: + case CTPO_CAT_OTHERNM: + case CTPO_CAT_SUBTOTAL: + case CTPO_CAT_TOTAL: + { + struct ctables_cell_value cv = { + .category = ctables_find_category_for_postcompute (ctx->cats, e), + .value = { .f = e->number }, + }; + assert (cv.category != NULL); + return ctables_pcexpr_evaluate_category (ctx, &cv); + } + + case CTPO_ADD: + return ctables_pcexpr_evaluate_nonterminal (ctx, e, 2, ctpo_add); + + case CTPO_SUB: + return ctables_pcexpr_evaluate_nonterminal (ctx, e, 2, ctpo_sub); + + case CTPO_MUL: + return ctables_pcexpr_evaluate_nonterminal (ctx, e, 2, ctpo_mul); + + case CTPO_DIV: + return ctables_pcexpr_evaluate_nonterminal (ctx, e, 2, ctpo_div); + + case CTPO_POW: + return ctables_pcexpr_evaluate_nonterminal (ctx, e, 2, ctpo_pow); + + case CTPO_NEG: + return ctables_pcexpr_evaluate_nonterminal (ctx, e, 1, ctpo_neg); + } + + NOT_REACHED (); +} + +static double +ctables_cell_calculate_postcompute (const struct ctables_section *s, + const struct ctables_cell *cell) +{ + enum pivot_axis_type pc_a; + size_t pc_a_idx; + const struct ctables_postcompute *pc; + for (pc_a = 0; ; pc_a++) + { + assert (pc_a < PIVOT_N_AXES); + for (pc_a_idx = 0; pc_a_idx < s->nests[pc_a]->n; pc_a_idx++) + { + const struct ctables_cell_value *cv = &cell->axes[pc_a].cvs[pc_a_idx]; + if (cv->category->type == CCT_POSTCOMPUTE) + { + pc = cv->category->pc; + goto found; + } + } + } +found: ; + + const struct variable *var = s->nests[pc_a]->vars[pc_a_idx]; + const struct ctables_categories *cats = s->table->categories[ + var_get_dict_index (var)]; + struct ctables_pcexpr_evaluate_ctx ctx = { + .cell = cell, + .section = s, + .cats = cats, + .pc_a = pc_a, + .pc_a_idx = pc_a_idx, + }; + return ctables_pcexpr_evaluate (&ctx, pc->expr); +} + +static void +ctables_table_output (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)); + + 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_("Statistics")); + const struct ctables_summary_spec_set *specs = &t->summary_specs; + if (!t->slabels_visible) + d->hide_all_labels = true; + for (size_t i = 0; i < specs->n; i++) + pivot_category_create_leaf ( + d->root, pivot_value_new_text (specs->specs[i].label)); + } + + bool categories_dimension = t->clabels_example != NULL; + if (categories_dimension) + { + struct pivot_dimension *d = pivot_dimension_create ( + pt, t->label_axis[t->clabels_from_axis], + t->clabels_from_axis == PIVOT_AXIS_ROW + ? N_("Row Categories") + : N_("Column Categories")); + const struct variable *var = t->clabels_example; + const struct ctables_categories *c = t->categories[var_get_dict_index (var)]; + for (size_t i = 0; i < t->n_clabels_values; i++) + { + const struct ctables_value *value = t->clabels_values[i]; + const struct ctables_category *cat = ctables_categories_match (c, &value->value, var); + assert (cat != NULL); + pivot_category_create_leaf (d->root, ctables_category_create_label ( + cat, t->clabels_example, &value->value)); + } + } + + pivot_table_set_look (pt, ct->look); + struct pivot_dimension *d[PIVOT_N_AXES]; + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + { + static const char *names[] = { [PIVOT_AXIS_ROW] = N_("Rows"), [PIVOT_AXIS_COLUMN] = N_("Columns"), [PIVOT_AXIS_LAYER] = N_("Layers"), @@ -2978,8 +3465,8 @@ ctables_table_output (struct ctables *ct, struct ctables_table *t) if (prev->axes[a].cvs[var_idx].category != c) break; else if (c->type != CCT_SUBTOTAL - && c->type != CCT_HSUBTOTAL && c->type != CCT_TOTAL + && c->type != CCT_POSTCOMPUTE && !value_equal (&prev->axes[a].cvs[var_idx].value, &cell->axes[a].cvs[var_idx].value, var_get_type (nest->vars[var_idx]))) @@ -3073,7 +3560,9 @@ ctables_table_output (struct ctables *ct, struct ctables_table *t) dindexes[n_dindexes++] = leaf; } - double d = ctables_summary_value (cell, &cell->summaries[j], &specs->specs[j]); + double d = (cell->postcompute + ? ctables_cell_calculate_postcompute (s, cell) + : 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); @@ -3435,8 +3924,10 @@ ctables_add_category_occurrences (const struct variable *var, ctables_add_occurrence (var, &vl->value, occurrences); break; + case CCT_POSTCOMPUTE: + break; + case CCT_SUBTOTAL: - case CCT_HSUBTOTAL: case CCT_TOTAL: break; @@ -3459,19 +3950,36 @@ ctables_section_recurse_add_empty_categories ( enum pivot_axis_type a, size_t a_idx) { if (a >= PIVOT_N_AXES) - { - - } - else if (!s->nests[a] || idx >= s->nests[a]->n) - { - - - } + 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 { - - for (size_t i = 0; i < s->nests[a]->n; i++) + const struct variable *var = s->nests[a]->vars[a_idx]; + const struct ctables_categories *categories = s->table->categories[ + var_get_dict_index (var)]; + int width = var_get_width (var); + const struct hmap *occurrences = &s->occurrences[a][a_idx]; + const struct ctables_occurrence *o; + HMAP_FOR_EACH (o, struct ctables_occurrence, node, occurrences) + { + union value *value = case_data_rw (c, var); + value_destroy (value, width); + value_clone (value, &o->value, width); + cats[a][a_idx] = ctables_categories_match (categories, value, var); + assert (cats[a][a_idx] != NULL); + ctables_section_recurse_add_empty_categories (s, cats, c, a, a_idx + 1); + } + for (size_t i = 0; i < categories->n_cats; i++) + { + const struct ctables_category *cat = &categories->cats[i]; + if (cat->type == CCT_POSTCOMPUTE) + { + cats[a][a_idx] = cat; + ctables_section_recurse_add_empty_categories (s, cats, c, a, a_idx + 1); + } + } } } @@ -3498,7 +4006,8 @@ ctables_section_add_empty_categories (struct ctables_section *s) 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, c, cats, a, 0); + ctables_section_recurse_add_empty_categories (s, cats, c, 0, 0); + case_unref (c); } static bool @@ -3556,6 +4065,532 @@ ctables_execute (struct dataset *ds, struct ctables *ct) } 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 }, + .location = msg_location_merged (sub0->location, sub1->location), + }; + return e; +} + +/* 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, lhs->location, "%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.location = lex_ofs_location (lexer, start_ofs, 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 }, + .location = lex_ofs_location (lexer, 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), + .location = lex_ofs_location (lexer, 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 pcompute_start = 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; + } + + int expr_start = lex_ofs (lexer); + struct ctables_pcexpr *expr = parse_add (lexer); + int expr_end = lex_ofs (lexer) - 1; + if (!expr || !lex_force_match (lexer, T_RPAREN)) + { + free (name); + return false; + } + int pcompute_end = lex_ofs (lexer) - 1; + + struct msg_location *location = lex_ofs_location (lexer, pcompute_start, + pcompute_end); + + 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; + if (!pc->label) + pc->label = lex_ofs_representation (lexer, expr_start, expr_end); + 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) @@ -3572,6 +4607,7 @@ cmd_ctables (struct lexer *lexer, struct dataset *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; @@ -3731,7 +4767,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")) @@ -3783,6 +4828,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, @@ -3985,7 +5031,8 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) } else if (lex_match_id (lexer, "CATEGORIES")) { - if (!ctables_table_parse_categories (lexer, dataset_dict (ds), t)) + if (!ctables_table_parse_categories (lexer, dataset_dict (ds), + ct, t)) goto error; } else if (lex_match_id (lexer, "TITLES"))