X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Fctables.c;h=51493b0012a3c268310ea085c15fe150eb628d38;hb=1b8eb2cc06c2bb413b71452105d61d95f609392e;hp=e5724296060970dba0c4ea2d6dd69c5aba4f086d;hpb=ee3c2a4c9bfe8d8211ba991f0bdee04066dd1474;p=pspp diff --git a/src/language/stats/ctables.c b/src/language/stats/ctables.c index e572429606..51493b0012 100644 --- a/src/language/stats/ctables.c +++ b/src/language/stats/ctables.c @@ -17,11 +17,15 @@ #include #include +#include #include "data/casereader.h" +#include "data/casewriter.h" #include "data/dataset.h" #include "data/dictionary.h" #include "data/mrset.h" +#include "data/subcase.h" +#include "data/value-labels.h" #include "language/command.h" #include "language/lexer/format-parser.h" #include "language/lexer/lexer.h" @@ -30,9 +34,13 @@ #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" #include "math/moments.h" +#include "math/percentiles.h" +#include "math/sort.h" #include "output/pivot-table.h" #include "gl/minmax.h" @@ -167,8 +175,10 @@ struct ctables_domain const struct ctables_cell *example; - double valid; - double missing; + double d_valid; /* Dictionary weight. */ + double d_missing; + double e_valid; /* Effective weight */ + double e_missing; }; enum ctables_summary_variant @@ -180,19 +190,20 @@ 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. */ + bool contributes_to_domains; struct ctables_domain *domains[N_CTDTS]; bool hide; + bool postcompute; enum ctables_summary_variant sv; - struct + struct ctables_cell_axis { - size_t stack_idx; struct ctables_cell_value { const struct ctables_category *category; @@ -208,6 +219,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. @@ -221,37 +233,53 @@ 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 *base_weight; /* WEIGHT. */ + struct variable *e_weight; /* WEIGHT. */ int hide_threshold; /* HIDESMALLCOUNTS. */ struct ctables_table **tables; 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, @@ -259,31 +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]; }; - }; -enum ctables_label_position - { - CTLP_NORMAL, - CTLP_OPPOSITE, - CTLP_LAYER, + /* 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; @@ -293,6 +328,8 @@ struct ctables_summary_spec_set struct variable *var; }; +static void ctables_summary_spec_set_clone (struct ctables_summary_spec_set *, + const struct ctables_summary_spec_set *); static void ctables_summary_spec_set_uninit (struct ctables_summary_spec_set *); /* A nested sequence of variables, e.g. a > b > c. */ @@ -314,19 +351,57 @@ struct ctables_stack size_t n; }; +struct ctables_value + { + struct hmap_node node; + union value value; + int leaf; + }; + +struct ctables_occurrence + { + 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 hmap cells; - struct hmap domains[N_CTDTS]; + struct ctables_summary_spec_set summary_specs; - enum pivot_axis_type slabels_position; + const struct variable *clabels_example; + struct hmap clabels_values_map; + struct ctables_value **clabels_values; + size_t n_clabels_values; + + enum pivot_axis_type slabels_axis; bool slabels_visible; - enum ctables_label_position row_labels; - enum ctables_label_position col_labels; + /* The innermost category labels for axis 'a' appear on axis label_axis[a]. + + Most commonly, label_axis[a] == a, and in particular we always have + label_axis{PIVOT_AXIS_LAYER] == PIVOT_AXIS_LAYER. + + If ROWLABELS or COLLABELS is specified, then one of + label_axis[PIVOT_AXIS_ROW] or label_axis[PIVOT_AXIS_COLUMN] can be the + opposite axis or PIVOT_AXIS_LAYER. Only one of them will differ. + */ + enum pivot_axis_type label_axis[PIVOT_N_AXES]; + enum pivot_axis_type clabels_from_axis; /* Indexed by variable dictionary index. */ struct ctables_categories **categories; @@ -378,16 +453,19 @@ struct ctables_category { enum ctables_category_type { + /* Explicit category lists. */ CCT_NUMBER, CCT_STRING, CCT_RANGE, CCT_MISSING, CCT_OTHERNM, + CCT_POSTCOMPUTE, + /* Totals and subtotals. */ CCT_SUBTOTAL, - CCT_HSUBTOTAL, CCT_TOTAL, + /* Implicit category lists. */ CCT_VALUE, CCT_LABEL, CCT_FUNCTION, @@ -396,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 @@ -415,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 @@ -429,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: @@ -436,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; @@ -448,6 +539,48 @@ ctables_category_uninit (struct ctables_category *cat) } } +static bool +ctables_category_equal (const struct ctables_category *a, + const struct ctables_category *b) +{ + if (a->type != b->type) + return false; + + switch (a->type) + { + case CCT_NUMBER: + return a->number == b->number; + + case CCT_STRING: + return strcmp (a->string, b->string); + + case CCT_RANGE: + return a->range[0] == b->range[0] && a->range[1] == b->range[1]; + + case CCT_MISSING: + case CCT_OTHERNM: + return true; + + case CCT_POSTCOMPUTE: + return a->pc == b->pc; + + case CCT_SUBTOTAL: + case CCT_TOTAL: + return !strcmp (a->total_label, b->total_label); + + case CCT_VALUE: + case CCT_LABEL: + case CCT_FUNCTION: + return (a->include_missing == b->include_missing + && a->sort_ascending == b->sort_ascending + && a->sort_function == b->sort_function + && a->sort_var == b->sort_var + && a->percentile == b->percentile); + } + + NOT_REACHED (); +} + static void ctables_categories_unref (struct ctables_categories *c) { @@ -464,6 +597,20 @@ ctables_categories_unref (struct ctables_categories *c) free (c); } +static bool +ctables_categories_equal (const struct ctables_categories *a, + const struct ctables_categories *b) +{ + if (a->n_cats != b->n_cats || a->show_empty != b->show_empty) + return false; + + for (size_t i = 0; i < a->n_cats; i++) + if (!ctables_category_equal (&a->cats[i], &b->cats[i])) + return false; + + return true; +} + /* Chi-square test (SIGTEST). */ struct ctables_chisq { @@ -538,8 +685,17 @@ struct ctables_summary_spec double percentile; /* CTSF_PTILE only. */ char *label; struct fmt_spec format; /* XXX extra CTABLES formats */ + size_t axis_idx; }; +static void +ctables_summary_spec_clone (struct ctables_summary_spec *dst, + const struct ctables_summary_spec *src) +{ + *dst = *src; + dst->label = xstrdup (src->label); +} + static void ctables_summary_spec_uninit (struct ctables_summary_spec *s) { @@ -547,6 +703,22 @@ ctables_summary_spec_uninit (struct ctables_summary_spec *s) free (s->label); } +static void +ctables_summary_spec_set_clone (struct ctables_summary_spec_set *dst, + const struct ctables_summary_spec_set *src) +{ + struct ctables_summary_spec *specs = xnmalloc (src->n, sizeof *specs); + for (size_t i = 0; i < src->n; i++) + ctables_summary_spec_clone (&specs[i], &src->specs[i]); + + *dst = (struct ctables_summary_spec_set) { + .specs = specs, + .n = src->n, + .allocated = src->n, + .var = src->var + }; +} + static void ctables_summary_spec_set_uninit (struct ctables_summary_spec_set *set) { @@ -868,6 +1040,12 @@ ctables_axis_parse_primary (struct ctables_axis_parse_ctx *ctx) return axis; } +static bool +has_digit (const char *s) +{ + return s[strcspn (s, "0123456789")] != '\0'; +} + static struct ctables_axis * ctables_axis_parse_postfix (struct ctables_axis_parse_ctx *ctx) { @@ -875,7 +1053,7 @@ ctables_axis_parse_postfix (struct ctables_axis_parse_ctx *ctx) if (!sub || !lex_match (ctx->lexer, T_LBRACK)) return sub; - bool totals = false; + enum ctables_summary_variant sv = CSV_CELL; for (;;) { int start_ofs = lex_ofs (ctx->lexer); @@ -908,7 +1086,8 @@ ctables_axis_parse_postfix (struct ctables_axis_parse_ctx *ctx) /* Parse format. */ struct fmt_spec format; const struct fmt_spec *formatp; - if (lex_token (ctx->lexer) == T_ID) + if (lex_token (ctx->lexer) == T_ID + && has_digit (lex_tokcstr (ctx->lexer))) { if (!parse_format_specifier (ctx->lexer, &format) || !fmt_check_output (&format) @@ -924,28 +1103,23 @@ ctables_axis_parse_postfix (struct ctables_axis_parse_ctx *ctx) struct msg_location *loc = lex_ofs_location (ctx->lexer, start_ofs, lex_ofs (ctx->lexer) - 1); - add_summary_spec (sub, function, percentile, label, formatp, loc, - totals); + add_summary_spec (sub, function, percentile, label, formatp, loc, sv); free (label); msg_location_destroy (loc); - if (lex_match (ctx->lexer, T_COMMA)) + lex_match (ctx->lexer, T_COMMA); + if (sv == CSV_CELL && lex_match_id (ctx->lexer, "TOTALS")) { - if (!totals && lex_match_id (ctx->lexer, "TOTALS")) - { - if (!lex_force_match (ctx->lexer, T_LBRACK)) - goto error; - totals = true; - } + if (!lex_force_match (ctx->lexer, T_LBRACK)) + goto error; + sv = CSV_TOTAL; } - else if (lex_force_match (ctx->lexer, T_RBRACK)) + else if (lex_match (ctx->lexer, T_RBRACK)) { - if (totals && !lex_force_match (ctx->lexer, T_RBRACK)) + if (sv == CSV_TOTAL && !lex_force_match (ctx->lexer, T_RBRACK)) goto error; return sub; } - else - goto error; } error: @@ -1145,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; @@ -1159,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 @@ -1172,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 = { @@ -1383,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; } @@ -1425,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; @@ -1491,17 +1862,17 @@ nest_fts (struct ctables_stack s0, struct ctables_stack s1) summary_src = a; else NOT_REACHED (); - stack.nests[stack.n++] = (struct ctables_nest) { + + struct ctables_nest *new = &stack.nests[stack.n++]; + *new = (struct ctables_nest) { .vars = vars, .scale_idx = (a->scale_idx != SIZE_MAX ? a->scale_idx : b->scale_idx != SIZE_MAX ? a->n + b->scale_idx : SIZE_MAX), .n = n, - .specs = { - [CSV_CELL] = summary_src->specs[CSV_CELL], - [CSV_TOTAL] = summary_src->specs[CSV_TOTAL], - }, }; + for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++) + ctables_summary_spec_set_clone (&new->specs[sv], &summary_src->specs[sv]); } ctables_stack_uninit (&s0); ctables_stack_uninit (&s1); @@ -1543,10 +1914,10 @@ enumerate_fts (enum pivot_axis_type axis_type, const struct ctables_axis *a) .scale_idx = a->scale ? 0 : SIZE_MAX, }; if (a->specs[CSV_CELL].n || a->scale) - for (size_t i = 0; i < N_CSVS; i++) + for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++) { - nest->specs[i] = a->specs[i]; - nest->specs[i].var = a->var.var; + ctables_summary_spec_set_clone (&nest->specs[sv], &a->specs[sv]); + nest->specs[sv].var = a->var.var; } return (struct ctables_stack) { .nests = nest, .n = 1 }; @@ -1581,7 +1952,15 @@ union ctables_summary /* MEAN, SEMEAN, STDDEV, SUM, VARIANCE, *.SUM. */ struct moments1 *moments; - /* XXX percentiles, median, mode, multiple response */ + /* MEDIAN, MODE, PTILE. */ + struct + { + struct casewriter *writer; + double ovalid; + double ovalue; + }; + + /* XXX multiple response */ }; static void @@ -1613,6 +1992,7 @@ ctables_summary_init (union ctables_summary *s, case CTSF_LAYERPCT_TOTALN: case CTSF_LAYERROWPCT_TOTALN: case CTSF_LAYERCOLPCT_TOTALN: + case CTSF_MISSING: case CSTF_TOTALN: case CTSF_ETOTALN: case CTSF_VALIDN: @@ -1642,10 +2022,23 @@ ctables_summary_init (union ctables_summary *s, break; case CTSF_MEDIAN: - case CTSF_MISSING: case CTSF_MODE: case CTSF_PTILE: - NOT_REACHED (); + { + struct caseproto *proto = caseproto_create (); + proto = caseproto_add_width (proto, 0); + proto = caseproto_add_width (proto, 0); + + struct subcase ordering; + subcase_init (&ordering, 0, 0, SC_ASCEND); + s->writer = sort_create_writer (&ordering, proto); + subcase_uninit (&ordering); + caseproto_unref (proto); + + s->ovalid = 0; + s->ovalue = SYSMIS; + } + break; case CTSF_RESPONSES: case CTSF_ROWPCT_RESPONSES: @@ -1702,6 +2095,7 @@ ctables_summary_uninit (union ctables_summary *s, case CTSF_LAYERPCT_TOTALN: case CTSF_LAYERROWPCT_TOTALN: case CTSF_LAYERCOLPCT_TOTALN: + case CTSF_MISSING: case CSTF_TOTALN: case CTSF_ETOTALN: case CTSF_VALIDN: @@ -1729,10 +2123,10 @@ ctables_summary_uninit (union ctables_summary *s, break; case CTSF_MEDIAN: - case CTSF_MISSING: case CTSF_MODE: case CTSF_PTILE: - NOT_REACHED (); + casewriter_destroy (s->writer); + break; case CTSF_RESPONSES: case CTSF_ROWPCT_RESPONSES: @@ -1764,11 +2158,19 @@ static void ctables_summary_add (union ctables_summary *s, const struct ctables_summary_spec *ss, const struct variable *var, const union value *value, - double weight) + double d_weight, double e_weight) { switch (ss->function) { case CTSF_COUNT: + case CSTF_TOTALN: + case CTSF_VALIDN: + if (var_is_value_missing (var, value)) + s->missing += d_weight; + else + s->valid += d_weight; + break; + case CTSF_ECOUNT: case CTSF_ROWPCT_COUNT: case CTSF_COLPCT_COUNT: @@ -1791,14 +2193,13 @@ ctables_summary_add (union ctables_summary *s, case CTSF_LAYERPCT_TOTALN: case CTSF_LAYERROWPCT_TOTALN: case CTSF_LAYERCOLPCT_TOTALN: - case CSTF_TOTALN: + case CTSF_MISSING: case CTSF_ETOTALN: - case CTSF_VALIDN: case CTSF_EVALIDN: if (var_is_value_missing (var, value)) - s->missing += weight; + s->missing += e_weight; else - s->valid += weight; + s->valid += e_weight; break; case CTSF_MAXIMUM: @@ -1826,14 +2227,23 @@ ctables_summary_add (union ctables_summary *s, case CTSF_LAYERPCT_SUM: case CTSF_LAYERROWPCT_SUM: case CTSF_LAYERCOLPCT_SUM: - moments1_add (s->moments, value->f, weight); + if (!var_is_value_missing (var, value)) + moments1_add (s->moments, value->f, e_weight); break; case CTSF_MEDIAN: - case CTSF_MISSING: case CTSF_MODE: case CTSF_PTILE: - NOT_REACHED (); + if (var_is_value_missing (var, value)) + { + s->ovalid += e_weight; + + struct ccase *c = case_create (casewriter_get_proto (s->writer)); + *case_num_rw_idx (c, 0) = value->f; + *case_num_rw_idx (c, 1) = e_weight; + casewriter_write (s->writer, c); + } + break; case CTSF_RESPONSES: case CTSF_ROWPCT_RESPONSES: @@ -1861,6 +2271,99 @@ ctables_summary_add (union ctables_summary *s, } } +static enum ctables_domain_type +ctables_function_domain (enum ctables_summary_function function) +{ + switch (function) + { + case CTSF_COUNT: + case CTSF_ECOUNT: + case CTSF_MISSING: + case CSTF_TOTALN: + case CTSF_ETOTALN: + case CTSF_VALIDN: + case CTSF_EVALIDN: + case CTSF_MAXIMUM: + case CTSF_MINIMUM: + case CTSF_RANGE: + case CTSF_MEAN: + case CTSF_SEMEAN: + case CTSF_STDDEV: + case CTSF_SUM: + case CTSF_VARIANCE: + case CTSF_MEDIAN: + case CTSF_PTILE: + case CTSF_MODE: + case CTSF_RESPONSES: + NOT_REACHED (); + + case CTSF_COLPCT_COUNT: + case CTSF_COLPCT_COUNT_RESPONSES: + case CTSF_COLPCT_RESPONSES: + case CTSF_COLPCT_RESPONSES_COUNT: + case CTSF_COLPCT_SUM: + case CTSF_COLPCT_TOTALN: + case CTSF_COLPCT_VALIDN: + return CTDT_COL; + + case CTSF_LAYERCOLPCT_COUNT: + case CTSF_LAYERCOLPCT_COUNT_RESPONSES: + case CTSF_LAYERCOLPCT_RESPONSES: + case CTSF_LAYERCOLPCT_RESPONSES_COUNT: + case CTSF_LAYERCOLPCT_SUM: + case CTSF_LAYERCOLPCT_TOTALN: + case CTSF_LAYERCOLPCT_VALIDN: + return CTDT_LAYERCOL; + + case CTSF_LAYERPCT_COUNT: + case CTSF_LAYERPCT_COUNT_RESPONSES: + case CTSF_LAYERPCT_RESPONSES: + case CTSF_LAYERPCT_RESPONSES_COUNT: + case CTSF_LAYERPCT_SUM: + case CTSF_LAYERPCT_TOTALN: + case CTSF_LAYERPCT_VALIDN: + return CTDT_LAYER; + + case CTSF_LAYERROWPCT_COUNT: + case CTSF_LAYERROWPCT_COUNT_RESPONSES: + case CTSF_LAYERROWPCT_RESPONSES: + case CTSF_LAYERROWPCT_RESPONSES_COUNT: + case CTSF_LAYERROWPCT_SUM: + case CTSF_LAYERROWPCT_TOTALN: + case CTSF_LAYERROWPCT_VALIDN: + return CTDT_LAYERROW; + + case CTSF_ROWPCT_COUNT: + case CTSF_ROWPCT_COUNT_RESPONSES: + case CTSF_ROWPCT_RESPONSES: + case CTSF_ROWPCT_RESPONSES_COUNT: + case CTSF_ROWPCT_SUM: + case CTSF_ROWPCT_TOTALN: + case CTSF_ROWPCT_VALIDN: + return CTDT_ROW; + + case CTSF_SUBTABLEPCT_COUNT: + case CTSF_SUBTABLEPCT_COUNT_RESPONSES: + case CTSF_SUBTABLEPCT_RESPONSES: + case CTSF_SUBTABLEPCT_RESPONSES_COUNT: + case CTSF_SUBTABLEPCT_SUM: + case CTSF_SUBTABLEPCT_TOTALN: + case CTSF_SUBTABLEPCT_VALIDN: + return CTDT_SUBTABLE; + + case CTSF_TABLEPCT_COUNT: + case CTSF_TABLEPCT_COUNT_RESPONSES: + case CTSF_TABLEPCT_RESPONSES: + case CTSF_TABLEPCT_RESPONSES_COUNT: + case CTSF_TABLEPCT_SUM: + case CTSF_TABLEPCT_TOTALN: + case CTSF_TABLEPCT_VALIDN: + return CTDT_TABLE; + } + + NOT_REACHED (); +} + static double ctables_summary_value (const struct ctables_cell *cell, union ctables_summary *s, @@ -1872,26 +2375,19 @@ ctables_summary_value (const struct ctables_cell *cell, case CTSF_ECOUNT: return s->valid; - case CTSF_SUBTABLEPCT_COUNT: - return cell->domains[CTDT_SUBTABLE]->valid ? s->valid / cell->domains[CTDT_SUBTABLE]->valid * 100 : SYSMIS; - case CTSF_ROWPCT_COUNT: - return cell->domains[CTDT_ROW]->valid ? s->valid / cell->domains[CTDT_ROW]->valid * 100 : SYSMIS; - case CTSF_COLPCT_COUNT: - return cell->domains[CTDT_COL]->valid ? s->valid / cell->domains[CTDT_COL]->valid * 100 : SYSMIS; - case CTSF_TABLEPCT_COUNT: - return cell->domains[CTDT_TABLE]->valid ? s->valid / cell->domains[CTDT_TABLE]->valid * 100 : SYSMIS; - + case CTSF_SUBTABLEPCT_COUNT: case CTSF_LAYERPCT_COUNT: - return cell->domains[CTDT_LAYER]->valid ? s->valid / cell->domains[CTDT_LAYER]->valid * 100 : SYSMIS; - case CTSF_LAYERROWPCT_COUNT: - return cell->domains[CTDT_LAYERROW]->valid ? s->valid / cell->domains[CTDT_LAYERROW]->valid * 100 : SYSMIS; - case CTSF_LAYERCOLPCT_COUNT: - return cell->domains[CTDT_LAYERCOL]->valid ? s->valid / cell->domains[CTDT_LAYERCOL]->valid * 100 : SYSMIS; + { + enum ctables_domain_type d = ctables_function_domain (ss->function); + return (cell->domains[d]->e_valid + ? s->valid / cell->domains[d]->e_valid * 100 + : SYSMIS); + } case CTSF_ROWPCT_VALIDN: case CTSF_COLPCT_VALIDN: @@ -1909,6 +2405,9 @@ ctables_summary_value (const struct ctables_cell *cell, case CTSF_LAYERCOLPCT_TOTALN: NOT_REACHED (); + case CTSF_MISSING: + return s->missing; + case CSTF_TOTALN: case CTSF_ETOTALN: return s->valid + s->missing; @@ -1971,10 +2470,34 @@ ctables_summary_value (const struct ctables_cell *cell, NOT_REACHED (); case CTSF_MEDIAN: - case CTSF_MISSING: - case CTSF_MODE: case CTSF_PTILE: - NOT_REACHED (); + if (s->writer) + { + struct casereader *reader = casewriter_make_reader (s->writer); + s->writer = NULL; + + struct percentile *ptile = percentile_create ( + ss->function == CTSF_PTILE ? ss->percentile : 0.5, s->ovalid); + struct order_stats *os = &ptile->parent; + order_stats_accumulate_idx (&os, 1, reader, 1, 0); + s->ovalue = percentile_calculate (ptile, PC_HAVERAGE); + statistic_destroy (&ptile->parent.parent); + } + return s->ovalue; + + case CTSF_MODE: + if (s->writer) + { + struct casereader *reader = casewriter_make_reader (s->writer); + s->writer = NULL; + + struct mode *mode = mode_create (); + struct order_stats *os = &mode->parent; + order_stats_accumulate_idx (&os, 1, reader, 1, 0); + s->ovalue = mode->mode; + statistic_destroy (&mode->parent.parent); + } + return s->ovalue; case CTSF_RESPONSES: case CTSF_ROWPCT_RESPONSES: @@ -2006,7 +2529,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; }; @@ -2019,12 +2542,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].stack_idx; - size_t b_idx = b->axes[aux->a].stack_idx; - if (a_idx != b_idx) - return a_idx < b_idx ? -1 : 1; - - const struct ctables_nest *nest = &aux->t->stacks[aux->a].nests[a_idx]; + const struct ctables_nest *nest = aux->nest; for (size_t i = 0; i < nest->n; i++) if (i != nest->scale_idx) { @@ -2041,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; @@ -2103,15 +2621,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].stack_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]; @@ -2121,16 +2637,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].stack_idx; - if (idx != df->axes[a].stack_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]; @@ -2147,7 +2659,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; } @@ -2180,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; @@ -2212,25 +2726,21 @@ 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]]; - 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) { 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 @@ -2239,19 +2749,17 @@ 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].stack_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 || (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]))))) @@ -2266,448 +2774,1822 @@ ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c, cell = xmalloc (sizeof *cell); cell->hide = false; cell->sv = sv; + cell->contributes_to_domains = true; + cell->postcompute = false; for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) { - const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]]; - cell->axes[a].stack_idx = ix[a]; + const struct ctables_nest *nest = s->nests[a]; cell->axes[a].cvs = (nest->n ? xnmalloc (nest->n, sizeof *cell->axes[a].cvs) : NULL); for (size_t i = 0; i < nest->n; i++) { + const struct ctables_category *cat = cats[a][i]; if (i != nest->scale_idx) { - const struct ctables_category *subtotal = cats[a][i]->subtotal; - if (subtotal && subtotal->type == CCT_HSUBTOTAL) + const struct ctables_category *subtotal = cat->subtotal; + if (cat->hide || (subtotal && subtotal->hide_subcategories)) cell->hide = true; + + 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 = cats[a][i]; + cell->axes[a].cvs[i].category = cat; value_clone (&cell->axes[a].cvs[i].value, case_data (c, nest->vars[i]), var_get_width (nest->vars[i])); } } + 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++) 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 weight) + double d_weight, double e_weight) { - struct ctables_cell *cell = ctables_cell_insert__ (t, c, ix, cats); - const struct ctables_nest *ss = &t->stacks[t->summary_axis].nests[ix[t->summary_axis]]; + 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++) ctables_summary_add (&cell->summaries[i], &specs->specs[i], specs->var, - case_data (c, specs->var), weight); - for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++) - cell->domains[dt]->valid += weight; + case_data (c, specs->var), d_weight, e_weight); + if (cell->contributes_to_domains) + { + for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++) + { + cell->domains[dt]->d_valid += d_weight; + cell->domains[dt]->e_valid += e_weight; + } + } } static void -recurse_totals (struct ctables_table *t, const struct ccase *c, - size_t ix[PIVOT_N_AXES], +recurse_totals (struct ctables_section *s, const struct ccase *c, const struct ctables_category *cats[PIVOT_N_AXES][10], - double weight, + double d_weight, double e_weight, enum pivot_axis_type start_axis, size_t start_nest) { for (enum pivot_axis_type a = start_axis; a < PIVOT_N_AXES; a++) { - const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]]; - for (size_t i = start_nest; i < nest->n; i++) + const struct ctables_nest *nest = s->nests[a]; + for (size_t i = start_nest; i < nest->n; i++) + { + if (i == nest->scale_idx) + continue; + + const struct variable *var = nest->vars[i]; + + const struct ctables_category *total = ctables_categories_total ( + 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__ (s, c, cats, d_weight, e_weight); + recurse_totals (s, c, cats, d_weight, e_weight, a, i + 1); + cats[a][i] = save; + } + } + start_nest = 0; + } +} + +static void +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 = s->nests[a]; + for (size_t i = start_nest; i < nest->n; i++) + { + if (i == nest->scale_idx) + continue; + + const struct ctables_category *save = cats[a][i]; + if (save->subtotal) + { + cats[a][i] = save->subtotal; + ctables_cell_add__ (s, c, cats, d_weight, e_weight); + recurse_subtotals (s, c, cats, d_weight, e_weight, a, i + 1); + cats[a][i] = save; + } + } + start_nest = 0; + } +} + +static void +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_occurrence *o; + HMAP_FOR_EACH_WITH_HASH (o, struct ctables_occurrence, node, hash, + occurrences) + if (value_equal (value, &o->value, width)) + return; + + o = xmalloc (sizeof *o); + value_clone (&o->value, value, width); + hmap_insert (occurrences, &o->node, hash); +} + +static void +ctables_cell_insert (struct ctables_section *s, + const struct ccase *c, + double d_weight, double e_weight) +{ + 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 = s->nests[a]; + for (size_t i = 0; i < nest->n; i++) + { + if (i == nest->scale_idx) + continue; + + const struct variable *var = nest->vars[i]; + const union value *value = case_data (c, var); + + if (var_is_numeric (var) && value->f == SYSMIS) + return; + + cats[a][i] = ctables_categories_match ( + s->table->categories[var_get_dict_index (var)], value, var); + if (!cats[a][i]) + return; + } + } + + 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 (s, c, cats, d_weight, e_weight, 0, 0); + recurse_subtotals (s, c, cats, d_weight, e_weight, 0, 0); +} + +struct merge_item + { + const struct ctables_summary_spec_set *set; + size_t ofs; + }; + +static int +merge_item_compare_3way (const struct merge_item *a, const struct merge_item *b) +{ + const struct ctables_summary_spec *as = &a->set->specs[a->ofs]; + const struct ctables_summary_spec *bs = &b->set->specs[b->ofs]; + if (as->function != bs->function) + return as->function > bs->function ? 1 : -1; + else if (as->percentile != bs->percentile) + return as->percentile < bs->percentile ? 1 : -1; + return strcmp (as->label, bs->label); +} + +static struct pivot_value * +ctables_category_create_label (const struct ctables_category *cat, + const struct variable *var, + const union value *value) +{ + return (cat->type == CCT_TOTAL || cat->type == CCT_SUBTOTAL + ? 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)); +} + +static struct ctables_value * +ctables_value_find__ (struct ctables_table *t, const union value *value, + int width, unsigned int hash) +{ + struct ctables_value *clv; + HMAP_FOR_EACH_WITH_HASH (clv, struct ctables_value, node, + hash, &t->clabels_values_map) + if (value_equal (value, &clv->value, width)) + return clv; + return NULL; +} + +static struct ctables_value * +ctables_value_find (struct ctables_table *t, + const union value *value, int width) +{ + return ctables_value_find__ (t, value, width, + value_hash (value, width, 0)); +} + +static void +ctables_table_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 double +ctpo_add (double a, double b) +{ + return a + b; +} + +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++) + { + args[i] = ctables_pcexpr_evaluate (ctx, e->subs[i]); + if (!isfinite (args[i]) || args[i] == SYSMIS) + return SYSMIS; + } + return evaluate (args[0], args[1]); +} + +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++) + { + 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); + } + } + + struct ctables_cell *tc; + HMAP_FOR_EACH_WITH_HASH (tc, struct ctables_cell, node, hash, &s->cells) + { + 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"), + }; + d[a] = (t->axes[a] || a == t->summary_axis + ? pivot_dimension_create (pt, a, names[a]) + : NULL); + if (!d[a]) + continue; + + assert (t->axes[a]); + + 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; + + 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++) + { + struct ctables_section *s = sections[j]; + + 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 ctables_cell_sort_aux aux = { .nest = nest, .a = a }; + sort (sorted, n_sorted, sizeof *sorted, ctables_cell_compare_3way, &aux); + + struct ctables_level + { + enum ctables_level_type + { + CTL_VAR, /* Variable label for nest->vars[var_idx]. */ + CTL_CATEGORY, /* Category for nest->vars[var_idx]. */ + CTL_SUMMARY, /* Summary functions. */ + } + type; + + size_t var_idx; + }; + struct ctables_level *levels = xnmalloc (1 + 2 * max_depth, sizeof *levels); + size_t n_levels = 0; + 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 (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, + }; + } + } + + if (!summary_dimension && a == t->slabels_axis) + { + levels[n_levels++] = (struct ctables_level) { + .type = CTL_SUMMARY, + .var_idx = SIZE_MAX, + }; + } + + /* 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++) + { + struct ctables_cell *cell = sorted[j]; + struct ctables_cell *prev = j > 0 ? sorted[j - 1] : NULL; + + size_t n_common = 0; + if (j > 0) + { + 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_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]))) + break; + } + } + } + + for (size_t k = n_common; k < n_levels; k++) + { + const struct ctables_level *level = &levels[k]; + struct pivot_category *parent = k ? groups[k - 1] : d[a]->root; + if (level->type == CTL_SUMMARY) + { + 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 + { + 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); + } + } + + cell->axes[a].leaf = prev_leaf; + } + free (sorted); + free (groups); + } + } + + for (size_t i = 0; i < t->n_sections; i++) + { + struct ctables_section *s = &t->sections[i]; + + struct ctables_cell *cell; + HMAP_FOR_EACH (cell, struct ctables_cell, node, &s->cells) + { + if (cell->hide) + continue; + + const struct ctables_nest *specs_nest = s->nests[t->summary_axis]; + const struct ctables_summary_spec_set *specs = &specs_nest->specs[cell->sv]; + for (size_t j = 0; j < specs->n; j++) + { + size_t dindexes[5]; + size_t n_dindexes = 0; + + if (summary_dimension) + dindexes[n_dindexes++] = specs->specs[j].axis_idx; + + if (categories_dimension) + { + const struct ctables_nest *clabels_nest = s->nests[t->clabels_from_axis]; + const struct variable *var = clabels_nest->vars[clabels_nest->n - 1]; + const union value *value = &cell->axes[t->clabels_from_axis].cvs[clabels_nest->n - 1].value; + const struct ctables_value *ctv = ctables_value_find (t, value, var_get_width (var)); + assert (ctv != NULL); + dindexes[n_dindexes++] = ctv->leaf; + } + + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + if (d[a]) + { + int leaf = cell->axes[a].leaf; + if (a == t->summary_axis && !summary_dimension) + leaf += j; + dindexes[n_dindexes++] = leaf; + } + + double d = (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); + } + } + } + + pivot_table_submit (pt); +} + +static bool +ctables_check_label_position (struct ctables_table *t, enum pivot_axis_type a) +{ + enum pivot_axis_type label_pos = t->label_axis[a]; + if (label_pos == a) + return true; + + t->clabels_from_axis = a; + + const char *subcommand_name = a == PIVOT_AXIS_ROW ? "ROWLABELS" : "COLLABELS"; + const char *pos_name = label_pos == PIVOT_AXIS_LAYER ? "LAYER" : "OPPOSITE"; + + const struct ctables_stack *stack = &t->stacks[a]; + if (!stack->n) + return true; + + const struct ctables_nest *n0 = &stack->nests[0]; + assert (n0->n > 0); + const struct variable *v0 = n0->vars[n0->n - 1]; + struct ctables_categories *c0 = t->categories[var_get_dict_index (v0)]; + t->clabels_example = v0; + + for (size_t i = 0; i < c0->n_cats; i++) + if (c0->cats[i].type == CCT_FUNCTION) + { + msg (SE, _("%s=%s is not allowed with sorting based " + "on a summary function."), + subcommand_name, pos_name); + return false; + } + if (n0->n - 1 == n0->scale_idx) + { + msg (SE, _("%s=%s requires the variables to be moved to be categorical, " + "but %s is a scale variable."), + subcommand_name, pos_name, var_get_name (v0)); + return false; + } + + for (size_t i = 1; i < stack->n; i++) + { + const struct ctables_nest *ni = &stack->nests[i]; + assert (ni->n > 0); + const struct variable *vi = ni->vars[ni->n - 1]; + struct ctables_categories *ci = t->categories[var_get_dict_index (vi)]; + + if (ni->n - 1 == ni->scale_idx) + { + msg (SE, _("%s=%s requires the variables to be moved to be " + "categorical, but %s is a scale variable."), + subcommand_name, pos_name, var_get_name (vi)); + return false; + } + if (var_get_width (v0) != var_get_width (vi)) + { + msg (SE, _("%s=%s requires the variables to be " + "moved to have the same width, but %s has " + "width %d and %s has width %d."), + subcommand_name, pos_name, + var_get_name (v0), var_get_width (v0), + var_get_name (vi), var_get_width (vi)); + return false; + } + if (!val_labs_equal (var_get_value_labels (v0), + var_get_value_labels (vi))) + { + msg (SE, _("%s=%s requires the variables to be " + "moved to have the same value labels, but %s " + "and %s have different value labels."), + subcommand_name, pos_name, + var_get_name (v0), var_get_name (vi)); + return false; + } + if (!ctables_categories_equal (c0, ci)) + { + msg (SE, _("%s=%s requires the variables to be " + "moved to have the same category " + "specifications, but %s and %s have different " + "category specifications."), + subcommand_name, pos_name, + var_get_name (v0), var_get_name (vi)); + return false; + } + } + + return true; +} + +static bool +ctables_prepare_table (struct ctables_table *t) +{ + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + if (t->axes[a]) + { + t->stacks[a] = enumerate_fts (a, t->axes[a]); + + for (size_t j = 0; j < t->stacks[a].n; j++) + { + struct ctables_nest *nest = &t->stacks[a].nests[j]; + for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++) + { + nest->domains[dt] = xmalloc (nest->n * sizeof *nest->domains[dt]); + nest->n_domains[dt] = 0; + + for (size_t k = 0; k < nest->n; k++) + { + if (k == nest->scale_idx) + continue; + + switch (dt) + { + case CTDT_TABLE: + continue; + + case CTDT_LAYER: + if (a != PIVOT_AXIS_LAYER) + continue; + break; + + case CTDT_SUBTABLE: + case CTDT_ROW: + case CTDT_COL: + if (dt == CTDT_SUBTABLE ? a != PIVOT_AXIS_LAYER + : dt == CTDT_ROW ? a == PIVOT_AXIS_COLUMN + : a == PIVOT_AXIS_ROW) + { + if (k == nest->n - 1 + || (nest->scale_idx == nest->n - 1 + && k == nest->n - 2)) + continue; + } + break; + + case CTDT_LAYERROW: + if (a == PIVOT_AXIS_COLUMN) + continue; + break; + + case CTDT_LAYERCOL: + if (a == PIVOT_AXIS_ROW) + continue; + break; + } + + nest->domains[dt][nest->n_domains[dt]++] = k; + } + } + } + } + else + { + struct ctables_nest *nest = xmalloc (sizeof *nest); + *nest = (struct ctables_nest) { .n = 0 }; + t->stacks[a] = (struct ctables_stack) { .nests = nest, .n = 1 }; + } + + struct ctables_stack *stack = &t->stacks[t->summary_axis]; + for (size_t i = 0; i < stack->n; i++) + { + struct ctables_nest *nest = &stack->nests[i]; + if (!nest->specs[CSV_CELL].n) + { + struct ctables_summary_spec_set *specs = &nest->specs[CSV_CELL]; + specs->specs = xmalloc (sizeof *specs->specs); + specs->n = 1; + + enum ctables_summary_function function + = specs->var ? CTSF_MEAN : CTSF_COUNT; + struct ctables_var var = { .is_mrset = false, .var = specs->var }; + + *specs->specs = (struct ctables_summary_spec) { + .function = function, + .format = ctables_summary_default_format (function, &var), + .label = ctables_summary_default_label (function, 0), + }; + if (!specs->var) + specs->var = nest->vars[0]; + + ctables_summary_spec_set_clone (&nest->specs[CSV_TOTAL], + &nest->specs[CSV_CELL]); + } + else if (!nest->specs[CSV_TOTAL].n) + ctables_summary_spec_set_clone (&nest->specs[CSV_TOTAL], + &nest->specs[CSV_CELL]); + } + + struct ctables_summary_spec_set *merged = &t->summary_specs; + struct merge_item *items = xnmalloc (2 * stack->n, sizeof *items); + size_t n_left = 0; + for (size_t j = 0; j < stack->n; j++) + { + const struct ctables_nest *nest = &stack->nests[j]; + if (nest->n) + for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++) + items[n_left++] = (struct merge_item) { .set = &nest->specs[sv] }; + } + + while (n_left > 0) + { + struct merge_item min = items[0]; + for (size_t j = 1; j < n_left; j++) + if (merge_item_compare_3way (&items[j], &min) < 0) + min = items[j]; + + if (merged->n >= merged->allocated) + merged->specs = x2nrealloc (merged->specs, &merged->allocated, + sizeof *merged->specs); + merged->specs[merged->n++] = min.set->specs[min.ofs]; + + for (size_t j = 0; j < n_left; ) + { + if (merge_item_compare_3way (&items[j], &min) == 0) + { + struct merge_item *item = &items[j]; + item->set->specs[item->ofs].axis_idx = merged->n - 1; + if (++item->ofs >= item->set->n) + { + items[j] = items[--n_left]; + continue; + } + } + j++; + } + } + +#if 0 + for (size_t j = 0; j < merged->n; j++) + printf ("%s\n", ctables_summary_function_name (merged->specs[j].function)); + + for (size_t j = 0; j < stack->n; j++) + { + const struct ctables_nest *nest = &stack->nests[j]; + for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++) + { + const struct ctables_summary_spec_set *specs = &nest->specs[sv]; + for (size_t k = 0; k < specs->n; k++) + printf ("(%s, %zu) ", ctables_summary_function_name (specs->specs[k].function), + specs->specs[k].axis_idx); + printf ("\n"); + } + } +#endif + + return (ctables_check_label_position (t, PIVOT_AXIS_ROW) + && ctables_check_label_position (t, PIVOT_AXIS_COLUMN)); +} + +static void +ctables_insert_clabels_values (struct ctables_table *t, const struct ccase *c, + enum pivot_axis_type a) +{ + struct ctables_stack *stack = &t->stacks[a]; + for (size_t i = 0; i < stack->n; i++) + { + const struct ctables_nest *nest = &stack->nests[i]; + const struct variable *var = nest->vars[nest->n - 1]; + int width = var_get_width (var); + const union value *value = case_data (c, var); + + if (var_is_numeric (var) && value->f == SYSMIS) + continue; + + if (!ctables_categories_match (t->categories [var_get_dict_index (var)], + value, var)) + continue; + + unsigned int hash = value_hash (value, width, 0); + + struct ctables_value *clv = ctables_value_find__ (t, value, width, hash); + if (!clv) + { + clv = xmalloc (sizeof *clv); + value_clone (&clv->value, value, width); + hmap_insert (&t->clabels_values_map, &clv->node, hash); + } + } +} + +static int +compare_clabels_values_3way (const void *a_, const void *b_, const void *width_) +{ + const struct ctables_value *const *ap = a_; + const struct ctables_value *const *bp = b_; + const struct ctables_value *a = *ap; + const struct ctables_value *b = *bp; + const int *width = width_; + return value_compare_3way (&a->value, &b->value, *width); +} + +static void +ctables_sort_clabels_values (struct ctables_table *t) +{ + int width = var_get_width (t->clabels_example); + + size_t n = hmap_count (&t->clabels_values_map); + t->clabels_values = xnmalloc (n, sizeof *t->clabels_values); + + struct ctables_value *clv; + size_t i = 0; + HMAP_FOR_EACH (clv, struct ctables_value, node, &t->clabels_values_map) + t->clabels_values[i++] = clv; + t->n_clabels_values = n; + assert (i == n); + + sort (t->clabels_values, n, sizeof *t->clabels_values, + compare_clabels_values_3way, &width); + + for (size_t i = 0; i < n; i++) + t->clabels_values[i]->leaf = i; +} + +static void +ctables_add_category_occurrences (const struct variable *var, + struct hmap *occurrences, + const struct ctables_categories *cats) +{ + const struct val_labs *val_labs = var_get_value_labels (var); + + for (size_t i = 0; i < cats->n_cats; i++) + { + const struct ctables_category *c = &cats->cats[i]; + switch (c->type) + { + case CCT_NUMBER: + ctables_add_occurrence (var, &(const union value) { .f = c->number }, + occurrences); + break; + + case CCT_STRING: + abort (); /* XXX */ + + case CCT_RANGE: + assert (var_is_numeric (var)); + for (const struct val_lab *vl = val_labs_first (val_labs); vl; + vl = val_labs_next (val_labs, vl)) + if (vl->value.f >= c->range[0] && vl->value.f <= c->range[1]) + ctables_add_occurrence (var, &vl->value, occurrences); + break; + + case CCT_MISSING: + for (const struct val_lab *vl = val_labs_first (val_labs); vl; + vl = val_labs_next (val_labs, vl)) + if (var_is_value_missing (var, &vl->value)) + ctables_add_occurrence (var, &vl->value, occurrences); + break; + + case CCT_OTHERNM: + for (const struct val_lab *vl = val_labs_first (val_labs); vl; + vl = val_labs_next (val_labs, vl)) + ctables_add_occurrence (var, &vl->value, occurrences); + break; + + case CCT_POSTCOMPUTE: + break; + + case CCT_SUBTOTAL: + 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]; + 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); + } + } + } +} + +static void +ctables_section_add_empty_categories (struct ctables_section *s) +{ + bool show_empty = false; + for (size_t a = 0; a < PIVOT_N_AXES; a++) + if (s->nests[a]) + for (size_t k = 0; k < s->nests[a]->n; k++) + if (k != s->nests[a]->scale_idx) + { + const struct variable *var = s->nests[a]->vars[k]; + const struct ctables_categories *cats = s->table->categories[ + var_get_dict_index (var)]; + if (cats->show_empty) + { + show_empty = true; + ctables_add_category_occurrences (var, &s->occurrences[a][k], cats); + } + } + if (!show_empty) + return; + + const struct ctables_category *cats[PIVOT_N_AXES][10]; /* XXX */ + struct ccase *c = case_create (dict_get_proto (s->table->ctables->dict)); + ctables_section_recurse_add_empty_categories (s, cats, c, 0, 0); + case_unref (c); +} + +static bool +ctables_execute (struct dataset *ds, struct ctables *ct) +{ + for (size_t i = 0; i < ct->n_tables; i++) + { + struct ctables_table *t = ct->tables[i]; + t->sections = xnmalloc (MAX (1, t->stacks[PIVOT_AXIS_ROW].n) * + MAX (1, t->stacks[PIVOT_AXIS_COLUMN].n) * + MAX (1, t->stacks[PIVOT_AXIS_LAYER].n), + sizeof *t->sections); + size_t ix[PIVOT_N_AXES]; + ctables_table_add_section (t, 0, ix); + } + + struct casereader *input = proc_open (ds); + bool warn_on_invalid = true; + for (struct ccase *c = casereader_read (input); c; + case_unref (c), c = casereader_read (input)) + { + double d_weight = dict_get_case_weight (dataset_dict (ds), c, + &warn_on_invalid); + double e_weight = (ct->e_weight + ? var_force_valid_weight (ct->e_weight, + case_num (c, ct->e_weight), + &warn_on_invalid) + : d_weight); + + for (size_t i = 0; i < ct->n_tables; i++) + { + struct ctables_table *t = ct->tables[i]; + + for (size_t j = 0; j < t->n_sections; j++) + ctables_cell_insert (&t->sections[j], c, d_weight, e_weight); + + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + if (t->label_axis[a] != a) + ctables_insert_clabels_values (t, c, a); + } + } + casereader_destroy (input); + + for (size_t i = 0; i < ct->n_tables; i++) + { + struct ctables_table *t = ct->tables[i]; + + if (t->clabels_example) + ctables_sort_clabels_values (t); + + for (size_t j = 0; j < t->n_sections; j++) + ctables_section_add_empty_categories (&t->sections[j]); + + ctables_table_output (ct, ct->tables[i]); + } + return proc_commit (ds); +} + +/* 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)) { - if (i == nest->scale_idx) - continue; - - const struct variable *var = nest->vars[i]; - - const struct ctables_category *total = ctables_categories_total ( - t->categories[var_get_dict_index (var)]); - if (total) - { - const struct ctables_category *save = cats[a][i]; - cats[a][i] = total; - ctables_cell_add__ (t, c, ix, cats, weight); - recurse_totals (t, c, ix, cats, weight, a, i + 1); - cats[a][i] = save; - } + ctables_pcexpr_destroy (ep); + return NULL; } - start_nest = 0; + 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 void -ctables_cell_insert (struct ctables_table *t, - const struct ccase *c, - size_t ir, size_t ic, size_t il, - double weight) +static struct ctables_pcexpr * +ctables_pcexpr_allocate_neg (struct ctables_pcexpr *sub, + struct lexer *lexer, int start_ofs) { - size_t ix[PIVOT_N_AXES] = { - [PIVOT_AXIS_ROW] = ir, - [PIVOT_AXIS_COLUMN] = ic, - [PIVOT_AXIS_LAYER] = il, + 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; +} - const struct ctables_category *cats[PIVOT_N_AXES][10]; - for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) - { - const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]]; - for (size_t i = 0; i < nest->n; i++) - { - if (i == nest->scale_idx) - continue; +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); - const struct variable *var = nest->vars[i]; - const union value *value = case_data (c, var); + struct ctables_pcexpr *node = parse_binary_operators__ ( + lexer, &op, 1, parse_primary, chain_warning, lhs); + if (!node) + return NULL; - if (var_is_numeric (var) && value->f == SYSMIS) - return; + return ctables_pcexpr_allocate_neg (node, lexer, start_ofs); +} - cats[a][i] = ctables_categories_match ( - t->categories[var_get_dict_index (var)], value, var); - if (!cats[a][i]) - return; - } - } +/* 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); - ctables_cell_add__ (t, c, ix, cats, weight); + struct ctables_pcexpr *inner = parse_neg (lexer); + if (!inner) + return NULL; - recurse_totals (t, c, ix, cats, weight, 0, 0); + return ctables_pcexpr_allocate_neg (inner, lexer, start_ofs); +} - for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) +/* Parses the multiplication and division level. */ +static struct ctables_pcexpr * +parse_mul (struct lexer *lexer) +{ + static const struct operator ops[] = { - const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]]; - for (size_t i = 0; i < nest->n; i++) - { - if (i == nest->scale_idx) - continue; + { T_ASTERISK, CTPO_MUL }, + { T_SLASH, CTPO_DIV }, + }; - const struct ctables_category *save = cats[a][i]; - if (save->subtotal) - { - cats[a][i] = save->subtotal; - ctables_cell_add__ (t, c, ix, cats, weight); - cats[a][i] = save; - } - } - } + return parse_binary_operators (lexer, ops, sizeof ops / sizeof *ops, + parse_neg, NULL); } -static bool -ctables_execute (struct dataset *ds, struct ctables *ct) +/* Parses the addition and subtraction level. */ +static struct ctables_pcexpr * +parse_add (struct lexer *lexer) { - for (size_t i = 0; i < ct->n_tables; i++) + static const struct operator ops[] = { - struct ctables_table *t = ct->tables[i]; - for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) - if (t->axes[a]) - { - t->stacks[a] = enumerate_fts (a, t->axes[a]); - - for (size_t j = 0; j < t->stacks[a].n; j++) - { - struct ctables_nest *nest = &t->stacks[a].nests[j]; - for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++) - { - nest->domains[dt] = xmalloc (nest->n * sizeof *nest->domains[dt]); - nest->n_domains[dt] = 0; - - for (size_t k = 0; k < nest->n; k++) - { - if (k == nest->scale_idx) - continue; - - switch (dt) - { - case CTDT_TABLE: - continue; - - case CTDT_LAYER: - if (a != PIVOT_AXIS_LAYER) - continue; - break; + { T_PLUS, CTPO_ADD }, + { T_DASH, CTPO_SUB }, + { T_NEG_NUM, CTPO_ADD }, + }; - case CTDT_SUBTABLE: - case CTDT_ROW: - case CTDT_COL: - if (dt == CTDT_SUBTABLE ? a != PIVOT_AXIS_LAYER - : dt == CTDT_ROW ? a == PIVOT_AXIS_COLUMN - : a == PIVOT_AXIS_ROW) - { - if (k == nest->n - 1 - || (nest->scale_idx == nest->n - 1 - && k == nest->n - 2)) - continue; - } - break; + return parse_binary_operators (lexer, ops, sizeof ops / sizeof *ops, + parse_mul, NULL); +} - case CTDT_LAYERROW: - if (a == PIVOT_AXIS_COLUMN) - continue; - break; +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; +} - case CTDT_LAYERCOL: - if (a == PIVOT_AXIS_ROW) - continue; - break; - } +static bool +ctables_parse_pcompute (struct lexer *lexer, struct ctables *ct) +{ + int pcompute_start = lex_ofs (lexer) - 1; - nest->domains[dt][nest->n_domains[dt]++] = k; - } - } - } - } - else - { - struct ctables_nest *nest = xmalloc (sizeof *nest); - *nest = (struct ctables_nest) { .n = 0 }; - t->stacks[a] = (struct ctables_stack) { .nests = nest, .n = 1 }; - } + if (!lex_force_match (lexer, T_AND) || !lex_force_id (lexer)) + return false; - for (size_t i = 0; i < t->stacks[t->summary_axis].n; i++) - { - struct ctables_nest *nest = &t->stacks[t->summary_axis].nests[i]; - if (!nest->specs[CSV_CELL].n) - { - struct ctables_summary_spec_set *sss = &nest->specs[CSV_CELL]; - sss->specs = xmalloc (sizeof *sss->specs); - sss->n = 1; - - enum ctables_summary_function function - = sss->var ? CTSF_MEAN : CTSF_COUNT; - struct ctables_var var = { .is_mrset = false, .var = sss->var }; - - *sss->specs = (struct ctables_summary_spec) { - .function = function, - .format = ctables_summary_default_format (function, &var), - .label = ctables_summary_default_label (function, 0), - }; - if (!sss->var) - sss->var = nest->vars[0]; + char *name = ss_xstrdup (lex_tokss (lexer)); - nest->specs[CSV_TOTAL] = nest->specs[CSV_CELL]; - } - else if (!nest->specs[CSV_TOTAL].n) - nest->specs[CSV_TOTAL] = nest->specs[CSV_CELL]; - } + 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 casereader *input = casereader_create_filter_weight (proc_open (ds), - dataset_dict (ds), - NULL, NULL); - bool warn_on_invalid = true; - double total_weight = 0; - for (struct ccase *c = casereader_read (input); c; - case_unref (c), c = casereader_read (input)) + 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)) { - double weight = dict_get_case_weight (dataset_dict (ds), c, - &warn_on_invalid); - total_weight += weight; + free (name); + return false; + } + int pcompute_end = lex_ofs (lexer) - 1; - for (size_t i = 0; i < ct->n_tables; i++) - { - struct ctables_table *t = ct->tables[i]; + struct msg_location *location = lex_ofs_location (lexer, pcompute_start, + pcompute_end); - for (size_t ir = 0; ir < t->stacks[PIVOT_AXIS_ROW].n; ir++) - for (size_t ic = 0; ic < t->stacks[PIVOT_AXIS_COLUMN].n; ic++) - for (size_t il = 0; il < t->stacks[PIVOT_AXIS_LAYER].n; il++) - ctables_cell_insert (t, c, ir, ic, il, weight); - } + 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); } - casereader_destroy (input); - - for (size_t i = 0; i < ct->n_tables; i++) + else { - struct ctables_table *t = ct->tables[i]; - - struct pivot_table *pt = pivot_table_create__ ( - (t->title - ? pivot_value_new_user_text (t->title, SIZE_MAX) - : pivot_value_new_text (N_("Custom Tables"))), - "Custom Tables"); - if (t->caption) - pivot_table_set_caption ( - pt, pivot_value_new_user_text (t->caption, SIZE_MAX)); - if (t->corner) - pivot_table_set_caption ( - pt, pivot_value_new_user_text (t->corner, SIZE_MAX)); - - pivot_table_set_look (pt, ct->look); - struct pivot_dimension *d[PIVOT_N_AXES]; - for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) - { - static const char *names[] = { - [PIVOT_AXIS_ROW] = N_("Rows"), - [PIVOT_AXIS_COLUMN] = N_("Columns"), - [PIVOT_AXIS_LAYER] = N_("Layers"), - }; - d[a] = (t->axes[a] || a == t->summary_axis - ? pivot_dimension_create (pt, a, names[a]) - : NULL); - if (!d[a]) - continue; - - assert (t->axes[a]); - - struct ctables_cell **sorted = xnmalloc (t->cells.count, sizeof *sorted); + 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; +} - struct ctables_cell *cell; - size_t n = 0; - HMAP_FOR_EACH (cell, struct ctables_cell, node, &t->cells) - if (!cell->hide) - sorted[n++] = cell; - assert (n <= t->cells.count); +static bool +ctables_parse_pproperties_format (struct lexer *lexer, + struct ctables_summary_spec_set *sss) +{ + *sss = (struct ctables_summary_spec_set) { .n = 0 }; - struct ctables_cell_sort_aux aux = { .t = t, .a = a }; - sort (sorted, n, sizeof *sorted, ctables_cell_compare_3way, &aux); + 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; - 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; + /* 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); + } - struct pivot_category **groups = xnmalloc (max_depth, sizeof *groups); - struct pivot_category *top = NULL; - int prev_leaf = 0; - for (size_t j = 0; j < n; j++) - { - struct ctables_cell *cell = sorted[j]; - const struct ctables_nest *nest = &t->stacks[a].nests[cell->axes[a].stack_idx]; + /* 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; - size_t n_common = 0; - bool new_subtable = false; - if (j > 0) - { - struct ctables_cell *prev = sorted[j - 1]; - if (prev->axes[a].stack_idx == cell->axes[a].stack_idx) - { - for (; n_common < nest->n; n_common++) - if (n_common != nest->scale_idx - && (prev->axes[a].cvs[n_common].category - != cell->axes[a].cvs[n_common].category - || !value_equal (&prev->axes[a].cvs[n_common].value, - &cell->axes[a].cvs[n_common].value, - var_get_type (nest->vars[n_common])))) - break; - } - else - new_subtable = true; - } - else - new_subtable = true; + if (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; - if (new_subtable) - { - enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (nest->vars[0])]; - top = d[a]->root; - if (vlabel != CTVL_NONE) - top = pivot_category_create_group__ ( - top, pivot_value_new_variable (nest->vars[0])); - } - if (n_common == nest->n) - { - cell->axes[a].leaf = prev_leaf; - continue; - } +error: + ctables_summary_spec_set_uninit (sss); + return false; +} - for (size_t k = n_common; k < nest->n; k++) - { - struct pivot_category *parent = k > 0 ? groups[k - 1] : top; - - struct pivot_value *label - = (k == nest->scale_idx ? NULL - : (cell->axes[a].cvs[k].category->type == CCT_TOTAL - || cell->axes[a].cvs[k].category->type == CCT_SUBTOTAL - || cell->axes[a].cvs[k].category->type == CCT_HSUBTOTAL) - ? pivot_value_new_user_text (cell->axes[a].cvs[k].category->total_label, - SIZE_MAX) - : pivot_value_new_var_value (nest->vars[k], - &cell->axes[a].cvs[k].value)); - if (k == nest->n - 1) - { - if (a == t->summary_axis) - { - if (label) - parent = pivot_category_create_group__ (parent, label); - const struct ctables_summary_spec_set *specs = &nest->specs[cell->sv]; - for (size_t m = 0; m < specs->n; m++) - { - int leaf = pivot_category_create_leaf ( - parent, pivot_value_new_text (specs->specs[m].label)); - if (m == 0) - prev_leaf = leaf; - } - } - else - { - /* This assertion is true as long as the summary axis - is the axis where the summaries are displayed. */ - assert (label); +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; - prev_leaf = pivot_category_create_leaf (parent, label); - } - break; - } + 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 (label) - parent = pivot_category_create_group__ (parent, label); + if (n_pcs >= allocated_pcs) + pcs = x2nrealloc (pcs, &allocated_pcs, sizeof *pcs); + pcs[n_pcs++] = pc; + } - enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (nest->vars[k + 1])]; - if (vlabel != CTVL_NONE) - parent = pivot_category_create_group__ ( - parent, pivot_value_new_variable (nest->vars[k + 1])); - groups[k] = parent; - } + 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; - cell->axes[a].leaf = prev_leaf; + for (size_t i = 0; i < n_pcs; i++) + { + free (pcs[i]->label); + pcs[i]->label = ss_xstrdup (lex_tokss (lexer)); } - free (sorted); - free (groups); + + lex_get (lexer); } - struct ctables_cell *cell; - HMAP_FOR_EACH (cell, struct ctables_cell, node, &t->cells) + else if (lex_match_id (lexer, "FORMAT")) { - if (cell->hide) - continue; - - const struct ctables_nest *nest = &t->stacks[t->summary_axis].nests[cell->axes[t->summary_axis].stack_idx]; - const struct ctables_summary_spec_set *specs = &nest->specs[cell->sv]; - for (size_t j = 0; j < specs->n; j++) - { - size_t dindexes[3]; - size_t n_dindexes = 0; + lex_match (lexer, T_EQUALS); - for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) - if (d[a]) - { - int leaf = cell->axes[a].leaf; - if (a == t->summary_axis) - leaf += j; - dindexes[n_dindexes++] = leaf; - } + struct ctables_summary_spec_set sss; + if (!ctables_parse_pproperties_format (lexer, &sss)) + goto error; - 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); + 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; } - - pivot_table_submit (pt); } + free (pcs); + return true; - return proc_commit (ds); +error: + free (pcs); + return false; } int @@ -2721,9 +4603,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; @@ -2883,14 +4767,23 @@ 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")) goto error; lex_match (lexer, T_EQUALS); - ct->base_weight = parse_variable (lexer, dataset_dict (ds)); - if (!ct->base_weight) + ct->e_weight = parse_variable (lexer, dataset_dict (ds)); + if (!ct->e_weight) goto error; } else if (lex_match_id (lexer, "HIDESMALLCOUNTS")) @@ -2935,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, @@ -2944,17 +4838,20 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) struct ctables_table *t = xmalloc (sizeof *t); *t = (struct ctables_table) { - .cells = HMAP_INITIALIZER (t->cells), - .slabels_position = PIVOT_AXIS_COLUMN, + .ctables = ct, + .slabels_axis = PIVOT_AXIS_COLUMN, .slabels_visible = true, - .row_labels = CTLP_NORMAL, - .col_labels = CTLP_NORMAL, + .clabels_values_map = HMAP_INITIALIZER (t->clabels_values_map), + .label_axis = { + [PIVOT_AXIS_ROW] = PIVOT_AXIS_ROW, + [PIVOT_AXIS_COLUMN] = PIVOT_AXIS_COLUMN, + [PIVOT_AXIS_LAYER] = PIVOT_AXIS_LAYER, + }, + .clabels_from_axis = PIVOT_AXIS_LAYER, .categories = categories, .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); @@ -3036,7 +4933,11 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) } if (lex_token (lexer) == T_ENDCMD) - break; + { + if (!ctables_prepare_table (t)) + goto error; + break; + } if (!lex_force_match (lexer, T_SLASH)) break; @@ -3044,17 +4945,17 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) { if (lex_match_id (lexer, "SLABELS")) { - while (lex_token (lexer) != T_SLASH) + while (lex_token (lexer) != T_SLASH && lex_token (lexer) != T_ENDCMD) { if (lex_match_id (lexer, "POSITION")) { lex_match (lexer, T_EQUALS); if (lex_match_id (lexer, "COLUMN")) - t->slabels_position = PIVOT_AXIS_COLUMN; + t->slabels_axis = PIVOT_AXIS_COLUMN; else if (lex_match_id (lexer, "ROW")) - t->slabels_position = PIVOT_AXIS_ROW; + t->slabels_axis = PIVOT_AXIS_ROW; else if (lex_match_id (lexer, "LAYER")) - t->slabels_position = PIVOT_AXIS_LAYER; + t->slabels_axis = PIVOT_AXIS_LAYER; else { lex_error_expecting (lexer, "COLUMN", "ROW", "LAYER"); @@ -3076,17 +4977,20 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) } else if (lex_match_id (lexer, "CLABELS")) { - while (lex_token (lexer) != T_SLASH) + while (lex_token (lexer) != T_SLASH && lex_token (lexer) != T_ENDCMD) { if (lex_match_id (lexer, "AUTO")) - t->row_labels = t->col_labels = CTLP_NORMAL; + { + t->label_axis[PIVOT_AXIS_ROW] = PIVOT_AXIS_ROW; + t->label_axis[PIVOT_AXIS_COLUMN] = PIVOT_AXIS_COLUMN; + } else if (lex_match_id (lexer, "ROWLABELS")) { lex_match (lexer, T_EQUALS); if (lex_match_id (lexer, "OPPOSITE")) - t->row_labels = CTLP_OPPOSITE; + t->label_axis[PIVOT_AXIS_ROW] = PIVOT_AXIS_COLUMN; else if (lex_match_id (lexer, "LAYER")) - t->row_labels = CTLP_LAYER; + t->label_axis[PIVOT_AXIS_ROW] = PIVOT_AXIS_LAYER; else { lex_error_expecting (lexer, "OPPOSITE", "LAYER"); @@ -3097,9 +5001,9 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) { lex_match (lexer, T_EQUALS); if (lex_match_id (lexer, "OPPOSITE")) - t->col_labels = CTLP_OPPOSITE; + t->label_axis[PIVOT_AXIS_COLUMN] = PIVOT_AXIS_ROW; else if (lex_match_id (lexer, "LAYER")) - t->col_labels = CTLP_LAYER; + t->label_axis[PIVOT_AXIS_COLUMN] = PIVOT_AXIS_LAYER; else { lex_error_expecting (lexer, "OPPOSITE", "LAYER"); @@ -3127,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")) @@ -3374,12 +5279,15 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) break; } - if (t->row_labels != CTLP_NORMAL && t->col_labels != CTLP_NORMAL) + if (t->label_axis[PIVOT_AXIS_ROW] != PIVOT_AXIS_ROW + && t->label_axis[PIVOT_AXIS_COLUMN] != PIVOT_AXIS_COLUMN) { msg (SE, _("ROWLABELS and COLLABELS may not both be specified.")); goto error; } + if (!ctables_prepare_table (t)) + goto error; } while (lex_token (lexer) != T_ENDCMD);