X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Fctables.c;fp=src%2Flanguage%2Fstats%2Fctables.c;h=1d7760f57eea502dcfc74bdc3f886e2396030a3b;hb=939955167948167d6fe2a15d1c4db7073ad638e0;hp=0000000000000000000000000000000000000000;hpb=93261332cde187e1392b6935234b2b1d8b9a1d51;p=pspp diff --git a/src/language/stats/ctables.c b/src/language/stats/ctables.c new file mode 100644 index 0000000000..1d7760f57e --- /dev/null +++ b/src/language/stats/ctables.c @@ -0,0 +1,6581 @@ +/* PSPP - a program for statistical analysis. + Copyright (C) 2021 Free Software Foundation, Inc. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +#include + +#include +#include + +#include "data/casereader.h" +#include "data/casewriter.h" +#include "data/data-in.h" +#include "data/data-out.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" +#include "language/lexer/token.h" +#include "language/lexer/variable-parser.h" +#include "libpspp/array.h" +#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" +#include "gl/xalloc.h" + +#include "gettext.h" +#define _(msgid) gettext (msgid) +#define N_(msgid) (msgid) + +enum ctables_vlabel + { + CTVL_NONE = SETTINGS_VALUE_SHOW_DEFAULT, + CTVL_NAME = SETTINGS_VALUE_SHOW_VALUE, + CTVL_LABEL = SETTINGS_VALUE_SHOW_LABEL, + CTVL_BOTH = SETTINGS_VALUE_SHOW_BOTH, + }; + +/* XXX: + - unweighted summaries (U*) + - lower confidence limits (*.LCL) + - upper confidence limits (*.UCL) + - standard error (*.SE) + */ +#define SUMMARIES \ + /* All variables. */ \ + S(CTSF_COUNT, "COUNT", N_("Count"), CTF_COUNT, CTFA_ALL) \ + S(CTSF_ECOUNT, "ECOUNT", N_("Adjusted Count"), CTF_COUNT, CTFA_ALL) \ + S(CTSF_ROWPCT_COUNT, "ROWPCT.COUNT", N_("Row %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_COLPCT_COUNT, "COLPCT.COUNT", N_("Column %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_TABLEPCT_COUNT, "TABLEPCT.COUNT", N_("Table %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_SUBTABLEPCT_COUNT, "SUBTABLEPCT.COUNT", N_("Subtable %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_LAYERPCT_COUNT, "LAYERPCT.COUNT", N_("Layer %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_LAYERROWPCT_COUNT, "LAYERROWPCT.COUNT", N_("Layer Row %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_LAYERCOLPCT_COUNT, "LAYERCOLPCT.COUNT", N_("Layer Column %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_ROWPCT_VALIDN, "ROWPCT.VALIDN", N_("Row Valid N %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_COLPCT_VALIDN, "COLPCT.VALIDN", N_("Column Valid N %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_TABLEPCT_VALIDN, "TABLEPCT.VALIDN", N_("Table Valid N %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_SUBTABLEPCT_VALIDN, "SUBTABLEPCT.VALIDN", N_("Subtable Valid N %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_LAYERPCT_VALIDN, "LAYERPCT.VALIDN", N_("Layer Valid N %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_LAYERROWPCT_VALIDN, "LAYERROWPCT.VALIDN", N_("Layer Row Valid N %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_LAYERCOLPCT_VALIDN, "LAYERCOLPCT.VALIDN", N_("Layer Column Valid N %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_ROWPCT_TOTALN, "ROWPCT.TOTALN", N_("Row Total N %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_COLPCT_TOTALN, "COLPCT.TOTALN", N_("Column Total N %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_TABLEPCT_TOTALN, "TABLEPCT.TOTALN", N_("Table Total N %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_SUBTABLEPCT_TOTALN, "SUBTABLEPCT.TOTALN", N_("Subtable Total N %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_LAYERPCT_TOTALN, "LAYERPCT.TOTALN", N_("Layer Total N %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_LAYERROWPCT_TOTALN, "LAYERROWPCT.TOTALN", N_("Layer Row Total N %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_LAYERCOLPCT_TOTALN, "LAYERCOLPCT.TOTALN", N_("Layer Column Total N %"), CTF_PERCENT, CTFA_ALL) \ + \ + /* All variables (unweighted.) */ \ + S(CTSF_UCOUNT, "UCOUNT", N_("Unweighted Count"), CTF_COUNT, CTFA_ALL) \ + S(CTSF_UROWPCT_COUNT, "UROWPCT.COUNT", N_("Unweighted Row %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_UCOLPCT_COUNT, "UCOLPCT.COUNT", N_("Unweighted Column %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_UTABLEPCT_COUNT, "UTABLEPCT.COUNT", N_("Unweighted Table %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_USUBTABLEPCT_COUNT, "USUBTABLEPCT.COUNT", N_("Unweighted Subtable %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_ULAYERPCT_COUNT, "ULAYERPCT.COUNT", N_("Unweighted Layer %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_ULAYERROWPCT_COUNT, "ULAYERROWPCT.COUNT", N_("Unweighted Layer Row %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_ULAYERCOLPCT_COUNT, "ULAYERCOLPCT.COUNT", N_("Unweighted Layer Column %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_UROWPCT_VALIDN, "UROWPCT.VALIDN", N_("Unweighted Row Valid N %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_UCOLPCT_VALIDN, "UCOLPCT.VALIDN", N_("Unweighted Column Valid N %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_UTABLEPCT_VALIDN, "UTABLEPCT.VALIDN", N_("Unweighted Table Valid N %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_USUBTABLEPCT_VALIDN, "USUBTABLEPCT.VALIDN", N_("Unweighted Subtable Valid N %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_ULAYERPCT_VALIDN, "ULAYERPCT.VALIDN", N_("Unweighted Layer Valid N %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_ULAYERROWPCT_VALIDN, "ULAYERROWPCT.VALIDN", N_("Unweighted Layer Row Valid N %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_ULAYERCOLPCT_VALIDN, "ULAYERCOLPCT.VALIDN", N_("Unweighted Layer Column Valid N %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_UROWPCT_TOTALN, "UROWPCT.TOTALN", N_("Unweighted Row Total N %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_UCOLPCT_TOTALN, "UCOLPCT.TOTALN", N_("Unweighted Column Total N %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_UTABLEPCT_TOTALN, "UTABLEPCT.TOTALN", N_("Unweighted Table Total N %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_USUBTABLEPCT_TOTALN, "USUBTABLEPCT.TOTALN", N_("Unweighted Subtable Total N %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_ULAYERPCT_TOTALN, "ULAYERPCT.TOTALN", N_("Unweighted Layer Total N %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_ULAYERROWPCT_TOTALN, "ULAYERROWPCT.TOTALN", N_("Unweighted Layer Row Total N %"), CTF_PERCENT, CTFA_ALL) \ + S(CTSF_ULAYERCOLPCT_TOTALN, "ULAYERCOLPCT.TOTALN", N_("Unweighted Layer Column Total N %"), CTF_PERCENT, CTFA_ALL) \ + \ + /* Scale variables, totals, and subtotals. */ \ + S(CTSF_MAXIMUM, "MAXIMUM", N_("Maximum"), CTF_GENERAL, CTFA_SCALE) \ + S(CTSF_MEAN, "MEAN", N_("Mean"), CTF_GENERAL, CTFA_SCALE) \ + S(CTSF_MEDIAN, "MEDIAN", N_("Median"), CTF_GENERAL, CTFA_SCALE) \ + S(CTSF_MINIMUM, "MINIMUM", N_("Minimum"), CTF_GENERAL, CTFA_SCALE) \ + S(CTSF_MISSING, "MISSING", N_("Missing"), CTF_GENERAL, CTFA_SCALE) \ + S(CTSF_MODE, "MODE", N_("Mode"), CTF_GENERAL, CTFA_SCALE) \ + S(CTSF_PTILE, "PTILE", N_("Percentile"), CTF_GENERAL, CTFA_SCALE) \ + S(CTSF_RANGE, "RANGE", N_("Range"), CTF_GENERAL, CTFA_SCALE) \ + S(CTSF_SEMEAN, "SEMEAN", N_("Std Error of Mean"), CTF_GENERAL, CTFA_SCALE) \ + S(CTSF_STDDEV, "STDDEV", N_("Std Deviation"), CTF_GENERAL, CTFA_SCALE) \ + S(CTSF_SUM, "SUM", N_("Sum"), CTF_GENERAL, CTFA_SCALE) \ + S(CSTF_TOTALN, "TOTALN", N_("Total N"), CTF_COUNT, CTFA_SCALE) \ + S(CTSF_ETOTALN, "ETOTALN", N_("Adjusted Total N"), CTF_COUNT, CTFA_SCALE) \ + S(CTSF_VALIDN, "VALIDN", N_("Valid N"), CTF_COUNT, CTFA_SCALE) \ + S(CTSF_EVALIDN, "EVALIDN", N_("Adjusted Valid N"), CTF_COUNT, CTFA_SCALE) \ + S(CTSF_VARIANCE, "VARIANCE", N_("Variance"), CTF_GENERAL, CTFA_SCALE) \ + S(CTSF_ROWPCT_SUM, "ROWPCT.SUM", N_("Row Sum %"), CTF_PERCENT, CTFA_SCALE) \ + S(CTSF_COLPCT_SUM, "COLPCT.SUM", N_("Column Sum %"), CTF_PERCENT, CTFA_SCALE) \ + S(CTSF_TABLEPCT_SUM, "TABLEPCT.SUM", N_("Table Sum %"), CTF_PERCENT, CTFA_SCALE) \ + S(CTSF_SUBTABLEPCT_SUM, "SUBTABLEPCT.SUM", N_("Subtable Sum %"), CTF_PERCENT, CTFA_SCALE) \ + S(CTSF_LAYERPCT_SUM, "LAYERPCT.SUM", N_("Layer Sum %"), CTF_PERCENT, CTFA_SCALE) \ + S(CTSF_LAYERROWPCT_SUM, "LAYERROWPCT.SUM", N_("Layer Row Sum %"), CTF_PERCENT, CTFA_SCALE) \ + S(CTSF_LAYERCOLPCT_SUM, "LAYERCOLPCT.SUM", N_("Layer Column Sum %"), CTF_PERCENT, CTFA_SCALE) \ + \ + /* Scale variables, totals, and subtotals (unweighted). */ \ + S(CTSF_UMEAN, "UMEAN", N_("Unweighted Mean"), CTF_GENERAL, CTFA_SCALE) \ + S(CTSF_UMEDIAN, "UMEDIAN", N_("Unweighted Median"), CTF_GENERAL, CTFA_SCALE) \ + S(CTSF_UMISSING, "UMISSING", N_("Unweighted Missing"), CTF_GENERAL, CTFA_SCALE) \ + S(CTSF_UMODE, "UMODE", N_("Unweighted Mode"), CTF_GENERAL, CTFA_SCALE) \ + S(CTSF_UPTILE, "UPTILE", N_("Unweighted Percentile"), CTF_GENERAL, CTFA_SCALE) \ + S(CTSF_USEMEAN, "USEMEAN", N_("Unweighted Std Error of Mean"), CTF_GENERAL, CTFA_SCALE) \ + S(CTSF_USTDDEV, "USTDDEV", N_("Unweighted Std Deviation"), CTF_GENERAL, CTFA_SCALE) \ + S(CTSF_USUM, "USUM", N_("Unweighted Sum"), CTF_GENERAL, CTFA_SCALE) \ + S(CSTF_UTOTALN, "UTOTALN", N_("Unweighted Total N"), CTF_COUNT, CTFA_SCALE) \ + S(CTSF_UVALIDN, "UVALIDN", N_("Unweighted Valid N"), CTF_COUNT, CTFA_SCALE) \ + S(CTSF_UVARIANCE, "UVARIANCE", N_("Unweighted Variance"), CTF_GENERAL, CTFA_SCALE) \ + S(CTSF_UROWPCT_SUM, "UROWPCT.SUM", N_("Unweighted Row Sum %"), CTF_PERCENT, CTFA_SCALE) \ + S(CTSF_UCOLPCT_SUM, "UCOLPCT.SUM", N_("Unweighted Column Sum %"), CTF_PERCENT, CTFA_SCALE) \ + S(CTSF_UTABLEPCT_SUM, "UTABLEPCT.SUM", N_("Unweighted Table Sum %"), CTF_PERCENT, CTFA_SCALE) \ + S(CTSF_USUBTABLEPCT_SUM, "USUBTABLEPCT.SUM", N_("Unweighted Subtable Sum %"), CTF_PERCENT, CTFA_SCALE) \ + S(CTSF_ULAYERPCT_SUM, "ULAYERPCT.SUM", N_("Unweighted Layer Sum %"), CTF_PERCENT, CTFA_SCALE) \ + S(CTSF_ULAYERROWPCT_SUM, "ULAYERROWPCT.SUM", N_("Unweighted Layer Row Sum %"), CTF_PERCENT, CTFA_SCALE) \ + S(CTSF_ULAYERCOLPCT_SUM, "ULAYERCOLPCT.SUM", N_("Unweighted Layer Column Sum %"), CTF_PERCENT, CTFA_SCALE) \ + +#if 0 /* Multiple response sets not yet implemented. */ + S(CTSF_RESPONSES, "RESPONSES", N_("Responses"), CTF_COUNT, CTFA_MRSETS) \ + S(CTSF_ROWPCT_RESPONSES, "ROWPCT.RESPONSES", N_("Row Responses %"), CTF_PERCENT, CTFA_MRSETS) \ + S(CTSF_COLPCT_RESPONSES, "COLPCT.RESPONSES", N_("Column Responses %"), CTF_PERCENT, CTFA_MRSETS) \ + S(CTSF_TABLEPCT_RESPONSES, "TABLEPCT.RESPONSES", N_("Table Responses %"), CTF_PERCENT, CTFA_MRSETS) \ + S(CTSF_SUBTABLEPCT_RESPONSES, "SUBTABLEPCT.RESPONSES", N_("Subtable Responses %"), CTF_PERCENT, CTFA_MRSETS) \ + S(CTSF_LAYERPCT_RESPONSES, "LAYERPCT.RESPONSES", N_("Layer Responses %"), CTF_PERCENT, CTFA_MRSETS) \ + S(CTSF_LAYERROWPCT_RESPONSES, "LAYERROWPCT.RESPONSES", N_("Layer Row Responses %"), CTF_PERCENT, CTFA_MRSETS) \ + S(CTSF_LAYERCOLPCT_RESPONSES, "LAYERCOLPCT.RESPONSES", N_("Layer Column Responses %"), CTF_PERCENT, CTFA_MRSETS) \ + S(CTSF_ROWPCT_RESPONSES_COUNT, "ROWPCT.RESPONSES.COUNT", N_("Row Responses % (Base: Count)"), CTF_PERCENT, CTFA_MRSETS) \ + S(CTSF_COLPCT_RESPONSES_COUNT, "COLPCT.RESPONSES.COUNT", N_("Column Responses % (Base: Count)"), CTF_PERCENT, CTFA_MRSETS) \ + S(CTSF_TABLEPCT_RESPONSES_COUNT, "TABLEPCT.RESPONSES.COUNT", N_("Table Responses % (Base: Count)"), CTF_PERCENT, CTFA_MRSETS) \ + S(CTSF_SUBTABLEPCT_RESPONSES_COUNT, "SUBTABLEPCT.RESPONSES.COUNT", N_("Subtable Responses % (Base: Count)"), CTF_PERCENT, CTFA_MRSETS) \ + S(CTSF_LAYERPCT_RESPONSES_COUNT, "LAYERPCT.RESPONSES.COUNT", N_("Layer Responses % (Base: Count)"), CTF_PERCENT, CTFA_MRSETS) \ + S(CTSF_LAYERROWPCT_RESPONSES_COUNT, "LAYERROWPCT.RESPONSES.COUNT", N_("Layer Row Responses % (Base: Count)"), CTF_PERCENT, CTFA_MRSETS) \ + S(CTSF_LAYERCOLPCT_RESPONSES_COUNT, "LAYERCOLPCT.RESPONSES.COUNT", N_("Layer Column Responses % (Base: Count)"), CTF_PERCENT, CTFA_MRSETS) \ + S(CTSF_ROWPCT_COUNT_RESPONSES, "ROWPCT.COUNT.RESPONSES", N_("Row Count % (Base: Responses)"), CTF_PERCENT, CTFA_MRSETS) \ + S(CTSF_COLPCT_COUNT_RESPONSES, "COLPCT.COUNT.RESPONSES", N_("Column Count % (Base: Responses)"), CTF_PERCENT, CTFA_MRSETS) \ + S(CTSF_TABLEPCT_COUNT_RESPONSES, "TABLEPCT.COUNT.RESPONSES", N_("Table Count % (Base: Responses)"), CTF_PERCENT, CTFA_MRSETS) \ + S(CTSF_SUBTABLEPCT_COUNT_RESPONSES, "SUBTABLEPCT.COUNT.RESPONSES", N_("Subtable Count % (Base: Responses)"), CTF_PERCENT, CTFA_MRSETS) \ + S(CTSF_LAYERPCT_COUNT_RESPONSES, "LAYERPCT.COUNT.RESPONSES", N_("Layer Count % (Base: Responses)"), CTF_PERCENT, CTFA_MRSETS) \ + S(CTSF_LAYERROWPCT_COUNT_RESPONSES, "LAYERROWPCT.COUNT.RESPONSES", N_("Layer Row Count % (Base: Responses)"), CTF_PERCENT, CTFA_MRSETS) \ + S(CTSF_LAYERCOLPCT_COUNT_RESPONSES, "LAYERCOLPCT.RESPONSES.COUNT", N_("Layer Column Count % (Base: Responses)"), CTF_PERCENT, CTFA_MRSETS) +#endif + +enum ctables_summary_function + { +#define S(ENUM, NAME, LABEL, FORMAT, AVAILABILITY) ENUM, + SUMMARIES +#undef S + }; + +enum { +#define S(ENUM, NAME, LABEL, FORMAT, AVAILABILITY) +1 + N_CTSF_FUNCTIONS = SUMMARIES +#undef S +}; + +static bool ctables_summary_function_is_count (enum ctables_summary_function); + +enum ctables_domain_type + { + /* Within a section, where stacked variables divide one section from + another. */ + CTDT_TABLE, /* All layers of a whole section. */ + CTDT_LAYER, /* One layer within a section. */ + CTDT_LAYERROW, /* Row in one layer within a section. */ + CTDT_LAYERCOL, /* Column in one layer within a section. */ + + /* Within a subtable, where a subtable pairs an innermost row variable with + an innermost column variable within a single layer. */ + CTDT_SUBTABLE, /* Whole subtable. */ + CTDT_ROW, /* Row within a subtable. */ + CTDT_COL, /* Column within a subtable. */ +#define N_CTDTS 7 + }; + +struct ctables_domain + { + struct hmap_node node; + + const struct ctables_cell *example; + + double d_valid; /* Dictionary weight. */ + double d_count; + double d_total; + double e_valid; /* Effective weight */ + double e_count; + double e_total; + double u_valid; /* Unweighted. */ + double u_count; + double u_total; + struct ctables_sum *sums; + }; + +struct ctables_sum + { + double e_sum; + double u_sum; + }; + +enum ctables_summary_variant + { + CSV_CELL, + CSV_TOTAL +#define N_CSVS 2 + }; + +struct ctables_cell + { + /* 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. */ + uint32_t omit_domains; + struct ctables_domain *domains[N_CTDTS]; + + bool hide; + + bool postcompute; + enum ctables_summary_variant sv; + + struct ctables_cell_axis + { + struct ctables_cell_value + { + const struct ctables_category *category; + union value value; + } + *cvs; + int leaf; + } + axes[PIVOT_N_AXES]; + + union ctables_summary *summaries; + + //char *name; + }; + +struct ctables + { + const struct dictionary *dict; + struct pivot_table_look *look; + + /* CTABLES has a number of extra formats that we implement via custom + currency specifications on an alternate fmt_settings. */ +#define CTEF_NEGPAREN FMT_CCA +#define CTEF_NEQUAL FMT_CCB +#define CTEF_PAREN FMT_CCC +#define CTEF_PCTPAREN FMT_CCD + struct fmt_settings ctables_formats; + + /* If this is NULL, zeros are displayed using the normal print format. + Otherwise, this string is displayed. */ + char *zero; + + /* If this is NULL, missing values are displayed using the normal print + format. Otherwise, this string is displayed. */ + char *missing; + + /* Indexed by variable dictionary index. */ + enum ctables_vlabel *vlabels; + + struct hmap postcomputes; /* Contains "struct ctables_postcompute"s. */ + + bool mrsets_count_duplicates; /* MRSETS. */ + bool smissing_listwise; /* SMISSING. */ + struct variable *e_weight; /* WEIGHT. */ + 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. */ + char *name; /* Name, without leading &. */ + + struct msg_location *location; /* Location of definition. */ + struct ctables_pcexpr *expr; + char *label; + struct ctables_summary_spec_set *specs; + bool hide_source_cats; + }; + +struct ctables_pcexpr + { + /* Precedence table: + + () + ** + - + * / + - + + */ + enum ctables_postcompute_op + { + /* Terminals. */ + CTPO_CONSTANT, /* 5 */ + CTPO_CAT_NUMBER, /* [5] */ + CTPO_CAT_STRING, /* ["STRING"] */ + CTPO_CAT_NRANGE, /* [LO THRU 5] */ + CTPO_CAT_SRANGE, /* ["A" THRU "B"] */ + CTPO_CAT_MISSING, /* MISSING */ + CTPO_CAT_OTHERNM, /* OTHERNM */ + CTPO_CAT_SUBTOTAL, /* SUBTOTAL */ + CTPO_CAT_TOTAL, /* TOTAL */ + + /* Nonterminals. */ + CTPO_ADD, + CTPO_SUB, + CTPO_MUL, + CTPO_DIV, + CTPO_POW, + CTPO_NEG, + } + op; + + union + { + /* CTPO_CAT_NUMBER. */ + double number; + + /* CTPO_CAT_STRING, in dictionary encoding. */ + struct substring string; + + /* CTPO_CAT_NRANGE. */ + double nrange[2]; + + /* CTPO_CAT_SRANGE. */ + struct substring srange[2]; + + /* CTPO_CAT_SUBTOTAL. */ + size_t subtotal_index; + + /* Two elements: CTPO_ADD, CTPO_SUB, CTPO_MUL, CTPO_DIV, CTPO_POW. + One element: CTPO_NEG. */ + struct ctables_pcexpr *subs[2]; + }; + + /* Source location. */ + struct msg_location *location; + }; + +static void ctables_pcexpr_destroy (struct ctables_pcexpr *); +static struct ctables_pcexpr *ctables_pcexpr_allocate_binary ( + enum ctables_postcompute_op, struct ctables_pcexpr *sub0, + struct ctables_pcexpr *sub1); + +struct ctables_summary_spec_set + { + struct ctables_summary_spec *specs; + size_t n; + size_t allocated; + + /* The variable to which the summary specs are applied. */ + struct variable *var; + + /* Whether the variable to which the summary specs are applied is a scale + variable for the purpose of summarization. + + (VALIDN and TOTALN act differently for summarizing scale and categorical + variables.) */ + bool is_scale; + + /* If any of these optional additional scale variables are missing, then + treat 'var' as if it's missing too. This is for implementing + SMISSING=LISTWISE. */ + struct variable **listwise_vars; + size_t n_listwise_vars; + }; + +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. */ +struct ctables_nest + { + struct variable **vars; + size_t n; + size_t scale_idx; + size_t *domains[N_CTDTS]; + size_t n_domains[N_CTDTS]; + size_t group_head; + + struct ctables_summary_spec_set specs[N_CSVS]; + }; + +/* A stack of nestings, e.g. nest1 + nest2 + ... + nestN. */ +struct ctables_stack + { + struct ctables_nest *nests; + 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 ctables_summary_spec_set summary_specs; + struct variable **sum_vars; + size_t n_sum_vars; + + 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; + + /* 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; + size_t n_categories; + + double cilevel; + + char *caption; + char *corner; + char *title; + + struct ctables_chisq *chisq; + struct ctables_pairwise *pairwise; + }; + +struct ctables_categories + { + size_t n_refs; + struct ctables_category *cats; + size_t n_cats; + bool show_empty; + }; + +struct ctables_category + { + enum ctables_category_type + { + /* Explicit category lists. */ + CCT_NUMBER, + CCT_STRING, + CCT_NRANGE, /* Numerical range. */ + CCT_SRANGE, /* String range. */ + CCT_MISSING, + CCT_OTHERNM, + CCT_POSTCOMPUTE, + + /* Totals and subtotals. */ + CCT_SUBTOTAL, + CCT_TOTAL, + + /* Implicit category lists. */ + CCT_VALUE, + CCT_LABEL, + CCT_FUNCTION, + + /* For contributing to TOTALN. */ + CCT_EXCLUDED_MISSING, + } + type; + + struct ctables_category *subtotal; + + bool hide; + + union + { + double number; /* CCT_NUMBER. */ + struct substring string; /* CCT_STRING, in dictionary encoding. */ + double nrange[2]; /* CCT_NRANGE. */ + struct substring srange[2]; /* CCT_SRANGE. */ + + 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 + { + bool include_missing; + bool sort_ascending; + + /* CCT_FUNCTION. */ + enum ctables_summary_function sort_function; + struct variable *sort_var; + double percentile; + }; + }; + + /* Source location. This is null for CCT_TOTAL, CCT_VALUE, CCT_LABEL, + CCT_FUNCTION, CCT_EXCLUDED_MISSING. */ + struct msg_location *location; + }; + +static void +ctables_category_uninit (struct ctables_category *cat) +{ + if (!cat) + return; + + switch (cat->type) + { + case CCT_NUMBER: + case CCT_NRANGE: + case CCT_MISSING: + case CCT_OTHERNM: + case CCT_POSTCOMPUTE: + break; + + case CCT_STRING: + ss_dealloc (&cat->string); + break; + + case CCT_SRANGE: + ss_dealloc (&cat->srange[0]); + ss_dealloc (&cat->srange[1]); + break; + + case CCT_SUBTOTAL: + case CCT_TOTAL: + free (cat->total_label); + break; + + case CCT_VALUE: + case CCT_LABEL: + case CCT_FUNCTION: + break; + + case CCT_EXCLUDED_MISSING: + break; + } +} + +static bool +nullable_substring_equal (const struct substring *a, + const struct substring *b) +{ + return !a->string ? !b->string : b->string && ss_equals (*a, *b); +} + +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 ss_equals (a->string, b->string); + + case CCT_NRANGE: + return a->nrange[0] == b->nrange[0] && a->nrange[1] == b->nrange[1]; + + case CCT_SRANGE: + return (nullable_substring_equal (&a->srange[0], &b->srange[0]) + && nullable_substring_equal (&a->srange[1], &b->srange[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); + + case CCT_EXCLUDED_MISSING: + return true; + } + + NOT_REACHED (); +} + +static void +ctables_categories_unref (struct ctables_categories *c) +{ + if (!c) + return; + + assert (c->n_refs > 0); + if (--c->n_refs) + return; + + for (size_t i = 0; i < c->n_cats; i++) + ctables_category_uninit (&c->cats[i]); + free (c->cats); + 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 + { + double alpha; + bool include_mrsets; + bool all_visible; + }; + +/* Pairwise comparison test (COMPARETEST). */ +struct ctables_pairwise + { + enum { PROP, MEAN } type; + double alpha[2]; + bool include_mrsets; + bool meansvariance_allcats; + bool all_visible; + enum { BONFERRONI = 1, BH } adjust; + bool merge; + bool apa_style; + bool show_sig; + }; + +struct ctables_axis + { + enum ctables_axis_op + { + /* Terminals. */ + CTAO_VAR, + + /* Nonterminals. */ + CTAO_STACK, /* + */ + CTAO_NEST, /* > */ + } + op; + + union + { + /* Terminals. */ + struct + { + struct variable *var; + bool scale; + struct ctables_summary_spec_set specs[N_CSVS]; + }; + + /* Nonterminals. */ + struct ctables_axis *subs[2]; + }; + + struct msg_location *loc; + }; + +static void ctables_axis_destroy (struct ctables_axis *); + +enum ctables_format + { + CTF_COUNT, + CTF_PERCENT, + CTF_GENERAL + }; + +enum ctables_function_availability + { + CTFA_ALL, /* Any variables. */ + CTFA_SCALE, /* Only scale variables, totals, and subtotals. */ + CTFA_MRSETS, /* Only multiple-response sets */ + }; + +struct ctables_summary_spec + { + enum ctables_summary_function function; + double percentile; /* CTSF_PTILE only. */ + char *label; + + struct fmt_spec format; + bool is_ctables_format; /* Is 'format' one of CTEF_*? */ + + size_t axis_idx; + size_t sum_var_idx; + }; + +static void +ctables_summary_spec_clone (struct ctables_summary_spec *dst, + const struct ctables_summary_spec *src) +{ + *dst = *src; + dst->label = xstrdup_if_nonnull (src->label); +} + +static void +ctables_summary_spec_uninit (struct ctables_summary_spec *s) +{ + if (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, + .is_scale = src->is_scale, + }; +} + +static void +ctables_summary_spec_set_uninit (struct ctables_summary_spec_set *set) +{ + for (size_t i = 0; i < set->n; i++) + ctables_summary_spec_uninit (&set->specs[i]); + free (set->specs); +} + +static bool +parse_col_width (struct lexer *lexer, const char *name, double *width) +{ + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "DEFAULT")) + *width = SYSMIS; + else if (lex_force_num_range_closed (lexer, name, 0, DBL_MAX)) + { + *width = lex_number (lexer); + lex_get (lexer); + } + else + return false; + + return true; +} + +static bool +parse_bool (struct lexer *lexer, bool *b) +{ + if (lex_match_id (lexer, "NO")) + *b = false; + else if (lex_match_id (lexer, "YES")) + *b = true; + else + { + lex_error_expecting (lexer, "YES", "NO"); + return false; + } + return true; +} + +static enum ctables_function_availability +ctables_function_availability (enum ctables_summary_function f) +{ + static enum ctables_function_availability availability[] = { +#define S(ENUM, NAME, LABEL, FORMAT, AVAILABILITY) [ENUM] = AVAILABILITY, + SUMMARIES +#undef S + }; + + return availability[f]; +} + +static bool +ctables_summary_function_is_count (enum ctables_summary_function f) +{ + switch (f) + { + case CTSF_COUNT: + case CTSF_ECOUNT: + case CTSF_ROWPCT_COUNT: + case CTSF_COLPCT_COUNT: + case CTSF_TABLEPCT_COUNT: + case CTSF_SUBTABLEPCT_COUNT: + case CTSF_LAYERPCT_COUNT: + case CTSF_LAYERROWPCT_COUNT: + case CTSF_LAYERCOLPCT_COUNT: + case CTSF_UCOUNT: + case CTSF_UROWPCT_COUNT: + case CTSF_UCOLPCT_COUNT: + case CTSF_UTABLEPCT_COUNT: + case CTSF_USUBTABLEPCT_COUNT: + case CTSF_ULAYERPCT_COUNT: + case CTSF_ULAYERROWPCT_COUNT: + case CTSF_ULAYERCOLPCT_COUNT: + return true; + + case CTSF_ROWPCT_VALIDN: + case CTSF_COLPCT_VALIDN: + case CTSF_TABLEPCT_VALIDN: + case CTSF_SUBTABLEPCT_VALIDN: + case CTSF_LAYERPCT_VALIDN: + case CTSF_LAYERROWPCT_VALIDN: + case CTSF_LAYERCOLPCT_VALIDN: + case CTSF_ROWPCT_TOTALN: + case CTSF_COLPCT_TOTALN: + case CTSF_TABLEPCT_TOTALN: + case CTSF_SUBTABLEPCT_TOTALN: + case CTSF_LAYERPCT_TOTALN: + case CTSF_LAYERROWPCT_TOTALN: + case CTSF_LAYERCOLPCT_TOTALN: + case CTSF_MAXIMUM: + case CTSF_MEAN: + case CTSF_MEDIAN: + case CTSF_MINIMUM: + case CTSF_MISSING: + case CTSF_MODE: + case CTSF_PTILE: + case CTSF_RANGE: + case CTSF_SEMEAN: + case CTSF_STDDEV: + case CTSF_SUM: + case CSTF_TOTALN: + case CTSF_ETOTALN: + case CTSF_VALIDN: + case CTSF_EVALIDN: + case CTSF_VARIANCE: + case CTSF_ROWPCT_SUM: + case CTSF_COLPCT_SUM: + case CTSF_TABLEPCT_SUM: + case CTSF_SUBTABLEPCT_SUM: + case CTSF_LAYERPCT_SUM: + case CTSF_LAYERROWPCT_SUM: + case CTSF_LAYERCOLPCT_SUM: + case CTSF_UROWPCT_VALIDN: + case CTSF_UCOLPCT_VALIDN: + case CTSF_UTABLEPCT_VALIDN: + case CTSF_USUBTABLEPCT_VALIDN: + case CTSF_ULAYERPCT_VALIDN: + case CTSF_ULAYERROWPCT_VALIDN: + case CTSF_ULAYERCOLPCT_VALIDN: + case CTSF_UROWPCT_TOTALN: + case CTSF_UCOLPCT_TOTALN: + case CTSF_UTABLEPCT_TOTALN: + case CTSF_USUBTABLEPCT_TOTALN: + case CTSF_ULAYERPCT_TOTALN: + case CTSF_ULAYERROWPCT_TOTALN: + case CTSF_ULAYERCOLPCT_TOTALN: + case CTSF_UMEAN: + case CTSF_UMEDIAN: + case CTSF_UMISSING: + case CTSF_UMODE: + case CTSF_UPTILE: + case CTSF_USEMEAN: + case CTSF_USTDDEV: + case CTSF_USUM: + case CSTF_UTOTALN: + case CTSF_UVALIDN: + case CTSF_UVARIANCE: + case CTSF_UROWPCT_SUM: + case CTSF_UCOLPCT_SUM: + case CTSF_UTABLEPCT_SUM: + case CTSF_USUBTABLEPCT_SUM: + case CTSF_ULAYERPCT_SUM: + case CTSF_ULAYERROWPCT_SUM: + case CTSF_ULAYERCOLPCT_SUM: + return false; + } + NOT_REACHED (); +} + + +static bool +parse_ctables_summary_function (struct lexer *lexer, + enum ctables_summary_function *f) +{ + struct pair + { + enum ctables_summary_function function; + struct substring name; + }; + static struct pair names[] = { +#define S(ENUM, NAME, LABEL, FORMAT, AVAILABILITY) \ + { ENUM, SS_LITERAL_INITIALIZER (NAME) }, + SUMMARIES + + /* The .COUNT suffix may be omitted. */ + S(CTSF_ROWPCT_COUNT, "ROWPCT", _, _, _) + S(CTSF_COLPCT_COUNT, "COLPCT", _, _, _) + S(CTSF_TABLEPCT_COUNT, "TABLEPCT", _, _, _) + S(CTSF_SUBTABLEPCT_COUNT, "SUBTABLEPCT", _, _, _) + S(CTSF_LAYERPCT_COUNT, "LAYERPCT", _, _, _) + S(CTSF_LAYERROWPCT_COUNT, "LAYERROWPCT", _, _, _) + S(CTSF_LAYERCOLPCT_COUNT, "LAYERCOLPCT", _, _, _) +#undef S + }; + + if (!lex_force_id (lexer)) + return false; + + for (size_t i = 0; i < sizeof names / sizeof *names; i++) + if (ss_equals_case (names[i].name, lex_tokss (lexer))) + { + *f = names[i].function; + lex_get (lexer); + return true; + } + + lex_error (lexer, _("Expecting summary function name.")); + return false; +} + +static void +ctables_axis_destroy (struct ctables_axis *axis) +{ + if (!axis) + return; + + switch (axis->op) + { + case CTAO_VAR: + for (size_t i = 0; i < N_CSVS; i++) + ctables_summary_spec_set_uninit (&axis->specs[i]); + break; + + case CTAO_STACK: + case CTAO_NEST: + ctables_axis_destroy (axis->subs[0]); + ctables_axis_destroy (axis->subs[1]); + break; + } + msg_location_destroy (axis->loc); + free (axis); +} + +static struct ctables_axis * +ctables_axis_new_nonterminal (enum ctables_axis_op op, + struct ctables_axis *sub0, + struct ctables_axis *sub1, + struct lexer *lexer, int start_ofs) +{ + struct ctables_axis *axis = xmalloc (sizeof *axis); + *axis = (struct ctables_axis) { + .op = op, + .subs = { sub0, sub1 }, + .loc = lex_ofs_location (lexer, start_ofs, lex_ofs (lexer) - 1), + }; + return axis; +} + +struct ctables_axis_parse_ctx + { + struct lexer *lexer; + struct dictionary *dict; + struct ctables *ct; + struct ctables_table *t; + }; + +static struct fmt_spec +ctables_summary_default_format (enum ctables_summary_function function, + const struct variable *var) +{ + static const enum ctables_format default_formats[] = { +#define S(ENUM, NAME, LABEL, FORMAT, AVAILABILITY) [ENUM] = FORMAT, + SUMMARIES +#undef S + }; + switch (default_formats[function]) + { + case CTF_COUNT: + return (struct fmt_spec) { .type = FMT_F, .w = 40 }; + + case CTF_PERCENT: + return (struct fmt_spec) { .type = FMT_PCT, .w = 40, .d = 1 }; + + case CTF_GENERAL: + return *var_get_print_format (var); + + default: + NOT_REACHED (); + } +} + +static struct pivot_value * +ctables_summary_label (const struct ctables_summary_spec *spec, double cilevel) +{ + if (!spec->label) + { + static const char *default_labels[] = { +#define S(ENUM, NAME, LABEL, FORMAT, AVAILABILITY) [ENUM] = LABEL, + SUMMARIES +#undef S + }; + + return (spec->function == CTSF_PTILE + ? pivot_value_new_text_format (N_("Percentile %.2f"), + spec->percentile) + : pivot_value_new_text (default_labels[spec->function])); + } + else + { + struct substring in = ss_cstr (spec->label); + struct substring target = ss_cstr (")CILEVEL"); + + struct string out = DS_EMPTY_INITIALIZER; + for (;;) + { + size_t chunk = ss_find_substring (in, target); + ds_put_substring (&out, ss_head (in, chunk)); + ss_advance (&in, chunk); + if (!in.length) + return pivot_value_new_user_text_nocopy (ds_steal_cstr (&out)); + + ss_advance (&in, target.length); + ds_put_format (&out, "%g", cilevel); + } + } +} + +static const char * +ctables_summary_function_name (enum ctables_summary_function function) +{ + static const char *names[] = { +#define S(ENUM, NAME, LABEL, FORMAT, AVAILABILITY) [ENUM] = NAME, + SUMMARIES +#undef S + }; + return names[function]; +} + +static bool +add_summary_spec (struct ctables_axis *axis, + enum ctables_summary_function function, double percentile, + const char *label, const struct fmt_spec *format, + bool is_ctables_format, const struct msg_location *loc, + enum ctables_summary_variant sv) +{ + if (axis->op == CTAO_VAR) + { + const char *function_name = ctables_summary_function_name (function); + const char *var_name = var_get_name (axis->var); + switch (ctables_function_availability (function)) + { + case CTFA_MRSETS: + msg_at (SE, loc, _("Summary function %s applies only to multiple " + "response sets."), function_name); + msg_at (SN, axis->loc, _("'%s' is not a multiple response set."), + var_name); + return false; + + case CTFA_SCALE: +#if 0 + if (!axis->scale) + { + msg_at (SE, loc, + _("Summary function %s applies only to scale variables."), + function_name); + msg_at (SN, axis->loc, _("'%s' is not a scale variable."), + var_name); + return false; + } +#endif + break; + + case CTFA_ALL: + break; + } + + struct ctables_summary_spec_set *set = &axis->specs[sv]; + if (set->n >= set->allocated) + set->specs = x2nrealloc (set->specs, &set->allocated, + sizeof *set->specs); + + struct ctables_summary_spec *dst = &set->specs[set->n++]; + *dst = (struct ctables_summary_spec) { + .function = function, + .percentile = percentile, + .label = xstrdup_if_nonnull (label), + .format = (format ? *format + : ctables_summary_default_format (function, axis->var)), + .is_ctables_format = is_ctables_format, + }; + return true; + } + else + { + for (size_t i = 0; i < 2; i++) + if (!add_summary_spec (axis->subs[i], function, percentile, label, + format, is_ctables_format, loc, sv)) + return false; + return true; + } +} + +static struct ctables_axis *ctables_axis_parse_stack ( + struct ctables_axis_parse_ctx *); + + +static struct ctables_axis * +ctables_axis_parse_primary (struct ctables_axis_parse_ctx *ctx) +{ + if (lex_match (ctx->lexer, T_LPAREN)) + { + struct ctables_axis *sub = ctables_axis_parse_stack (ctx); + if (!sub || !lex_force_match (ctx->lexer, T_RPAREN)) + { + ctables_axis_destroy (sub); + return NULL; + } + return sub; + } + + if (!lex_force_id (ctx->lexer)) + return NULL; + + int start_ofs = lex_ofs (ctx->lexer); + struct variable *var = parse_variable (ctx->lexer, ctx->dict); + if (!var) + return NULL; + + struct ctables_axis *axis = xmalloc (sizeof *axis); + *axis = (struct ctables_axis) { .op = CTAO_VAR, .var = var }; + + /* XXX should figure out default measures by reading data */ + axis->scale = (lex_match_phrase (ctx->lexer, "[S]") ? true + : lex_match_phrase (ctx->lexer, "[C]") ? false + : var_get_measure (var) == MEASURE_SCALE); + axis->loc = lex_ofs_location (ctx->lexer, start_ofs, + lex_ofs (ctx->lexer) - 1); + if (axis->scale && var_is_alpha (var)) + { + msg_at (SE, axis->loc, _("Cannot use string variable %s as a scale " + "variable."), + var_get_name (var)); + ctables_axis_destroy (axis); + return NULL; + } + + return axis; +} + +static bool +has_digit (const char *s) +{ + return s[strcspn (s, "0123456789")] != '\0'; +} + +static bool +parse_ctables_format_specifier (struct lexer *lexer, struct fmt_spec *format, + bool *is_ctables_format) +{ + char type[FMT_TYPE_LEN_MAX + 1]; + if (!parse_abstract_format_specifier__ (lexer, type, &format->w, &format->d)) + return false; + + if (!strcasecmp (type, "NEGPAREN")) + format->type = CTEF_NEGPAREN; + else if (!strcasecmp (type, "NEQUAL")) + format->type = CTEF_NEQUAL; + else if (!strcasecmp (type, "PAREN")) + format->type = CTEF_PAREN; + else if (!strcasecmp (type, "PCTPAREN")) + format->type = CTEF_PCTPAREN; + else + { + *is_ctables_format = false; + return (parse_format_specifier (lexer, format) + && fmt_check_output (format) + && fmt_check_type_compat (format, VAL_NUMERIC)); + } + + if (format->w < 2) + { + msg (SE, _("Output format %s requires width 2 or greater."), type); + return false; + } + else if (format->d > format->w - 1) + { + msg (SE, _("Output format %s requires width greater than decimals."), + type); + return false; + } + else + { + *is_ctables_format = true; + return true; + } +} + +static struct ctables_axis * +ctables_axis_parse_postfix (struct ctables_axis_parse_ctx *ctx) +{ + struct ctables_axis *sub = ctables_axis_parse_primary (ctx); + if (!sub || !lex_match (ctx->lexer, T_LBRACK)) + return sub; + + enum ctables_summary_variant sv = CSV_CELL; + for (;;) + { + int start_ofs = lex_ofs (ctx->lexer); + + /* Parse function. */ + enum ctables_summary_function function; + if (!parse_ctables_summary_function (ctx->lexer, &function)) + goto error; + + /* Parse percentile. */ + double percentile = 0; + if (function == CTSF_PTILE) + { + if (!lex_force_num_range_closed (ctx->lexer, "PTILE", 0, 100)) + goto error; + percentile = lex_number (ctx->lexer); + lex_get (ctx->lexer); + } + + /* Parse label. */ + char *label = NULL; + if (lex_is_string (ctx->lexer)) + { + label = ss_xstrdup (lex_tokss (ctx->lexer)); + lex_get (ctx->lexer); + } + + /* Parse format. */ + struct fmt_spec format; + const struct fmt_spec *formatp; + bool is_ctables_format = false; + if (lex_token (ctx->lexer) == T_ID + && has_digit (lex_tokcstr (ctx->lexer))) + { + if (!parse_ctables_format_specifier (ctx->lexer, &format, + &is_ctables_format)) + { + free (label); + goto error; + } + formatp = &format; + } + else + formatp = NULL; + + struct msg_location *loc = lex_ofs_location (ctx->lexer, start_ofs, + lex_ofs (ctx->lexer) - 1); + add_summary_spec (sub, function, percentile, label, formatp, + is_ctables_format, loc, sv); + free (label); + msg_location_destroy (loc); + + lex_match (ctx->lexer, T_COMMA); + if (sv == CSV_CELL && lex_match_id (ctx->lexer, "TOTALS")) + { + if (!lex_force_match (ctx->lexer, T_LBRACK)) + goto error; + sv = CSV_TOTAL; + } + else if (lex_match (ctx->lexer, T_RBRACK)) + { + if (sv == CSV_TOTAL && !lex_force_match (ctx->lexer, T_RBRACK)) + goto error; + return sub; + } + } + +error: + ctables_axis_destroy (sub); + return NULL; +} + +static const struct ctables_axis * +find_scale (const struct ctables_axis *axis) +{ + if (!axis) + return NULL; + else if (axis->op == CTAO_VAR) + return axis->scale ? axis : NULL; + else + { + for (size_t i = 0; i < 2; i++) + { + const struct ctables_axis *scale = find_scale (axis->subs[i]); + if (scale) + return scale; + } + return NULL; + } +} + +static const struct ctables_axis * +find_categorical_summary_spec (const struct ctables_axis *axis) +{ + if (!axis) + return NULL; + else if (axis->op == CTAO_VAR) + return !axis->scale && axis->specs[CSV_CELL].n ? axis : NULL; + else + { + for (size_t i = 0; i < 2; i++) + { + const struct ctables_axis *sum + = find_categorical_summary_spec (axis->subs[i]); + if (sum) + return sum; + } + return NULL; + } +} + +static struct ctables_axis * +ctables_axis_parse_nest (struct ctables_axis_parse_ctx *ctx) +{ + int start_ofs = lex_ofs (ctx->lexer); + struct ctables_axis *lhs = ctables_axis_parse_postfix (ctx); + if (!lhs) + return NULL; + + while (lex_match (ctx->lexer, T_GT)) + { + struct ctables_axis *rhs = ctables_axis_parse_postfix (ctx); + if (!rhs) + return NULL; + + struct ctables_axis *nest = ctables_axis_new_nonterminal ( + CTAO_NEST, lhs, rhs, ctx->lexer, start_ofs); + + const struct ctables_axis *outer_scale = find_scale (lhs); + const struct ctables_axis *inner_scale = find_scale (rhs); + if (outer_scale && inner_scale) + { + msg_at (SE, nest->loc, _("Cannot nest scale variables.")); + msg_at (SN, outer_scale->loc, _("This is an outer scale variable.")); + msg_at (SN, inner_scale->loc, _("This is an inner scale variable.")); + ctables_axis_destroy (nest); + return NULL; + } + + const struct ctables_axis *outer_sum = find_categorical_summary_spec (lhs); + if (outer_sum) + { + msg_at (SE, nest->loc, + _("Summaries may only be requested for categorical variables " + "at the innermost nesting level.")); + msg_at (SN, outer_sum->loc, + _("This outer categorical variable has a summary.")); + ctables_axis_destroy (nest); + return NULL; + } + + lhs = nest; + } + + return lhs; +} + +static struct ctables_axis * +ctables_axis_parse_stack (struct ctables_axis_parse_ctx *ctx) +{ + int start_ofs = lex_ofs (ctx->lexer); + struct ctables_axis *lhs = ctables_axis_parse_nest (ctx); + if (!lhs) + return NULL; + + while (lex_match (ctx->lexer, T_PLUS)) + { + struct ctables_axis *rhs = ctables_axis_parse_nest (ctx); + if (!rhs) + return NULL; + + lhs = ctables_axis_new_nonterminal (CTAO_STACK, lhs, rhs, + ctx->lexer, start_ofs); + } + + return lhs; +} + +static bool +ctables_axis_parse (struct lexer *lexer, struct dictionary *dict, + struct ctables *ct, struct ctables_table *t, + enum pivot_axis_type a) +{ + if (lex_token (lexer) == T_BY + || lex_token (lexer) == T_SLASH + || lex_token (lexer) == T_ENDCMD) + return true; + + struct ctables_axis_parse_ctx ctx = { + .lexer = lexer, + .dict = dict, + .ct = ct, + .t = t + }; + t->axes[a] = ctables_axis_parse_stack (&ctx); + return t->axes[a] != NULL; +} + +static void +ctables_chisq_destroy (struct ctables_chisq *chisq) +{ + free (chisq); +} + +static void +ctables_pairwise_destroy (struct ctables_pairwise *pairwise) +{ + free (pairwise); +} + +static void +ctables_table_destroy (struct ctables_table *t) +{ + if (!t) + return; + + for (size_t i = 0; i < t->n_categories; i++) + ctables_categories_unref (t->categories[i]); + free (t->categories); + + ctables_axis_destroy (t->axes[PIVOT_AXIS_COLUMN]); + ctables_axis_destroy (t->axes[PIVOT_AXIS_ROW]); + ctables_axis_destroy (t->axes[PIVOT_AXIS_LAYER]); + free (t->caption); + free (t->corner); + free (t->title); + ctables_chisq_destroy (t->chisq); + ctables_pairwise_destroy (t->pairwise); + free (t); +} + +static void +ctables_destroy (struct ctables *ct) +{ + if (!ct) + return; + + pivot_table_look_unref (ct->look); + free (ct->zero); + free (ct->missing); + free (ct->vlabels); + for (size_t i = 0; i < ct->n_tables; i++) + ctables_table_destroy (ct->tables[i]); + free (ct->tables); + free (ct); +} + +static struct ctables_category +cct_nrange (double low, double high) +{ + return (struct ctables_category) { + .type = CCT_NRANGE, + .nrange = { low, high } + }; +} + +static struct ctables_category +cct_srange (struct substring low, struct substring high) +{ + return (struct ctables_category) { + .type = CCT_SRANGE, + .srange = { low, 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 struct substring +parse_substring (struct lexer *lexer, struct dictionary *dict) +{ + struct substring s = recode_substring_pool ( + dict_get_encoding (dict), "UTF-8", lex_tokss (lexer), NULL); + ss_rtrim (&s, ss_cstr (" ")); + lex_get (lexer); + return s; +} + +static bool +ctables_table_parse_explicit_category (struct lexer *lexer, + struct dictionary *dict, + 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")) + return false; + if (lex_is_string (lexer)) + { + struct substring sr0 = { .string = NULL }; + struct substring sr1 = parse_substring (lexer, dict); + *cat = cct_srange (sr0, sr1); + } + else if (lex_force_num (lexer)) + { + *cat = cct_nrange (-DBL_MAX, lex_number (lexer)); + lex_get (lexer); + } + else + return false; + } + 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_nrange (number, DBL_MAX); + else + { + if (!lex_force_num (lexer)) + return false; + *cat = cct_nrange (number, lex_number (lexer)); + lex_get (lexer); + } + } + else + *cat = (struct ctables_category) { + .type = CCT_NUMBER, + .number = number + }; + } + else if (lex_is_string (lexer)) + { + struct substring s = parse_substring (lexer, dict); + if (lex_match_id (lexer, "THRU")) + { + if (lex_match_id (lexer, "HI")) + { + struct substring sr1 = { .string = NULL }; + *cat = cct_srange (s, sr1); + } + else + { + if (!lex_force_string (lexer)) + return false; + struct substring sr1 = parse_substring (lexer, dict); + *cat = cct_srange (s, sr1); + } + } + else + *cat = (struct ctables_category) { .type = CCT_STRING, .string = s }; + } + 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 && ss_equals (cat->string, e->string)) + best = cat; + break; + + case CTPO_CAT_NRANGE: + if (cat->type == CCT_NRANGE + && cat->nrange[0] == e->nrange[0] + && cat->nrange[1] == e->nrange[1]) + best = cat; + break; + + case CTPO_CAT_SRANGE: + if (cat->type == CCT_SRANGE + && nullable_substring_equal (&cat->srange[0], &e->srange[0]) + && nullable_substring_equal (&cat->srange[1], &e->srange[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_NRANGE: + 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 +parse_category_string (const struct ctables_category *cat, + struct substring s, struct dictionary *dict, + enum fmt_type format, double *n) +{ + union value v; + char *error = data_in (s, dict_get_encoding (dict), format, + settings_get_fmt_settings (), &v, 0, NULL); + if (error) + { + msg_at (SE, cat->location, + _("Failed to parse category specification as format %s: %s."), + fmt_name (format), error); + free (error); + return false; + } + + *n = v.f; + return true; +} + +static bool +all_strings (struct variable **vars, size_t n_vars, + const struct ctables_category *cat) +{ + for (size_t j = 0; j < n_vars; j++) + if (var_is_numeric (vars[j])) + { + msg_at (SE, cat->location, + _("This category specification may be applied only to string " + "variables, but this subcommand tries to apply it to " + "numeric variable %s."), + var_get_name (vars[j])); + return false; + } + return true; +} + +static bool +ctables_table_parse_categories (struct lexer *lexer, struct dictionary *dict, + struct ctables *ct, struct ctables_table *t) +{ + if (!lex_match_id (lexer, "VARIABLES")) + return false; + lex_match (lexer, T_EQUALS); + + struct variable **vars; + size_t n_vars; + if (!parse_variables (lexer, dict, &vars, &n_vars, PV_NO_SCRATCH)) + return false; + + const struct fmt_spec *common_format = var_get_print_format (vars[0]); + for (size_t i = 1; i < n_vars; i++) + { + const struct fmt_spec *f = var_get_print_format (vars[i]); + if (f->type != common_format->type) + { + common_format = NULL; + break; + } + } + bool parse_strings + = (common_format + && (fmt_get_category (common_format->type) + & (FMT_CAT_DATE | FMT_CAT_TIME | FMT_CAT_DATE_COMPONENT))); + + struct ctables_categories *c = xmalloc (sizeof *c); + *c = (struct ctables_categories) { .n_refs = n_vars, .show_empty = true }; + for (size_t i = 0; i < n_vars; i++) + { + struct ctables_categories **cp + = &t->categories[var_get_dict_index (vars[i])]; + ctables_categories_unref (*cp); + *cp = c; + } + + 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 (!ctables_table_parse_explicit_category (lexer, dict, 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]; + switch (cat->type) + { + case CCT_POSTCOMPUTE: + if (!ctables_recursive_check_postcompute (cat->pc->expr, cat, + c, cats_location)) + return false; + break; + + case CCT_NUMBER: + case CCT_NRANGE: + for (size_t j = 0; j < n_vars; j++) + if (var_is_alpha (vars[j])) + { + msg_at (SE, cat->location, + _("This category specification may be applied " + "only to numeric variables, but this " + "subcommand tries to apply it to string " + "variable %s."), + var_get_name (vars[j])); + return false; + } + break; + + case CCT_STRING: + if (parse_strings) + { + double n; + if (!parse_category_string (cat, cat->string, dict, + common_format->type, &n)) + return false; + + ss_dealloc (&cat->string); + + cat->type = CCT_NUMBER; + cat->number = n; + } + else if (!all_strings (vars, n_vars, cat)) + return false; + break; + + case CCT_SRANGE: + if (parse_strings) + { + double n[2]; + + if (!cat->srange[0].string) + n[0] = -DBL_MAX; + else if (!parse_category_string (cat, cat->srange[0], dict, + common_format->type, &n[0])) + return false; + + if (!cat->srange[1].string) + n[1] = DBL_MAX; + else if (!parse_category_string (cat, cat->srange[1], dict, + common_format->type, &n[1])) + return false; + + ss_dealloc (&cat->srange[0]); + ss_dealloc (&cat->srange[1]); + + cat->type = CCT_NRANGE; + cat->nrange[0] = n[0]; + cat->nrange[1] = n[1]; + } + else if (!all_strings (vars, n_vars, cat)) + return false; + break; + + case CCT_MISSING: + case CCT_OTHERNM: + case CCT_SUBTOTAL: + case CCT_TOTAL: + case CCT_VALUE: + case CCT_LABEL: + case CCT_FUNCTION: + case CCT_EXCLUDED_MISSING: + break; + } + } + } + + struct ctables_category cat = { + .type = CCT_VALUE, + .include_missing = false, + .sort_ascending = true, + }; + bool show_totals = false; + char *total_label = NULL; + bool totals_before = false; + while (lex_token (lexer) != T_SLASH && lex_token (lexer) != T_ENDCMD) + { + if (!c->n_cats && lex_match_id (lexer, "ORDER")) + { + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "A")) + cat.sort_ascending = true; + else if (lex_match_id (lexer, "D")) + cat.sort_ascending = false; + else + { + lex_error_expecting (lexer, "A", "D"); + return false; + } + } + else if (!c->n_cats && lex_match_id (lexer, "KEY")) + { + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "VALUE")) + cat.type = CCT_VALUE; + else if (lex_match_id (lexer, "LABEL")) + cat.type = CCT_LABEL; + else + { + cat.type = CCT_FUNCTION; + if (!parse_ctables_summary_function (lexer, &cat.sort_function)) + return false; + + if (lex_match (lexer, T_LPAREN)) + { + cat.sort_var = parse_variable (lexer, dict); + if (!cat.sort_var) + return false; + + if (cat.sort_function == CTSF_PTILE) + { + lex_match (lexer, T_COMMA); + if (!lex_force_num_range_closed (lexer, "PTILE", 0, 100)) + return false; + cat.percentile = lex_number (lexer); + lex_get (lexer); + } + + if (!lex_force_match (lexer, T_RPAREN)) + return false; + } + else if (ctables_function_availability (cat.sort_function) + == CTFA_SCALE) + { + bool UNUSED b = lex_force_match (lexer, T_LPAREN); + return false; + } + } + } + else if (!c->n_cats && lex_match_id (lexer, "MISSING")) + { + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "INCLUDE")) + cat.include_missing = true; + else if (lex_match_id (lexer, "EXCLUDE")) + cat.include_missing = false; + else + { + lex_error_expecting (lexer, "INCLUDE", "EXCLUDE"); + return false; + } + } + else if (lex_match_id (lexer, "TOTAL")) + { + lex_match (lexer, T_EQUALS); + if (!parse_bool (lexer, &show_totals)) + return false; + } + else if (lex_match_id (lexer, "LABEL")) + { + lex_match (lexer, T_EQUALS); + if (!lex_force_string (lexer)) + return false; + free (total_label); + total_label = ss_xstrdup (lex_tokss (lexer)); + lex_get (lexer); + } + else if (lex_match_id (lexer, "POSITION")) + { + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "BEFORE")) + totals_before = true; + else if (lex_match_id (lexer, "AFTER")) + totals_before = false; + else + { + lex_error_expecting (lexer, "BEFORE", "AFTER"); + return false; + } + } + else if (lex_match_id (lexer, "EMPTY")) + { + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "INCLUDE")) + c->show_empty = true; + else if (lex_match_id (lexer, "EXCLUDE")) + c->show_empty = false; + else + { + lex_error_expecting (lexer, "INCLUDE", "EXCLUDE"); + return false; + } + } + else + { + if (!c->n_cats) + lex_error_expecting (lexer, "ORDER", "KEY", "MISSING", + "TOTAL", "LABEL", "POSITION", "EMPTY"); + else + lex_error_expecting (lexer, "TOTAL", "LABEL", "POSITION", "EMPTY"); + return false; + } + } + + if (!c->n_cats) + { + if (c->n_cats >= allocated_cats) + c->cats = x2nrealloc (c->cats, &allocated_cats, sizeof *c->cats); + c->cats[c->n_cats++] = cat; + } + + if (show_totals) + { + if (c->n_cats >= allocated_cats) + c->cats = x2nrealloc (c->cats, &allocated_cats, sizeof *c->cats); + + struct ctables_category *totals; + if (totals_before) + { + insert_element (c->cats, c->n_cats, sizeof *c->cats, 0); + totals = &c->cats[0]; + } + else + totals = &c->cats[c->n_cats]; + c->n_cats++; + + *totals = (struct ctables_category) { + .type = CCT_TOTAL, + .total_label = total_label ? total_label : xstrdup (_("Total")), + }; + } + + struct ctables_category *subtotal = NULL; + for (size_t i = totals_before ? 0 : c->n_cats; + totals_before ? i < c->n_cats : i-- > 0; + totals_before ? i++ : 0) + { + struct ctables_category *cat = &c->cats[i]; + switch (cat->type) + { + case CCT_NUMBER: + case CCT_STRING: + case CCT_NRANGE: + case CCT_SRANGE: + case CCT_MISSING: + case CCT_OTHERNM: + cat->subtotal = subtotal; + break; + + case CCT_POSTCOMPUTE: + break; + + case CCT_SUBTOTAL: + subtotal = cat; + break; + + case CCT_TOTAL: + case CCT_VALUE: + case CCT_LABEL: + case CCT_FUNCTION: + case CCT_EXCLUDED_MISSING: + break; + } + } + + return true; +} + +static void +ctables_nest_uninit (struct ctables_nest *nest) +{ + if (nest) + free (nest->vars); +} + +static void +ctables_stack_uninit (struct ctables_stack *stack) +{ + if (stack) + { + for (size_t i = 0; i < stack->n; i++) + ctables_nest_uninit (&stack->nests[i]); + free (stack->nests); + } +} + +static struct ctables_stack +nest_fts (struct ctables_stack s0, struct ctables_stack s1) +{ + if (!s0.n) + return s1; + else if (!s1.n) + return s0; + + struct ctables_stack stack = { .nests = xnmalloc (s0.n, s1.n * sizeof *stack.nests) }; + for (size_t i = 0; i < s0.n; i++) + for (size_t j = 0; j < s1.n; j++) + { + const struct ctables_nest *a = &s0.nests[i]; + const struct ctables_nest *b = &s1.nests[j]; + + size_t allocate = a->n + b->n; + struct variable **vars = xnmalloc (allocate, sizeof *vars); + enum pivot_axis_type *axes = xnmalloc (allocate, sizeof *axes); + size_t n = 0; + for (size_t k = 0; k < a->n; k++) + vars[n++] = a->vars[k]; + for (size_t k = 0; k < b->n; k++) + vars[n++] = b->vars[k]; + assert (n == allocate); + + const struct ctables_nest *summary_src; + if (!a->specs[CSV_CELL].var) + summary_src = b; + else if (!b->specs[CSV_CELL].var) + summary_src = a; + else + NOT_REACHED (); + + 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, + }; + 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); + return stack; +} + +static struct ctables_stack +stack_fts (struct ctables_stack s0, struct ctables_stack s1) +{ + struct ctables_stack stack = { .nests = xnmalloc (s0.n + s1.n, sizeof *stack.nests) }; + for (size_t i = 0; i < s0.n; i++) + stack.nests[stack.n++] = s0.nests[i]; + for (size_t i = 0; i < s1.n; i++) + { + stack.nests[stack.n] = s1.nests[i]; + stack.nests[stack.n].group_head += s0.n; + stack.n++; + } + assert (stack.n == s0.n + s1.n); + free (s0.nests); + free (s1.nests); + return stack; +} + +static struct ctables_stack +var_fts (const struct ctables_axis *a) +{ + struct variable **vars = xmalloc (sizeof *vars); + *vars = a->var; + + struct ctables_nest *nest = xmalloc (sizeof *nest); + *nest = (struct ctables_nest) { + .vars = vars, + .n = 1, + .scale_idx = a->scale ? 0 : SIZE_MAX, + }; + if (a->specs[CSV_CELL].n || a->scale) + for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++) + { + ctables_summary_spec_set_clone (&nest->specs[sv], &a->specs[sv]); + nest->specs[sv].var = a->var; + nest->specs[sv].is_scale = a->scale; + } + return (struct ctables_stack) { .nests = nest, .n = 1 }; +} + +static struct ctables_stack +enumerate_fts (enum pivot_axis_type axis_type, const struct ctables_axis *a) +{ + if (!a) + return (struct ctables_stack) { .n = 0 }; + + switch (a->op) + { + case CTAO_VAR: + return var_fts (a); + + case CTAO_STACK: + return stack_fts (enumerate_fts (axis_type, a->subs[0]), + enumerate_fts (axis_type, a->subs[1])); + + case CTAO_NEST: + /* This should consider any of the scale variables found in the result to + be linked to each other listwise for SMISSING=LISTWISE. */ + return nest_fts (enumerate_fts (axis_type, a->subs[0]), + enumerate_fts (axis_type, a->subs[1])); + } + + NOT_REACHED (); +} + +union ctables_summary + { + /* COUNT, VALIDN, TOTALN. */ + double count; + + /* MINIMUM, MAXIMUM, RANGE. */ + struct + { + double min; + double max; + }; + + /* MEAN, SEMEAN, STDDEV, SUM, VARIANCE, *.SUM. */ + struct moments1 *moments; + + /* MEDIAN, MODE, PTILE. */ + struct + { + struct casewriter *writer; + double ovalid; + double ovalue; + }; + + /* XXX multiple response */ + }; + +static void +ctables_summary_init (union ctables_summary *s, + const struct ctables_summary_spec *ss) +{ + switch (ss->function) + { + case CTSF_COUNT: + case CTSF_ECOUNT: + case CTSF_ROWPCT_COUNT: + case CTSF_COLPCT_COUNT: + case CTSF_TABLEPCT_COUNT: + case CTSF_SUBTABLEPCT_COUNT: + case CTSF_LAYERPCT_COUNT: + case CTSF_LAYERROWPCT_COUNT: + case CTSF_LAYERCOLPCT_COUNT: + case CTSF_ROWPCT_VALIDN: + case CTSF_COLPCT_VALIDN: + case CTSF_TABLEPCT_VALIDN: + case CTSF_SUBTABLEPCT_VALIDN: + case CTSF_LAYERPCT_VALIDN: + case CTSF_LAYERROWPCT_VALIDN: + case CTSF_LAYERCOLPCT_VALIDN: + case CTSF_ROWPCT_TOTALN: + case CTSF_COLPCT_TOTALN: + case CTSF_TABLEPCT_TOTALN: + case CTSF_SUBTABLEPCT_TOTALN: + case CTSF_LAYERPCT_TOTALN: + case CTSF_LAYERROWPCT_TOTALN: + case CTSF_LAYERCOLPCT_TOTALN: + case CTSF_MISSING: + case CSTF_TOTALN: + case CTSF_ETOTALN: + case CTSF_VALIDN: + case CTSF_EVALIDN: + case CTSF_UCOUNT: + case CTSF_UROWPCT_COUNT: + case CTSF_UCOLPCT_COUNT: + case CTSF_UTABLEPCT_COUNT: + case CTSF_USUBTABLEPCT_COUNT: + case CTSF_ULAYERPCT_COUNT: + case CTSF_ULAYERROWPCT_COUNT: + case CTSF_ULAYERCOLPCT_COUNT: + case CTSF_UROWPCT_VALIDN: + case CTSF_UCOLPCT_VALIDN: + case CTSF_UTABLEPCT_VALIDN: + case CTSF_USUBTABLEPCT_VALIDN: + case CTSF_ULAYERPCT_VALIDN: + case CTSF_ULAYERROWPCT_VALIDN: + case CTSF_ULAYERCOLPCT_VALIDN: + case CTSF_UROWPCT_TOTALN: + case CTSF_UCOLPCT_TOTALN: + case CTSF_UTABLEPCT_TOTALN: + case CTSF_USUBTABLEPCT_TOTALN: + case CTSF_ULAYERPCT_TOTALN: + case CTSF_ULAYERROWPCT_TOTALN: + case CTSF_ULAYERCOLPCT_TOTALN: + case CTSF_UMISSING: + case CSTF_UTOTALN: + case CTSF_UVALIDN: + s->count = 0; + break; + + case CTSF_MAXIMUM: + case CTSF_MINIMUM: + case CTSF_RANGE: + s->min = s->max = SYSMIS; + break; + + case CTSF_MEAN: + case CTSF_SEMEAN: + case CTSF_STDDEV: + case CTSF_SUM: + case CTSF_VARIANCE: + case CTSF_ROWPCT_SUM: + case CTSF_COLPCT_SUM: + case CTSF_TABLEPCT_SUM: + case CTSF_SUBTABLEPCT_SUM: + case CTSF_LAYERPCT_SUM: + case CTSF_LAYERROWPCT_SUM: + case CTSF_LAYERCOLPCT_SUM: + case CTSF_UMEAN: + case CTSF_USEMEAN: + case CTSF_USTDDEV: + case CTSF_USUM: + case CTSF_UVARIANCE: + case CTSF_UROWPCT_SUM: + case CTSF_UCOLPCT_SUM: + case CTSF_UTABLEPCT_SUM: + case CTSF_USUBTABLEPCT_SUM: + case CTSF_ULAYERPCT_SUM: + case CTSF_ULAYERROWPCT_SUM: + case CTSF_ULAYERCOLPCT_SUM: + s->moments = moments1_create (MOMENT_VARIANCE); + break; + + case CTSF_MEDIAN: + case CTSF_MODE: + case CTSF_PTILE: + case CTSF_UMEDIAN: + case CTSF_UMODE: + case CTSF_UPTILE: + { + 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; + } +} + +static void UNUSED +ctables_summary_uninit (union ctables_summary *s, + const struct ctables_summary_spec *ss) +{ + switch (ss->function) + { + case CTSF_COUNT: + case CTSF_ECOUNT: + case CTSF_ROWPCT_COUNT: + case CTSF_COLPCT_COUNT: + case CTSF_TABLEPCT_COUNT: + case CTSF_SUBTABLEPCT_COUNT: + case CTSF_LAYERPCT_COUNT: + case CTSF_LAYERROWPCT_COUNT: + case CTSF_LAYERCOLPCT_COUNT: + case CTSF_ROWPCT_VALIDN: + case CTSF_COLPCT_VALIDN: + case CTSF_TABLEPCT_VALIDN: + case CTSF_SUBTABLEPCT_VALIDN: + case CTSF_LAYERPCT_VALIDN: + case CTSF_LAYERROWPCT_VALIDN: + case CTSF_LAYERCOLPCT_VALIDN: + case CTSF_ROWPCT_TOTALN: + case CTSF_COLPCT_TOTALN: + case CTSF_TABLEPCT_TOTALN: + case CTSF_SUBTABLEPCT_TOTALN: + case CTSF_LAYERPCT_TOTALN: + case CTSF_LAYERROWPCT_TOTALN: + case CTSF_LAYERCOLPCT_TOTALN: + case CTSF_MISSING: + case CSTF_TOTALN: + case CTSF_ETOTALN: + case CTSF_VALIDN: + case CTSF_EVALIDN: + case CTSF_UCOUNT: + case CTSF_UROWPCT_COUNT: + case CTSF_UCOLPCT_COUNT: + case CTSF_UTABLEPCT_COUNT: + case CTSF_USUBTABLEPCT_COUNT: + case CTSF_ULAYERPCT_COUNT: + case CTSF_ULAYERROWPCT_COUNT: + case CTSF_ULAYERCOLPCT_COUNT: + case CTSF_UROWPCT_VALIDN: + case CTSF_UCOLPCT_VALIDN: + case CTSF_UTABLEPCT_VALIDN: + case CTSF_USUBTABLEPCT_VALIDN: + case CTSF_ULAYERPCT_VALIDN: + case CTSF_ULAYERROWPCT_VALIDN: + case CTSF_ULAYERCOLPCT_VALIDN: + case CTSF_UROWPCT_TOTALN: + case CTSF_UCOLPCT_TOTALN: + case CTSF_UTABLEPCT_TOTALN: + case CTSF_USUBTABLEPCT_TOTALN: + case CTSF_ULAYERPCT_TOTALN: + case CTSF_ULAYERROWPCT_TOTALN: + case CTSF_ULAYERCOLPCT_TOTALN: + case CTSF_UMISSING: + case CSTF_UTOTALN: + case CTSF_UVALIDN: + break; + + case CTSF_MAXIMUM: + case CTSF_MINIMUM: + case CTSF_RANGE: + break; + + case CTSF_MEAN: + case CTSF_SEMEAN: + case CTSF_STDDEV: + case CTSF_SUM: + case CTSF_VARIANCE: + case CTSF_ROWPCT_SUM: + case CTSF_COLPCT_SUM: + case CTSF_TABLEPCT_SUM: + case CTSF_SUBTABLEPCT_SUM: + case CTSF_LAYERPCT_SUM: + case CTSF_LAYERROWPCT_SUM: + case CTSF_LAYERCOLPCT_SUM: + case CTSF_UMEAN: + case CTSF_USEMEAN: + case CTSF_USTDDEV: + case CTSF_USUM: + case CTSF_UVARIANCE: + case CTSF_UROWPCT_SUM: + case CTSF_UCOLPCT_SUM: + case CTSF_UTABLEPCT_SUM: + case CTSF_USUBTABLEPCT_SUM: + case CTSF_ULAYERPCT_SUM: + case CTSF_ULAYERROWPCT_SUM: + case CTSF_ULAYERCOLPCT_SUM: + moments1_destroy (s->moments); + break; + + case CTSF_MEDIAN: + case CTSF_MODE: + case CTSF_PTILE: + case CTSF_UMEDIAN: + case CTSF_UMODE: + case CTSF_UPTILE: + casewriter_destroy (s->writer); + break; + } +} + +static void +ctables_summary_add (union ctables_summary *s, + const struct ctables_summary_spec *ss, + const struct variable *var, const union value *value, + bool is_scale, bool is_scale_missing, + bool is_missing, bool excluded_missing, + double d_weight, double e_weight) +{ + /* To determine whether a case is included in a given table for a particular + kind of summary, consider the following charts for each variable in the + table. Only if "yes" appears for every variable for the summary is the + case counted. + + Categorical variables: VALIDN COUNT TOTALN + Valid values in included categories yes yes yes + Missing values in included categories --- yes yes + Missing values in excluded categories --- --- yes + Valid values in excluded categories --- --- --- + + Scale variables: VALIDN COUNT TOTALN + Valid value yes yes yes + Missing value --- yes yes + + Missing values include both user- and system-missing. (The system-missing + value is always in an excluded category.) + */ + switch (ss->function) + { + case CSTF_TOTALN: + case CTSF_ROWPCT_TOTALN: + case CTSF_COLPCT_TOTALN: + case CTSF_TABLEPCT_TOTALN: + case CTSF_SUBTABLEPCT_TOTALN: + case CTSF_LAYERPCT_TOTALN: + case CTSF_LAYERROWPCT_TOTALN: + case CTSF_LAYERCOLPCT_TOTALN: + s->count += d_weight; + break; + + case CSTF_UTOTALN: + case CTSF_UROWPCT_TOTALN: + case CTSF_UCOLPCT_TOTALN: + case CTSF_UTABLEPCT_TOTALN: + case CTSF_USUBTABLEPCT_TOTALN: + case CTSF_ULAYERPCT_TOTALN: + case CTSF_ULAYERROWPCT_TOTALN: + case CTSF_ULAYERCOLPCT_TOTALN: + s->count += 1.0; + break; + + case CTSF_COUNT: + case CTSF_ROWPCT_COUNT: + case CTSF_COLPCT_COUNT: + case CTSF_TABLEPCT_COUNT: + case CTSF_SUBTABLEPCT_COUNT: + case CTSF_LAYERPCT_COUNT: + case CTSF_LAYERROWPCT_COUNT: + case CTSF_LAYERCOLPCT_COUNT: + if (is_scale || !excluded_missing) + s->count += d_weight; + break; + + case CTSF_UCOUNT: + case CTSF_UROWPCT_COUNT: + case CTSF_UCOLPCT_COUNT: + case CTSF_UTABLEPCT_COUNT: + case CTSF_USUBTABLEPCT_COUNT: + case CTSF_ULAYERPCT_COUNT: + case CTSF_ULAYERROWPCT_COUNT: + case CTSF_ULAYERCOLPCT_COUNT: + if (is_scale || !excluded_missing) + s->count += 1.0; + break; + + case CTSF_VALIDN: + case CTSF_ROWPCT_VALIDN: + case CTSF_COLPCT_VALIDN: + case CTSF_TABLEPCT_VALIDN: + case CTSF_SUBTABLEPCT_VALIDN: + case CTSF_LAYERPCT_VALIDN: + case CTSF_LAYERROWPCT_VALIDN: + case CTSF_LAYERCOLPCT_VALIDN: + if (is_scale + ? !is_scale_missing + : !is_missing) + s->count += d_weight; + break; + + case CTSF_UVALIDN: + case CTSF_UROWPCT_VALIDN: + case CTSF_UCOLPCT_VALIDN: + case CTSF_UTABLEPCT_VALIDN: + case CTSF_USUBTABLEPCT_VALIDN: + case CTSF_ULAYERPCT_VALIDN: + case CTSF_ULAYERROWPCT_VALIDN: + case CTSF_ULAYERCOLPCT_VALIDN: + if (is_scale + ? !is_scale_missing + : !is_missing) + s->count += 1.0; + break; + + case CTSF_MISSING: + if (is_missing) + s->count += d_weight; + break; + + case CTSF_UMISSING: + if (is_missing) + s->count += 1.0; + break; + + case CTSF_ECOUNT: + if (is_scale || !excluded_missing) + s->count += e_weight; + break; + + case CTSF_EVALIDN: + if (is_scale + ? !is_scale_missing + : !is_missing) + s->count += e_weight; + break; + + case CTSF_ETOTALN: + s->count += e_weight; + break; + + case CTSF_MAXIMUM: + case CTSF_MINIMUM: + case CTSF_RANGE: + if (!is_scale_missing) + { + assert (!var_is_alpha (var)); /* XXX? */ + if (s->min == SYSMIS || value->f < s->min) + s->min = value->f; + if (s->max == SYSMIS || value->f > s->max) + s->max = value->f; + } + break; + + case CTSF_MEAN: + case CTSF_SEMEAN: + case CTSF_STDDEV: + case CTSF_SUM: + case CTSF_VARIANCE: + case CTSF_ROWPCT_SUM: + case CTSF_COLPCT_SUM: + case CTSF_TABLEPCT_SUM: + case CTSF_SUBTABLEPCT_SUM: + case CTSF_LAYERPCT_SUM: + case CTSF_LAYERROWPCT_SUM: + case CTSF_LAYERCOLPCT_SUM: + if (!is_scale_missing) + moments1_add (s->moments, value->f, e_weight); + break; + + case CTSF_UMEAN: + case CTSF_USEMEAN: + case CTSF_USTDDEV: + case CTSF_USUM: + case CTSF_UVARIANCE: + case CTSF_UROWPCT_SUM: + case CTSF_UCOLPCT_SUM: + case CTSF_UTABLEPCT_SUM: + case CTSF_USUBTABLEPCT_SUM: + case CTSF_ULAYERPCT_SUM: + case CTSF_ULAYERROWPCT_SUM: + case CTSF_ULAYERCOLPCT_SUM: + if (!is_scale_missing) + moments1_add (s->moments, value->f, 1.0); + break; + + case CTSF_UMEDIAN: + case CTSF_UMODE: + case CTSF_UPTILE: + d_weight = e_weight = 1.0; + /* Fall through. */ + case CTSF_MEDIAN: + case CTSF_MODE: + case CTSF_PTILE: + if (!is_scale_missing) + { + 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; + } +} + +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_UCOUNT: + case CTSF_UMISSING: + case CSTF_UTOTALN: + case CTSF_UVALIDN: + case CTSF_UMEAN: + case CTSF_USEMEAN: + case CTSF_USTDDEV: + case CTSF_USUM: + case CTSF_UVARIANCE: + case CTSF_UMEDIAN: + case CTSF_UPTILE: + case CTSF_UMODE: + NOT_REACHED (); + + case CTSF_COLPCT_COUNT: + case CTSF_COLPCT_SUM: + case CTSF_COLPCT_TOTALN: + case CTSF_COLPCT_VALIDN: + case CTSF_UCOLPCT_COUNT: + case CTSF_UCOLPCT_SUM: + case CTSF_UCOLPCT_TOTALN: + case CTSF_UCOLPCT_VALIDN: + return CTDT_COL; + + case CTSF_LAYERCOLPCT_COUNT: + case CTSF_LAYERCOLPCT_SUM: + case CTSF_LAYERCOLPCT_TOTALN: + case CTSF_LAYERCOLPCT_VALIDN: + case CTSF_ULAYERCOLPCT_COUNT: + case CTSF_ULAYERCOLPCT_SUM: + case CTSF_ULAYERCOLPCT_TOTALN: + case CTSF_ULAYERCOLPCT_VALIDN: + return CTDT_LAYERCOL; + + case CTSF_LAYERPCT_COUNT: + case CTSF_LAYERPCT_SUM: + case CTSF_LAYERPCT_TOTALN: + case CTSF_LAYERPCT_VALIDN: + case CTSF_ULAYERPCT_COUNT: + case CTSF_ULAYERPCT_SUM: + case CTSF_ULAYERPCT_TOTALN: + case CTSF_ULAYERPCT_VALIDN: + return CTDT_LAYER; + + case CTSF_LAYERROWPCT_COUNT: + case CTSF_LAYERROWPCT_SUM: + case CTSF_LAYERROWPCT_TOTALN: + case CTSF_LAYERROWPCT_VALIDN: + case CTSF_ULAYERROWPCT_COUNT: + case CTSF_ULAYERROWPCT_SUM: + case CTSF_ULAYERROWPCT_TOTALN: + case CTSF_ULAYERROWPCT_VALIDN: + return CTDT_LAYERROW; + + case CTSF_ROWPCT_COUNT: + case CTSF_ROWPCT_SUM: + case CTSF_ROWPCT_TOTALN: + case CTSF_ROWPCT_VALIDN: + case CTSF_UROWPCT_COUNT: + case CTSF_UROWPCT_SUM: + case CTSF_UROWPCT_TOTALN: + case CTSF_UROWPCT_VALIDN: + return CTDT_ROW; + + case CTSF_SUBTABLEPCT_COUNT: + case CTSF_SUBTABLEPCT_SUM: + case CTSF_SUBTABLEPCT_TOTALN: + case CTSF_SUBTABLEPCT_VALIDN: + case CTSF_USUBTABLEPCT_COUNT: + case CTSF_USUBTABLEPCT_SUM: + case CTSF_USUBTABLEPCT_TOTALN: + case CTSF_USUBTABLEPCT_VALIDN: + return CTDT_SUBTABLE; + + case CTSF_TABLEPCT_COUNT: + case CTSF_TABLEPCT_SUM: + case CTSF_TABLEPCT_TOTALN: + case CTSF_TABLEPCT_VALIDN: + case CTSF_UTABLEPCT_COUNT: + case CTSF_UTABLEPCT_SUM: + case CTSF_UTABLEPCT_TOTALN: + case CTSF_UTABLEPCT_VALIDN: + return CTDT_TABLE; + } + + NOT_REACHED (); +} + +static enum ctables_domain_type +ctables_function_is_pctsum (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_UCOUNT: + case CTSF_UMISSING: + case CSTF_UTOTALN: + case CTSF_UVALIDN: + case CTSF_UMEAN: + case CTSF_USEMEAN: + case CTSF_USTDDEV: + case CTSF_USUM: + case CTSF_UVARIANCE: + case CTSF_UMEDIAN: + case CTSF_UPTILE: + case CTSF_UMODE: + case CTSF_COLPCT_COUNT: + case CTSF_COLPCT_TOTALN: + case CTSF_COLPCT_VALIDN: + case CTSF_UCOLPCT_COUNT: + case CTSF_UCOLPCT_TOTALN: + case CTSF_UCOLPCT_VALIDN: + case CTSF_LAYERCOLPCT_COUNT: + case CTSF_LAYERCOLPCT_TOTALN: + case CTSF_LAYERCOLPCT_VALIDN: + case CTSF_ULAYERCOLPCT_COUNT: + case CTSF_ULAYERCOLPCT_TOTALN: + case CTSF_ULAYERCOLPCT_VALIDN: + case CTSF_LAYERPCT_COUNT: + case CTSF_LAYERPCT_TOTALN: + case CTSF_LAYERPCT_VALIDN: + case CTSF_ULAYERPCT_COUNT: + case CTSF_ULAYERPCT_TOTALN: + case CTSF_ULAYERPCT_VALIDN: + case CTSF_LAYERROWPCT_COUNT: + case CTSF_LAYERROWPCT_TOTALN: + case CTSF_LAYERROWPCT_VALIDN: + case CTSF_ULAYERROWPCT_COUNT: + case CTSF_ULAYERROWPCT_TOTALN: + case CTSF_ULAYERROWPCT_VALIDN: + case CTSF_ROWPCT_COUNT: + case CTSF_ROWPCT_TOTALN: + case CTSF_ROWPCT_VALIDN: + case CTSF_UROWPCT_COUNT: + case CTSF_UROWPCT_TOTALN: + case CTSF_UROWPCT_VALIDN: + case CTSF_SUBTABLEPCT_COUNT: + case CTSF_SUBTABLEPCT_TOTALN: + case CTSF_SUBTABLEPCT_VALIDN: + case CTSF_USUBTABLEPCT_COUNT: + case CTSF_USUBTABLEPCT_TOTALN: + case CTSF_USUBTABLEPCT_VALIDN: + case CTSF_TABLEPCT_COUNT: + case CTSF_TABLEPCT_TOTALN: + case CTSF_TABLEPCT_VALIDN: + case CTSF_UTABLEPCT_COUNT: + case CTSF_UTABLEPCT_TOTALN: + case CTSF_UTABLEPCT_VALIDN: + return false; + + case CTSF_COLPCT_SUM: + case CTSF_UCOLPCT_SUM: + case CTSF_LAYERCOLPCT_SUM: + case CTSF_ULAYERCOLPCT_SUM: + case CTSF_LAYERPCT_SUM: + case CTSF_ULAYERPCT_SUM: + case CTSF_LAYERROWPCT_SUM: + case CTSF_ULAYERROWPCT_SUM: + case CTSF_ROWPCT_SUM: + case CTSF_UROWPCT_SUM: + case CTSF_SUBTABLEPCT_SUM: + case CTSF_USUBTABLEPCT_SUM: + case CTSF_TABLEPCT_SUM: + case CTSF_UTABLEPCT_SUM: + return true; + } + + NOT_REACHED (); +} + +static double +ctables_summary_value (const struct ctables_cell *cell, + union ctables_summary *s, + const struct ctables_summary_spec *ss) +{ + switch (ss->function) + { + case CTSF_COUNT: + case CTSF_ECOUNT: + case CTSF_UCOUNT: + return s->count; + + case CTSF_ROWPCT_COUNT: + case CTSF_COLPCT_COUNT: + case CTSF_TABLEPCT_COUNT: + case CTSF_SUBTABLEPCT_COUNT: + case CTSF_LAYERPCT_COUNT: + case CTSF_LAYERROWPCT_COUNT: + case CTSF_LAYERCOLPCT_COUNT: + { + enum ctables_domain_type d = ctables_function_domain (ss->function); + return (cell->domains[d]->e_count + ? s->count / cell->domains[d]->e_count * 100 + : SYSMIS); + } + + case CTSF_UROWPCT_COUNT: + case CTSF_UCOLPCT_COUNT: + case CTSF_UTABLEPCT_COUNT: + case CTSF_USUBTABLEPCT_COUNT: + case CTSF_ULAYERPCT_COUNT: + case CTSF_ULAYERROWPCT_COUNT: + case CTSF_ULAYERCOLPCT_COUNT: + { + enum ctables_domain_type d = ctables_function_domain (ss->function); + return (cell->domains[d]->u_count + ? s->count / cell->domains[d]->u_count * 100 + : SYSMIS); + } + + case CTSF_ROWPCT_VALIDN: + case CTSF_COLPCT_VALIDN: + case CTSF_TABLEPCT_VALIDN: + case CTSF_SUBTABLEPCT_VALIDN: + case CTSF_LAYERPCT_VALIDN: + case CTSF_LAYERROWPCT_VALIDN: + case CTSF_LAYERCOLPCT_VALIDN: + { + enum ctables_domain_type d = ctables_function_domain (ss->function); + return (cell->domains[d]->e_valid + ? s->count / cell->domains[d]->e_valid * 100 + : SYSMIS); + } + + case CTSF_UROWPCT_VALIDN: + case CTSF_UCOLPCT_VALIDN: + case CTSF_UTABLEPCT_VALIDN: + case CTSF_USUBTABLEPCT_VALIDN: + case CTSF_ULAYERPCT_VALIDN: + case CTSF_ULAYERROWPCT_VALIDN: + case CTSF_ULAYERCOLPCT_VALIDN: + { + enum ctables_domain_type d = ctables_function_domain (ss->function); + return (cell->domains[d]->u_valid + ? s->count / cell->domains[d]->u_valid * 100 + : SYSMIS); + } + + case CTSF_ROWPCT_TOTALN: + case CTSF_COLPCT_TOTALN: + case CTSF_TABLEPCT_TOTALN: + case CTSF_SUBTABLEPCT_TOTALN: + case CTSF_LAYERPCT_TOTALN: + case CTSF_LAYERROWPCT_TOTALN: + case CTSF_LAYERCOLPCT_TOTALN: + { + enum ctables_domain_type d = ctables_function_domain (ss->function); + return (cell->domains[d]->e_total + ? s->count / cell->domains[d]->e_total * 100 + : SYSMIS); + } + + case CTSF_UROWPCT_TOTALN: + case CTSF_UCOLPCT_TOTALN: + case CTSF_UTABLEPCT_TOTALN: + case CTSF_USUBTABLEPCT_TOTALN: + case CTSF_ULAYERPCT_TOTALN: + case CTSF_ULAYERROWPCT_TOTALN: + case CTSF_ULAYERCOLPCT_TOTALN: + { + enum ctables_domain_type d = ctables_function_domain (ss->function); + return (cell->domains[d]->u_total + ? s->count / cell->domains[d]->u_total * 100 + : SYSMIS); + } + + case CTSF_MISSING: + case CTSF_UMISSING: + case CSTF_TOTALN: + case CTSF_ETOTALN: + case CSTF_UTOTALN: + case CTSF_VALIDN: + case CTSF_UVALIDN: + case CTSF_EVALIDN: + return s->count; + + case CTSF_MAXIMUM: + return s->max; + + case CTSF_MINIMUM: + return s->min; + + case CTSF_RANGE: + return s->max != SYSMIS && s->min != SYSMIS ? s->max - s->min : SYSMIS; + + case CTSF_MEAN: + case CTSF_UMEAN: + { + double mean; + moments1_calculate (s->moments, NULL, &mean, NULL, NULL, NULL); + return mean; + } + + case CTSF_SEMEAN: + case CTSF_USEMEAN: + { + double weight, variance; + moments1_calculate (s->moments, &weight, NULL, &variance, NULL, NULL); + return calc_semean (variance, weight); + } + + case CTSF_STDDEV: + case CTSF_USTDDEV: + { + double variance; + moments1_calculate (s->moments, NULL, NULL, &variance, NULL, NULL); + return variance != SYSMIS ? sqrt (variance) : SYSMIS; + } + + case CTSF_SUM: + case CTSF_USUM: + { + double weight, mean; + moments1_calculate (s->moments, &weight, &mean, NULL, NULL, NULL); + return weight != SYSMIS && mean != SYSMIS ? weight * mean : SYSMIS; + } + + case CTSF_VARIANCE: + case CTSF_UVARIANCE: + { + double variance; + moments1_calculate (s->moments, NULL, NULL, &variance, NULL, NULL); + return variance; + } + + case CTSF_ROWPCT_SUM: + case CTSF_COLPCT_SUM: + case CTSF_TABLEPCT_SUM: + case CTSF_SUBTABLEPCT_SUM: + case CTSF_LAYERPCT_SUM: + case CTSF_LAYERROWPCT_SUM: + case CTSF_LAYERCOLPCT_SUM: + { + double weight, mean; + moments1_calculate (s->moments, &weight, &mean, NULL, NULL, NULL); + if (weight == SYSMIS || mean == SYSMIS) + return SYSMIS; + enum ctables_domain_type d = ctables_function_domain (ss->function); + double num = weight * mean; + double denom = cell->domains[d]->sums[ss->sum_var_idx].e_sum; + return denom != 0 ? num / denom * 100 : SYSMIS; + } + case CTSF_UROWPCT_SUM: + case CTSF_UCOLPCT_SUM: + case CTSF_UTABLEPCT_SUM: + case CTSF_USUBTABLEPCT_SUM: + case CTSF_ULAYERPCT_SUM: + case CTSF_ULAYERROWPCT_SUM: + case CTSF_ULAYERCOLPCT_SUM: + { + double weight, mean; + moments1_calculate (s->moments, &weight, &mean, NULL, NULL, NULL); + if (weight == SYSMIS || mean == SYSMIS) + return SYSMIS; + enum ctables_domain_type d = ctables_function_domain (ss->function); + double num = weight * mean; + double denom = cell->domains[d]->sums[ss->sum_var_idx].u_sum; + return denom != 0 ? num / denom * 100 : SYSMIS; + } + + case CTSF_MEDIAN: + case CTSF_PTILE: + case CTSF_UMEDIAN: + case CTSF_UPTILE: + 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: + case CTSF_UMODE: + 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; + } + + NOT_REACHED (); +} + +struct ctables_cell_sort_aux + { + const struct ctables_nest *nest; + enum pivot_axis_type a; + }; + +static int +ctables_cell_compare_3way (const void *a_, const void *b_, const void *aux_) +{ + const struct ctables_cell_sort_aux *aux = aux_; + struct ctables_cell *const *ap = a_; + struct ctables_cell *const *bp = b_; + const struct ctables_cell *a = *ap; + const struct ctables_cell *b = *bp; + + const struct ctables_nest *nest = aux->nest; + for (size_t i = 0; i < nest->n; i++) + if (i != nest->scale_idx) + { + const struct variable *var = nest->vars[i]; + const struct ctables_cell_value *a_cv = &a->axes[aux->a].cvs[i]; + const struct ctables_cell_value *b_cv = &b->axes[aux->a].cvs[i]; + if (a_cv->category != b_cv->category) + return a_cv->category > b_cv->category ? 1 : -1; + + const union value *a_val = &a_cv->value; + const union value *b_val = &b_cv->value; + switch (a_cv->category->type) + { + case CCT_NUMBER: + case CCT_STRING: + case CCT_SUBTOTAL: + case CCT_TOTAL: + case CCT_POSTCOMPUTE: + case CCT_EXCLUDED_MISSING: + /* Must be equal. */ + continue; + + case CCT_NRANGE: + case CCT_SRANGE: + case CCT_MISSING: + case CCT_OTHERNM: + { + int cmp = value_compare_3way (a_val, b_val, var_get_width (var)); + if (cmp) + return cmp; + } + break; + + case CCT_VALUE: + { + int cmp = value_compare_3way (a_val, b_val, var_get_width (var)); + if (cmp) + return a_cv->category->sort_ascending ? cmp : -cmp; + } + break; + + case CCT_LABEL: + { + const char *a_label = var_lookup_value_label (var, a_val); + const char *b_label = var_lookup_value_label (var, b_val); + int cmp = (a_label + ? (b_label ? strcmp (a_label, b_label) : 1) + : (b_label ? -1 : value_compare_3way ( + a_val, b_val, var_get_width (var)))); + if (cmp) + return a_cv->category->sort_ascending ? cmp : -cmp; + } + break; + + case CCT_FUNCTION: + NOT_REACHED (); + } + } + return 0; +} + +/* Algorithm: + + For each row: + For each ctables_table: + For each combination of row vars: + For each combination of column vars: + For each combination of layer vars: + Add entry + Make a table of row values: + Sort entries by row values + Assign a 0-based index to each actual value + Construct a dimension + Make a table of column values + Make a table of layer values + For each entry: + Fill the table entry using the indexes from before. + */ + +static struct ctables_domain * +ctables_domain_insert (struct ctables_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++) + { + 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]; + struct ctables_cell_value *cv = &cell->axes[a].cvs[v_idx]; + 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[v_idx]), hash); + } + } + + struct ctables_domain *d; + 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++) + { + 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]; + struct ctables_cell_value *cv1 = &df->axes[a].cvs[v_idx]; + struct ctables_cell_value *cv2 = &cell->axes[a].cvs[v_idx]; + if (cv1->category != cv2->category + || (cv1->category->type != CCT_TOTAL + && cv1->category->type != CCT_SUBTOTAL + && cv1->category->type != CCT_POSTCOMPUTE + && !value_equal (&cv1->value, &cv2->value, + var_get_width (nest->vars[v_idx])))) + goto not_equal; + } + } + return d; + + not_equal: ; + } + + struct ctables_sum *sums = (s->table->n_sum_vars + ? xzalloc (s->table->n_sum_vars * sizeof *sums) + : NULL); + + d = xmalloc (sizeof *d); + *d = (struct ctables_domain) { .example = cell, .sums = sums }; + hmap_insert (&s->domains[domain], &d->node, hash); + return d; +} + +static struct substring +rtrim_value (const union value *v, const struct variable *var) +{ + struct substring s = ss_buffer (CHAR_CAST (char *, v->s), + var_get_width (var)); + ss_rtrim (&s, ss_cstr (" ")); + return s; +} + +static bool +in_string_range (const union value *v, const struct variable *var, + const struct substring *srange) +{ + struct substring s = rtrim_value (v, var); + return ((!srange[0].string || ss_compare (s, srange[0]) >= 0) + && (!srange[1].string || ss_compare (s, srange[1]) <= 0)); +} + +static const struct ctables_category * +ctables_categories_match (const struct ctables_categories *c, + const union value *v, const struct variable *var) +{ + if (var_is_numeric (var) && v->f == SYSMIS) + return NULL; + + const struct ctables_category *othernm = NULL; + for (size_t i = c->n_cats; i-- > 0; ) + { + const struct ctables_category *cat = &c->cats[i]; + switch (cat->type) + { + case CCT_NUMBER: + if (cat->number == v->f) + return cat; + break; + + case CCT_STRING: + if (ss_equals (cat->string, rtrim_value (v, var))) + return cat; + break; + + case CCT_NRANGE: + if ((cat->nrange[0] == -DBL_MAX || v->f >= cat->nrange[0]) + && (cat->nrange[1] == DBL_MAX || v->f <= cat->nrange[1])) + return cat; + break; + + case CCT_SRANGE: + if (in_string_range (v, var, cat->srange)) + return cat; + break; + + case CCT_MISSING: + if (var_is_value_missing (var, v)) + return cat; + break; + + case CCT_POSTCOMPUTE: + break; + + case CCT_OTHERNM: + if (!othernm) + othernm = cat; + break; + + case CCT_SUBTOTAL: + case CCT_TOTAL: + break; + + case CCT_VALUE: + case CCT_LABEL: + case CCT_FUNCTION: + return (cat->include_missing || !var_is_value_missing (var, v) ? cat + : NULL); + + case CCT_EXCLUDED_MISSING: + break; + } + } + + return var_is_value_missing (var, v) ? NULL : othernm; +} + +static const struct ctables_category * +ctables_categories_total (const struct ctables_categories *c) +{ + const struct ctables_category *first = &c->cats[0]; + const struct ctables_category *last = &c->cats[c->n_cats - 1]; + return (first->type == CCT_TOTAL ? first + : last->type == CCT_TOTAL ? last + : NULL); +} + +static struct ctables_cell * +ctables_cell_insert__ (struct ctables_section *s, const struct ccase *c, + const struct ctables_category *cats[PIVOT_N_AXES][10]) +{ + 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 = 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_POSTCOMPUTE) + hash = value_hash (case_data (c, nest->vars[i]), + var_get_width (nest->vars[i]), hash); + else + sv = CSV_TOTAL; + } + } + + struct ctables_cell *cell; + HMAP_FOR_EACH_WITH_HASH (cell, struct ctables_cell, node, hash, &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 + && (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_POSTCOMPUTE + && !value_equal (case_data (c, nest->vars[i]), + &cell->axes[a].cvs[i].value, + var_get_width (nest->vars[i]))))) + goto not_equal; + } + + return cell; + + not_equal: ; + } + + cell = xmalloc (sizeof *cell); + cell->hide = false; + cell->sv = sv; + cell->omit_domains = 0; + cell->postcompute = false; + //struct string name = DS_EMPTY_INITIALIZER; + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; 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]; + const struct variable *var = nest->vars[i]; + const union value *value = case_data (c, var); + if (i != nest->scale_idx) + { + 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) + { + /* XXX these should be more encompassing I think.*/ + + switch (a) + { + case PIVOT_AXIS_COLUMN: + cell->omit_domains |= ((1u << CTDT_TABLE) | + (1u << CTDT_LAYER) | + (1u << CTDT_LAYERCOL) | + (1u << CTDT_SUBTABLE) | + (1u << CTDT_COL)); + break; + case PIVOT_AXIS_ROW: + cell->omit_domains |= ((1u << CTDT_TABLE) | + (1u << CTDT_LAYER) | + (1u << CTDT_LAYERROW) | + (1u << CTDT_SUBTABLE) | + (1u << CTDT_ROW)); + break; + case PIVOT_AXIS_LAYER: + cell->omit_domains |= ((1u << CTDT_TABLE) | + (1u << CTDT_LAYER)); + break; + } + } + if (cat->type == CCT_POSTCOMPUTE) + cell->postcompute = true; + } + + cell->axes[a].cvs[i].category = cat; + value_clone (&cell->axes[a].cvs[i].value, value, var_get_width (var)); + +#if 0 + if (i != nest->scale_idx) + { + if (!ds_is_empty (&name)) + ds_put_cstr (&name, ", "); + char *value_s = data_out (value, var_get_encoding (var), + var_get_print_format (var), + settings_get_fmt_settings ()); + if (cat->type == CCT_TOTAL + || cat->type == CCT_SUBTOTAL + || cat->type == CCT_POSTCOMPUTE) + ds_put_format (&name, "%s=total", var_get_name (var)); + else + ds_put_format (&name, "%s=%s", var_get_name (var), + value_s + strspn (value_s, " ")); + free (value_s); + } +#endif + } + } + //cell->name = ds_steal_cstr (&name); + + 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 (s, cell, dt); + hmap_insert (&s->cells, &cell->node, hash); + return cell; +} + +static bool +is_scale_missing (const struct ctables_summary_spec_set *specs, + const struct ccase *c) +{ + if (!specs->is_scale) + return false; + + if (var_is_num_missing (specs->var, case_num (c, specs->var))) + return true; + + for (size_t i = 0; i < specs->n_listwise_vars; i++) + { + const struct variable *var = specs->listwise_vars[i]; + if (var_is_num_missing (var, case_num (c, var))) + return true; + } + + return false; +} + +static void +ctables_cell_add__ (struct ctables_section *s, const struct ccase *c, + const struct ctables_category *cats[PIVOT_N_AXES][10], + bool is_missing, bool excluded_missing, + double d_weight, double e_weight) +{ + 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]; + + bool scale_missing = is_scale_missing (specs, c); + 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), specs->is_scale, + scale_missing, is_missing, excluded_missing, + d_weight, e_weight); + for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++) + if (!(cell->omit_domains && (1u << dt))) + { + struct ctables_domain *d = cell->domains[dt]; + d->d_total += d_weight; + d->e_total += e_weight; + d->u_total += 1.0; + if (!excluded_missing) + { + d->d_count += d_weight; + d->e_count += e_weight; + d->u_count += 1.0; + } + if (!is_missing) + { + d->d_valid += d_weight; + d->e_valid += e_weight; + d->u_count += 1.0; + + for (size_t i = 0; i < s->table->n_sum_vars; i++) + { + /* XXX listwise_missing??? */ + const struct variable *var = s->table->sum_vars[i]; + double addend = case_num (c, var); + if (!var_is_num_missing (var, addend)) + { + struct ctables_sum *sum = &d->sums[i]; + sum->e_sum += addend * e_weight; + sum->u_sum += addend; + } + } + } + } +} + +static void +recurse_totals (struct ctables_section *s, const struct ccase *c, + const struct ctables_category *cats[PIVOT_N_AXES][10], + bool is_missing, bool excluded_missing, + 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 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, is_missing, excluded_missing, + d_weight, e_weight); + recurse_totals (s, c, cats, is_missing, excluded_missing, + 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], + bool is_missing, bool excluded_missing, + 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, is_missing, excluded_missing, + d_weight, e_weight); + recurse_subtotals (s, c, cats, is_missing, excluded_missing, + 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 */ + + /* Does at least one categorical variable have a missing value in an included + or excluded category? */ + bool is_missing = false; + + /* Does at least one categorical variable have a missing value in an excluded + category? */ + bool excluded_missing = false; + + 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); + + bool var_missing = var_is_value_missing (var, value) != 0; + if (var_missing) + is_missing = true; + + cats[a][i] = ctables_categories_match ( + s->table->categories[var_get_dict_index (var)], value, var); + if (!cats[a][i]) + { + if (!var_missing) + return; + + static const struct ctables_category cct_excluded_missing = { + .type = CCT_EXCLUDED_MISSING, + .hide = true, + }; + cats[a][i] = &cct_excluded_missing; + excluded_missing = true; + } + } + } + + if (!excluded_missing) + 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, is_missing, excluded_missing, + d_weight, e_weight); + + //if (!excluded_missing) + { + recurse_totals (s, c, cats, is_missing, excluded_missing, + d_weight, e_weight, 0, 0); + recurse_subtotals (s, c, cats, is_missing, excluded_missing, + 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; + + const char *as_label = as->label ? as->label : ""; + const char *bs_label = bs->label ? bs->label : ""; + 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) + : pivot_value_new_var_value (var, value)); +} + +static struct pivot_value * +ctables_postcompute_label (const struct ctables_categories *cats, + const struct ctables_category *cat, + const struct variable *var, + const union value *value) +{ + struct substring in = ss_cstr (cat->pc->label); + struct substring target = ss_cstr (")LABEL["); + + struct string out = DS_EMPTY_INITIALIZER; + for (;;) + { + size_t chunk = ss_find_substring (in, target); + if (chunk == SIZE_MAX) + { + if (ds_is_empty (&out)) + return pivot_value_new_user_text (in.string, in.length); + else + { + ds_put_substring (&out, in); + return pivot_value_new_user_text_nocopy (ds_steal_cstr (&out)); + } + } + + ds_put_substring (&out, ss_head (in, chunk)); + ss_advance (&in, chunk + target.length); + + struct substring idx_s; + if (!ss_get_until (&in, ']', &idx_s)) + goto error; + char *tail; + long int idx = strtol (idx_s.string, &tail, 10); + if (idx < 1 || idx > cats->n_cats || tail != ss_end (idx_s)) + goto error; + + struct ctables_category *cat2 = &cats->cats[idx - 1]; + struct pivot_value *label2 + = ctables_category_create_label__ (cat2, var, value); + char *label2_s = pivot_value_to_string_defaults (label2); + ds_put_cstr (&out, label2_s); + free (label2_s); + pivot_value_destroy (label2); + } + +error: + ds_destroy (&out); + return pivot_value_new_user_text (cat->pc->label, SIZE_MAX); +} + +static struct pivot_value * +ctables_category_create_label (const struct ctables_categories *cats, + const struct ctables_category *cat, + const struct variable *var, + const union value *value) +{ + return (cat->type == CCT_POSTCOMPUTE && cat->pc->label + ? ctables_postcompute_label (cats, cat, var, value) + : ctables_category_create_label__ (cat, 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 void +ctables_value_insert (struct ctables_table *t, const union value *value, + int width) +{ + 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 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; + size_t summary_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]; + return ctables_summary_value (tc, &tc->summaries[ctx->summary_idx], + &specs->specs[ctx->summary_idx]); +} + +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_NRANGE: + case CTPO_CAT_SRANGE: + { + 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 (); +} + +/* XXX what if there is a postcompute in more than one dimension?? */ +static const struct ctables_postcompute * +ctables_cell_postcompute (const struct ctables_section *s, + const struct ctables_cell *cell, + enum pivot_axis_type *pc_a_p, + size_t *pc_a_idx_p) +{ + assert (cell->postcompute); + const struct ctables_postcompute *pc = NULL; + for (enum pivot_axis_type pc_a = 0; pc_a < PIVOT_N_AXES; pc_a++) + for (size_t 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) + { + if (pc) + { + /* Multiple postcomputes cross each other. The value is + undefined. */ + return NULL; + } + + pc = cv->category->pc; + if (pc_a_p) + *pc_a_p = pc_a; + if (pc_a_idx_p) + *pc_a_idx_p = pc_a_idx; + } + } + + assert (pc != NULL); + return pc; +} + +static double +ctables_cell_calculate_postcompute (const struct ctables_section *s, + const struct ctables_cell *cell, + const struct ctables_summary_spec *ss, + struct fmt_spec *format, + bool *is_ctables_format, + size_t summary_idx) +{ + enum pivot_axis_type pc_a = 0; + size_t pc_a_idx = 0; + const struct ctables_postcompute *pc = ctables_cell_postcompute ( + s, cell, &pc_a, &pc_a_idx); + if (!pc) + return SYSMIS; + + if (pc->specs) + { + for (size_t i = 0; i < pc->specs->n; i++) + { + const struct ctables_summary_spec *ss2 = &pc->specs->specs[i]; + if (ss->function == ss2->function + && ss->percentile == ss2->percentile) + { + *format = ss2->format; + *is_ctables_format = ss2->is_ctables_format; + break; + } + } + } + + 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, + .summary_idx = summary_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_corner_text ( + 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, ctables_summary_label (&specs->specs[i], t->cilevel)); + } + + 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 ( + c, 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); + +#if 0 + for (size_t j = 0; j < n_sorted; j++) + { + printf ("%s (%s): %f/%f = %.1f%%\n", sorted[j]->name, sorted[j]->contributes_to_domains ? "y" : "n", sorted[j]->summaries[0].count, sorted[j]->domains[CTDT_COL]->e_count, sorted[j]->summaries[0].count / sorted[j]->domains[CTDT_COL]->e_count * 100.0); + } + printf ("\n"); +#endif + + 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; + + enum settings_value_show vlabel; /* CTL_VAR only. */ + 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, + .vlabel = (enum settings_value_show) vlabel, + .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, ctables_summary_label (&specs->specs[m], + t->cilevel)); + 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); + label->variable.show = level->vlabel; + } + else if (level->type == CTL_CATEGORY) + { + const struct ctables_cell_value *cv = &cell->axes[a].cvs[level->var_idx]; + label = ctables_category_create_label ( + t->categories[var_get_dict_index (var)], + 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)); + if (!ctv) + continue; + 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; + } + + const struct ctables_summary_spec *ss = &specs->specs[j]; + + struct fmt_spec format = specs->specs[j].format; + bool is_ctables_format = ss->is_ctables_format; + double d = (cell->postcompute + ? ctables_cell_calculate_postcompute ( + s, cell, ss, &format, &is_ctables_format, j) + : ctables_summary_value (cell, &cell->summaries[j], + ss)); + + struct pivot_value *value; + if (ct->hide_threshold != 0 + && d < ct->hide_threshold + && ctables_summary_function_is_count (ss->function)) + { + value = pivot_value_new_user_text_nocopy ( + xasprintf ("<%d", ct->hide_threshold)); + } + else if (d == 0 && ct->zero) + value = pivot_value_new_user_text (ct->zero, SIZE_MAX); + else if (d == SYSMIS && ct->missing) + value = pivot_value_new_user_text (ct->missing, SIZE_MAX); + else if (is_ctables_format) + { + char *s = data_out_stretchy (&(union value) { .f = d }, + "UTF-8", &format, + &ct->ctables_formats, NULL); + value = pivot_value_new_user_text_nocopy (s); + } + else + { + value = pivot_value_new_number (d); + value->numeric.format = 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 size_t +add_sum_var (struct variable *var, + struct variable ***sum_vars, size_t *n, size_t *allocated) +{ + for (size_t i = 0; i < *n; i++) + if (var == (*sum_vars)[i]) + return i; + + if (*n >= *allocated) + *sum_vars = x2nrealloc (*sum_vars, allocated, sizeof **sum_vars); + (*sum_vars)[*n] = var; + return (*n)++; +} + +static void +enumerate_sum_vars (const struct ctables_axis *a, + struct variable ***sum_vars, size_t *n, size_t *allocated) +{ + if (!a) + return; + + switch (a->op) + { + case CTAO_VAR: + for (size_t i = 0; i < N_CSVS; i++) + for (size_t j = 0; j < a->specs[i].n; j++) + { + struct ctables_summary_spec *spec = &a->specs[i].specs[j]; + if (ctables_function_is_pctsum (spec->function)) + spec->sum_var_idx = add_sum_var (a->var, sum_vars, n, allocated); + } + break; + + case CTAO_STACK: + case CTAO_NEST: + for (size_t i = 0; i < 2; i++) + enumerate_sum_vars (a->subs[i], sum_vars, n, allocated); + break; + } +} + +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->is_scale ? CTSF_MEAN : CTSF_COUNT; + + *specs->specs = (struct ctables_summary_spec) { + .function = function, + .format = ctables_summary_default_format (function, specs->var), + }; + 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]); + + if (t->ctables->smissing_listwise) + { + struct variable **listwise_vars = NULL; + size_t n = 0; + size_t allocated = 0; + + for (size_t j = nest->group_head; j < stack->n; j++) + { + const struct ctables_nest *other_nest = &stack->nests[j]; + if (other_nest->group_head != nest->group_head) + break; + + if (nest != other_nest && other_nest->scale_idx < other_nest->n) + { + if (n >= allocated) + listwise_vars = x2nrealloc (listwise_vars, &allocated, + sizeof *listwise_vars); + listwise_vars[n++] = other_nest->vars[other_nest->scale_idx]; + } + } + for (size_t j = 0; j < N_CSVS; j++) + { + nest->specs[j].listwise_vars = listwise_vars; + nest->specs[j].n_listwise_vars = n; + } + } + } + + struct ctables_summary_spec_set *merged = &t->summary_specs; + struct merge_item *items = xnmalloc (N_CSVS * 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 + + size_t allocated_sum_vars = 0; + enumerate_sum_vars (t->axes[t->summary_axis], + &t->sum_vars, &t->n_sum_vars, &allocated_sum_vars); + + 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]; + 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)) + ctables_value_insert (t, value, var_get_width (var)); + } +} + +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) +{ + const struct variable *v0 = t->clabels_example; + int width = var_get_width (v0); + + struct ctables_categories *c0 = t->categories[var_get_dict_index (v0)]; + if (c0->show_empty) + { + const struct val_labs *val_labs = var_get_value_labels (v0); + for (const struct val_lab *vl = val_labs_first (val_labs); vl; + vl = val_labs_next (val_labs, vl)) + if (ctables_categories_match (c0, &vl->value, v0)) + ctables_value_insert (t, &vl->value, width); + } + + 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: + { + int width = var_get_width (var); + union value value; + value_init (&value, width); + value_copy_buf_rpad (&value, width, + CHAR_CAST (uint8_t *, c->string.string), + c->string.length, ' '); + ctables_add_occurrence (var, &value, occurrences); + value_destroy (&value, width); + } + break; + + case CCT_NRANGE: + 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->nrange[0] && vl->value.f <= c->nrange[1]) + ctables_add_occurrence (var, &vl->value, occurrences); + break; + + case CCT_SRANGE: + assert (var_is_alpha (var)); + for (const struct val_lab *vl = val_labs_first (val_labs); vl; + vl = val_labs_next (val_labs, vl)) + if (in_string_range (&vl->value, var, c->srange)) + 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; + + case CCT_EXCLUDED_MISSING: + 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 *, + struct dictionary *); + +static void +ctables_pcexpr_destroy (struct ctables_pcexpr *e) +{ + if (e) + { + switch (e->op) + { + case CTPO_CAT_STRING: + ss_dealloc (&e->string); + break; + + case CTPO_CAT_SRANGE: + for (size_t i = 0; i < 2; i++) + ss_dealloc (&e->srange[i]); + 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_NRANGE: + 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 * +ctable_pcexpr_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 * +ctable_pcexpr_parse_binary_operators__ ( + struct lexer *lexer, struct dictionary *dict, + 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 + = ctable_pcexpr_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, dict); + if (!rhs) + { + ctables_pcexpr_destroy (lhs); + return NULL; + } + + lhs = ctables_pcexpr_allocate_binary (op->op, lhs, rhs); + } +} + +static struct ctables_pcexpr * +ctable_pcexpr_parse_binary_operators (struct lexer *lexer, + struct dictionary *dict, + 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, dict); + if (!lhs) + return NULL; + + return ctable_pcexpr_parse_binary_operators__ (lexer, dict, ops, n_ops, + parse_next_level, + chain_warning, lhs); +} + +static struct ctables_pcexpr *ctable_pcexpr_parse_add (struct lexer *, + struct dictionary *); + +static struct ctables_pcexpr +ctpo_cat_nrange (double low, double high) +{ + return (struct ctables_pcexpr) { + .op = CTPO_CAT_NRANGE, + .nrange = { low, high }, + }; +} + +static struct ctables_pcexpr * +ctable_pcexpr_parse_primary (struct lexer *lexer, struct dictionary *dict) +{ + 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_nrange (-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_nrange (number, DBL_MAX); + else + { + if (!lex_force_num (lexer)) + return false; + e = ctpo_cat_nrange (number, lex_number (lexer)); + lex_get (lexer); + } + } + else + e = (struct ctables_pcexpr) { .op = CTPO_CAT_NUMBER, + .number = number }; + } + else if (lex_is_string (lexer)) + { + struct substring s = recode_substring_pool ( + dict_get_encoding (dict), "UTF-8", lex_tokss (lexer), NULL); + ss_rtrim (&s, ss_cstr (" ")); + + e = (struct ctables_pcexpr) { .op = CTPO_CAT_STRING, .string = s }; + lex_get (lexer); + } + else + { + lex_error (lexer, NULL); + return NULL; + } + + if (!lex_force_match (lexer, T_RBRACK)) + { + if (e.op == CTPO_CAT_STRING) + ss_dealloc (&e.string); + return NULL; + } + } + else if (lex_match (lexer, T_LPAREN)) + { + struct ctables_pcexpr *ep = ctable_pcexpr_parse_add (lexer, dict); + if (!ep) + return NULL; + if (!lex_force_match (lexer, T_RPAREN)) + { + ctables_pcexpr_destroy (ep); + return NULL; + } + return ep; + } + else + { + lex_error (lexer, NULL); + return NULL; + } + + e.location = lex_ofs_location (lexer, start_ofs, lex_ofs (lexer) - 1); + return xmemdup (&e, sizeof e); +} + +static struct ctables_pcexpr * +ctables_pcexpr_allocate_neg (struct ctables_pcexpr *sub, + struct lexer *lexer, int start_ofs) +{ + struct ctables_pcexpr *e = xmalloc (sizeof *e); + *e = (struct ctables_pcexpr) { + .op = CTPO_NEG, + .subs = { sub }, + .location = lex_ofs_location (lexer, start_ofs, lex_ofs (lexer) - 1), + }; + return e; +} + +static struct ctables_pcexpr * +ctable_pcexpr_parse_exp (struct lexer *lexer, struct dictionary *dict) +{ + 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 ctable_pcexpr_parse_binary_operators (lexer, dict, &op, 1, + ctable_pcexpr_parse_primary, + chain_warning); + + /* Special case for situations like "-5**6", which must be parsed as + -(5**6). */ + + int start_ofs = lex_ofs (lexer); + struct ctables_pcexpr *lhs = xmalloc (sizeof *lhs); + *lhs = (struct ctables_pcexpr) { + .op = CTPO_CONSTANT, + .number = -lex_tokval (lexer), + .location = lex_ofs_location (lexer, start_ofs, lex_ofs (lexer)), + }; + lex_get (lexer); + + struct ctables_pcexpr *node = ctable_pcexpr_parse_binary_operators__ ( + lexer, dict, &op, 1, + ctable_pcexpr_parse_primary, chain_warning, lhs); + if (!node) + return NULL; + + return ctables_pcexpr_allocate_neg (node, lexer, start_ofs); +} + +/* Parses the unary minus level. */ +static struct ctables_pcexpr * +ctable_pcexpr_parse_neg (struct lexer *lexer, struct dictionary *dict) +{ + int start_ofs = lex_ofs (lexer); + if (!lex_match (lexer, T_DASH)) + return ctable_pcexpr_parse_exp (lexer, dict); + + struct ctables_pcexpr *inner = ctable_pcexpr_parse_neg (lexer, dict); + if (!inner) + return NULL; + + return ctables_pcexpr_allocate_neg (inner, lexer, start_ofs); +} + +/* Parses the multiplication and division level. */ +static struct ctables_pcexpr * +ctable_pcexpr_parse_mul (struct lexer *lexer, struct dictionary *dict) +{ + static const struct operator ops[] = + { + { T_ASTERISK, CTPO_MUL }, + { T_SLASH, CTPO_DIV }, + }; + + return ctable_pcexpr_parse_binary_operators (lexer, dict, ops, + sizeof ops / sizeof *ops, + ctable_pcexpr_parse_neg, NULL); +} + +/* Parses the addition and subtraction level. */ +static struct ctables_pcexpr * +ctable_pcexpr_parse_add (struct lexer *lexer, struct dictionary *dict) +{ + static const struct operator ops[] = + { + { T_PLUS, CTPO_ADD }, + { T_DASH, CTPO_SUB }, + { T_NEG_NUM, CTPO_ADD }, + }; + + return ctable_pcexpr_parse_binary_operators (lexer, dict, + ops, sizeof ops / sizeof *ops, + ctable_pcexpr_parse_mul, NULL); +} + +static struct ctables_postcompute * +ctables_find_postcompute (struct ctables *ct, const char *name) +{ + struct ctables_postcompute *pc; + HMAP_FOR_EACH_WITH_HASH (pc, struct ctables_postcompute, hmap_node, + utf8_hash_case_string (name, 0), &ct->postcomputes) + if (!utf8_strcasecmp (pc->name, name)) + return pc; + return NULL; +} + +static bool +ctables_parse_pcompute (struct lexer *lexer, struct dictionary *dict, + struct ctables *ct) +{ + int pcompute_start = lex_ofs (lexer) - 1; + + if (!lex_force_match (lexer, T_AND) || !lex_force_id (lexer)) + return false; + + char *name = ss_xstrdup (lex_tokss (lexer)); + + lex_get (lexer); + if (!lex_force_match (lexer, T_EQUALS) + || !lex_force_match_id (lexer, "EXPR") + || !lex_force_match (lexer, T_LPAREN)) + { + free (name); + return false; + } + + int expr_start = lex_ofs (lexer); + struct ctables_pcexpr *expr = ctable_pcexpr_parse_add (lexer, dict); + int expr_end = lex_ofs (lexer) - 1; + if (!expr || !lex_force_match (lexer, T_RPAREN)) + { + free (name); + return false; + } + int pcompute_end = lex_ofs (lexer) - 1; + + struct msg_location *location = lex_ofs_location (lexer, pcompute_start, + pcompute_end); + + struct ctables_postcompute *pc = ctables_find_postcompute (ct, name); + if (pc) + { + msg_at (SW, location, _("New definition of &%s will override the " + "previous definition."), + pc->name); + msg_at (SN, pc->location, _("This is the previous definition.")); + + ctables_pcexpr_destroy (pc->expr); + msg_location_destroy (pc->location); + free (name); + } + else + { + pc = xmalloc (sizeof *pc); + *pc = (struct ctables_postcompute) { .name = name }; + hmap_insert (&ct->postcomputes, &pc->hmap_node, + utf8_hash_case_string (pc->name, 0)); + } + pc->expr = expr; + pc->location = location; + if (!pc->label) + pc->label = lex_ofs_representation (lexer, expr_start, expr_end); + return true; +} + +static bool +ctables_parse_pproperties_format (struct lexer *lexer, + struct ctables_summary_spec_set *sss) +{ + *sss = (struct ctables_summary_spec_set) { .n = 0 }; + + while (lex_token (lexer) != T_ENDCMD && lex_token (lexer) != T_SLASH + && !(lex_token (lexer) == T_ID + && (lex_id_match (ss_cstr ("LABEL"), lex_tokss (lexer)) + || lex_id_match (ss_cstr ("HIDESOURCECATS"), + lex_tokss (lexer))))) + { + /* Parse function. */ + enum ctables_summary_function function; + if (!parse_ctables_summary_function (lexer, &function)) + goto error; + + /* Parse percentile. */ + double percentile = 0; + if (function == CTSF_PTILE) + { + if (!lex_force_num_range_closed (lexer, "PTILE", 0, 100)) + goto error; + percentile = lex_number (lexer); + lex_get (lexer); + } + + /* Parse format. */ + struct fmt_spec format; + bool is_ctables_format; + if (!parse_ctables_format_specifier (lexer, &format, &is_ctables_format)) + goto error; + + if (sss->n >= sss->allocated) + sss->specs = x2nrealloc (sss->specs, &sss->allocated, + sizeof *sss->specs); + sss->specs[sss->n++] = (struct ctables_summary_spec) { + .function = function, + .percentile = percentile, + .format = format, + .is_ctables_format = is_ctables_format, + }; + } + return true; + +error: + ctables_summary_spec_set_uninit (sss); + return false; +} + +static bool +ctables_parse_pproperties (struct lexer *lexer, struct ctables *ct) +{ + struct ctables_postcompute **pcs = NULL; + size_t n_pcs = 0; + size_t allocated_pcs = 0; + + while (lex_match (lexer, T_AND)) + { + if (!lex_force_id (lexer)) + goto error; + struct ctables_postcompute *pc + = ctables_find_postcompute (ct, lex_tokcstr (lexer)); + if (!pc) + { + msg (SE, _("Unknown computed category &%s."), lex_tokcstr (lexer)); + goto error; + } + lex_get (lexer); + + if (n_pcs >= allocated_pcs) + pcs = x2nrealloc (pcs, &allocated_pcs, sizeof *pcs); + pcs[n_pcs++] = pc; + } + + while (lex_token (lexer) != T_SLASH && lex_token (lexer) != T_ENDCMD) + { + if (lex_match_id (lexer, "LABEL")) + { + lex_match (lexer, T_EQUALS); + if (!lex_force_string (lexer)) + goto error; + + for (size_t i = 0; i < n_pcs; i++) + { + free (pcs[i]->label); + pcs[i]->label = ss_xstrdup (lex_tokss (lexer)); + } + + lex_get (lexer); + } + else if (lex_match_id (lexer, "FORMAT")) + { + lex_match (lexer, T_EQUALS); + + struct ctables_summary_spec_set sss; + if (!ctables_parse_pproperties_format (lexer, &sss)) + goto error; + + for (size_t i = 0; i < n_pcs; i++) + { + if (pcs[i]->specs) + ctables_summary_spec_set_uninit (pcs[i]->specs); + else + pcs[i]->specs = xmalloc (sizeof *pcs[i]->specs); + ctables_summary_spec_set_clone (pcs[i]->specs, &sss); + } + ctables_summary_spec_set_uninit (&sss); + } + else if (lex_match_id (lexer, "HIDESOURCECATS")) + { + lex_match (lexer, T_EQUALS); + bool hide_source_cats; + if (!parse_bool (lexer, &hide_source_cats)) + goto error; + for (size_t i = 0; i < n_pcs; i++) + pcs[i]->hide_source_cats = hide_source_cats; + } + else + { + lex_error_expecting (lexer, "LABEL", "FORMAT", "HIDESOURCECATS"); + goto error; + } + } + free (pcs); + return true; + +error: + free (pcs); + return false; +} + +static void +put_strftime (struct string *out, time_t now, const char *format) +{ + const struct tm *tm = localtime (&now); + char value[128]; + strftime (value, sizeof value, format, tm); + ds_put_cstr (out, value); +} + +static bool +skip_prefix (struct substring *s, struct substring prefix) +{ + if (ss_starts_with (*s, prefix)) + { + ss_advance (s, prefix.length); + return true; + } + else + return false; +} + +static void +put_table_expression (struct string *out, struct lexer *lexer, + struct dictionary *dict, int expr_start, int expr_end) +{ + size_t nest = 0; + for (int ofs = expr_start; ofs < expr_end; ofs++) + { + const struct token *t = lex_ofs_token (lexer, ofs); + if (t->type == T_LBRACK) + nest++; + else if (t->type == T_RBRACK && nest > 0) + nest--; + else if (nest > 0) + { + /* Nothing. */ + } + else if (t->type == T_ID) + { + const struct variable *var + = dict_lookup_var (dict, t->string.string); + const char *label = var ? var_get_label (var) : NULL; + ds_put_cstr (out, label ? label : t->string.string); + } + else + { + if (ofs != expr_start && t->type != T_RPAREN && ds_last (out) != ' ') + ds_put_byte (out, ' '); + + char *repr = lex_ofs_representation (lexer, ofs, ofs); + ds_put_cstr (out, repr); + free (repr); + + if (ofs + 1 != expr_end && t->type != T_LPAREN) + ds_put_byte (out, ' '); + } + } +} + +static void +put_title_text (struct string *out, struct substring in, time_t now, + struct lexer *lexer, struct dictionary *dict, + int expr_start, int expr_end) +{ + for (;;) + { + size_t chunk = ss_find_byte (in, ')'); + ds_put_substring (out, ss_head (in, chunk)); + ss_advance (&in, chunk); + if (ss_is_empty (in)) + return; + + if (skip_prefix (&in, ss_cstr (")DATE"))) + put_strftime (out, now, "%x"); + else if (skip_prefix (&in, ss_cstr (")TIME"))) + put_strftime (out, now, "%X"); + else if (skip_prefix (&in, ss_cstr (")TABLE"))) + put_table_expression (out, lexer, dict, expr_start, expr_end); + else + { + ds_put_byte (out, ')'); + ss_advance (&in, 1); + } + } +} + +int +cmd_ctables (struct lexer *lexer, struct dataset *ds) +{ + size_t n_vars = dict_get_n_vars (dataset_dict (ds)); + enum ctables_vlabel *vlabels = xnmalloc (n_vars, sizeof *vlabels); + enum settings_value_show tvars = settings_get_show_variables (); + for (size_t i = 0; i < n_vars; i++) + vlabels[i] = (enum ctables_vlabel) tvars; + + struct pivot_table_look *look = pivot_table_look_unshare ( + pivot_table_look_ref (pivot_table_look_get_default ())); + look->omit_empty = false; + + struct ctables *ct = xmalloc (sizeof *ct); + *ct = (struct ctables) { + .dict = dataset_dict (ds), + .look = look, + .ctables_formats = FMT_SETTINGS_INIT, + .vlabels = vlabels, + .postcomputes = HMAP_INITIALIZER (ct->postcomputes), + }; + + time_t now = time (NULL); + + struct ctf + { + enum fmt_type type; + const char *dot_string; + const char *comma_string; + }; + static const struct ctf ctfs[4] = { + { CTEF_NEGPAREN, "(,,,)", "(...)" }, + { CTEF_NEQUAL, "-,N=,,", "-.N=.." }, + { CTEF_PAREN, "-,(,),", "-.(.)." }, + { CTEF_PCTPAREN, "-,(,%),", "-.(.%)." }, + }; + bool is_dot = settings_get_fmt_settings ()->decimal == '.'; + for (size_t i = 0; i < 4; i++) + { + const char *s = is_dot ? ctfs[i].dot_string : ctfs[i].comma_string; + fmt_settings_set_cc (&ct->ctables_formats, ctfs[i].type, + fmt_number_style_from_string (s)); + } + + if (!lex_force_match (lexer, T_SLASH)) + goto error; + + while (!lex_match_id (lexer, "TABLE")) + { + if (lex_match_id (lexer, "FORMAT")) + { + double widths[2] = { SYSMIS, SYSMIS }; + double units_per_inch = 72.0; + + while (lex_token (lexer) != T_SLASH) + { + if (lex_match_id (lexer, "MINCOLWIDTH")) + { + if (!parse_col_width (lexer, "MINCOLWIDTH", &widths[0])) + goto error; + } + else if (lex_match_id (lexer, "MAXCOLWIDTH")) + { + if (!parse_col_width (lexer, "MAXCOLWIDTH", &widths[1])) + goto error; + } + else if (lex_match_id (lexer, "UNITS")) + { + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "POINTS")) + units_per_inch = 72.0; + else if (lex_match_id (lexer, "INCHES")) + units_per_inch = 1.0; + else if (lex_match_id (lexer, "CM")) + units_per_inch = 2.54; + else + { + lex_error_expecting (lexer, "POINTS", "INCHES", "CM"); + goto error; + } + } + else if (lex_match_id (lexer, "EMPTY")) + { + free (ct->zero); + ct->zero = NULL; + + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "ZERO")) + { + /* Nothing to do. */ + } + else if (lex_match_id (lexer, "BLANK")) + ct->zero = xstrdup (""); + else if (lex_force_string (lexer)) + { + ct->zero = ss_xstrdup (lex_tokss (lexer)); + lex_get (lexer); + } + else + goto error; + } + else if (lex_match_id (lexer, "MISSING")) + { + lex_match (lexer, T_EQUALS); + if (!lex_force_string (lexer)) + goto error; + + free (ct->missing); + ct->missing = (strcmp (lex_tokcstr (lexer), ".") + ? ss_xstrdup (lex_tokss (lexer)) + : NULL); + lex_get (lexer); + } + else + { + lex_error_expecting (lexer, "MINCOLWIDTH", "MAXCOLWIDTH", + "UNITS", "EMPTY", "MISSING"); + goto error; + } + } + + if (widths[0] != SYSMIS && widths[1] != SYSMIS + && widths[0] > widths[1]) + { + msg (SE, _("MINCOLWIDTH must not be greater than MAXCOLWIDTH.")); + goto error; + } + + for (size_t i = 0; i < 2; i++) + if (widths[i] != SYSMIS) + { + int *wr = ct->look->width_ranges[TABLE_HORZ]; + wr[i] = widths[i] / units_per_inch * 96.0; + if (wr[0] > wr[1]) + wr[!i] = wr[i]; + } + } + else if (lex_match_id (lexer, "VLABELS")) + { + if (!lex_force_match_id (lexer, "VARIABLES")) + goto error; + lex_match (lexer, T_EQUALS); + + struct variable **vars; + size_t n_vars; + if (!parse_variables (lexer, dataset_dict (ds), &vars, &n_vars, + PV_NO_SCRATCH)) + goto error; + + if (!lex_force_match_id (lexer, "DISPLAY")) + { + free (vars); + goto error; + } + lex_match (lexer, T_EQUALS); + + enum ctables_vlabel vlabel; + if (lex_match_id (lexer, "DEFAULT")) + vlabel = (enum ctables_vlabel) settings_get_show_variables (); + else if (lex_match_id (lexer, "NAME")) + vlabel = CTVL_NAME; + else if (lex_match_id (lexer, "LABEL")) + vlabel = CTVL_LABEL; + else if (lex_match_id (lexer, "BOTH")) + vlabel = CTVL_BOTH; + else if (lex_match_id (lexer, "NONE")) + vlabel = CTVL_NONE; + else + { + lex_error_expecting (lexer, "DEFAULT", "NAME", "LABEL", + "BOTH", "NONE"); + free (vars); + goto error; + } + + for (size_t i = 0; i < n_vars; i++) + ct->vlabels[var_get_dict_index (vars[i])] = vlabel; + free (vars); + } + else if (lex_match_id (lexer, "MRSETS")) + { + if (!lex_force_match_id (lexer, "COUNTDUPLICATES")) + goto error; + lex_match (lexer, T_EQUALS); + if (!parse_bool (lexer, &ct->mrsets_count_duplicates)) + goto error; + } + else if (lex_match_id (lexer, "SMISSING")) + { + if (lex_match_id (lexer, "VARIABLE")) + ct->smissing_listwise = false; + else if (lex_match_id (lexer, "LISTWISE")) + ct->smissing_listwise = true; + else + { + lex_error_expecting (lexer, "VARIABLE", "LISTWISE"); + goto error; + } + } + else if (lex_match_id (lexer, "PCOMPUTE")) + { + if (!ctables_parse_pcompute (lexer, dataset_dict (ds), 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->e_weight = parse_variable (lexer, dataset_dict (ds)); + if (!ct->e_weight) + goto error; + } + else if (lex_match_id (lexer, " HIDESMALLCOUNTS")) + { + if (lex_match_id (lexer, "COUNT")) + { + lex_match (lexer, T_EQUALS); + if (!lex_force_int_range (lexer, "HIDESMALLCOUNTS COUNT", + 2, INT_MAX)) + goto error; + ct->hide_threshold = lex_integer (lexer); + lex_get (lexer); + } + else if (ct->hide_threshold == 0) + ct->hide_threshold = 5; + } + else + { + lex_error_expecting (lexer, "FORMAT", "VLABELS", "MRSETS", + "SMISSING", "PCOMPUTE", "PPROPERTIES", + "WEIGHT", "HIDESMALLCOUNTS", "TABLE"); + goto error; + } + + if (!lex_force_match (lexer, T_SLASH)) + goto error; + } + + size_t allocated_tables = 0; + do + { + if (ct->n_tables >= allocated_tables) + ct->tables = x2nrealloc (ct->tables, &allocated_tables, + sizeof *ct->tables); + + struct ctables_category *cat = xmalloc (sizeof *cat); + *cat = (struct ctables_category) { + .type = CCT_VALUE, + .include_missing = false, + .sort_ascending = true, + }; + + struct ctables_categories *c = xmalloc (sizeof *c); + size_t n_vars = dict_get_n_vars (dataset_dict (ds)); + *c = (struct ctables_categories) { + .n_refs = n_vars, + .cats = cat, + .n_cats = 1, + .show_empty = true, + }; + + struct ctables_categories **categories = xnmalloc (n_vars, + sizeof *categories); + for (size_t i = 0; i < n_vars; i++) + categories[i] = c; + + struct ctables_table *t = xmalloc (sizeof *t); + *t = (struct ctables_table) { + .ctables = ct, + .slabels_axis = PIVOT_AXIS_COLUMN, + .slabels_visible = true, + .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, + }; + ct->tables[ct->n_tables++] = t; + + lex_match (lexer, T_EQUALS); + int expr_start = lex_ofs (lexer); + if (!ctables_axis_parse (lexer, dataset_dict (ds), ct, t, PIVOT_AXIS_ROW)) + goto error; + if (lex_match (lexer, T_BY)) + { + if (!ctables_axis_parse (lexer, dataset_dict (ds), + ct, t, PIVOT_AXIS_COLUMN)) + goto error; + + if (lex_match (lexer, T_BY)) + { + if (!ctables_axis_parse (lexer, dataset_dict (ds), + ct, t, PIVOT_AXIS_LAYER)) + goto error; + } + } + int expr_end = lex_ofs (lexer); + + if (!t->axes[PIVOT_AXIS_ROW] && !t->axes[PIVOT_AXIS_COLUMN] + && !t->axes[PIVOT_AXIS_LAYER]) + { + lex_error (lexer, _("At least one variable must be specified.")); + goto error; + } + + const struct ctables_axis *scales[PIVOT_N_AXES]; + size_t n_scales = 0; + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + { + scales[a] = find_scale (t->axes[a]); + if (scales[a]) + n_scales++; + } + if (n_scales > 1) + { + msg (SE, _("Scale variables may appear only on one axis.")); + if (scales[PIVOT_AXIS_ROW]) + msg_at (SN, scales[PIVOT_AXIS_ROW]->loc, + _("This scale variable appears on the rows axis.")); + if (scales[PIVOT_AXIS_COLUMN]) + msg_at (SN, scales[PIVOT_AXIS_COLUMN]->loc, + _("This scale variable appears on the columns axis.")); + if (scales[PIVOT_AXIS_LAYER]) + msg_at (SN, scales[PIVOT_AXIS_LAYER]->loc, + _("This scale variable appears on the layer axis.")); + goto error; + } + + const struct ctables_axis *summaries[PIVOT_N_AXES]; + size_t n_summaries = 0; + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + { + summaries[a] = (scales[a] + ? scales[a] + : find_categorical_summary_spec (t->axes[a])); + if (summaries[a]) + n_summaries++; + } + if (n_summaries > 1) + { + msg (SE, _("Summaries may appear only on one axis.")); + if (summaries[PIVOT_AXIS_ROW]) + msg_at (SN, summaries[PIVOT_AXIS_ROW]->loc, + _("This variable on the rows axis has a summary.")); + if (summaries[PIVOT_AXIS_COLUMN]) + msg_at (SN, summaries[PIVOT_AXIS_COLUMN]->loc, + _("This variable on the columns axis has a summary.")); + if (summaries[PIVOT_AXIS_LAYER]) + msg_at (SN, summaries[PIVOT_AXIS_LAYER]->loc, + _("This variable on the layers axis has a summary.")); + goto error; + } + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + if (n_summaries ? summaries[a] : t->axes[a]) + { + t->summary_axis = a; + break; + } + + if (lex_token (lexer) == T_ENDCMD) + { + if (!ctables_prepare_table (t)) + goto error; + break; + } + if (!lex_force_match (lexer, T_SLASH)) + break; + + while (!lex_match_id (lexer, "TABLE") && lex_token (lexer) != T_ENDCMD) + { + if (lex_match_id (lexer, "SLABELS")) + { + 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_axis = PIVOT_AXIS_COLUMN; + else if (lex_match_id (lexer, "ROW")) + t->slabels_axis = PIVOT_AXIS_ROW; + else if (lex_match_id (lexer, "LAYER")) + t->slabels_axis = PIVOT_AXIS_LAYER; + else + { + lex_error_expecting (lexer, "COLUMN", "ROW", "LAYER"); + goto error; + } + } + else if (lex_match_id (lexer, "VISIBLE")) + { + lex_match (lexer, T_EQUALS); + if (!parse_bool (lexer, &t->slabels_visible)) + goto error; + } + else + { + lex_error_expecting (lexer, "POSITION", "VISIBLE"); + goto error; + } + } + } + else if (lex_match_id (lexer, "CLABELS")) + { + while (lex_token (lexer) != T_SLASH && lex_token (lexer) != T_ENDCMD) + { + if (lex_match_id (lexer, "AUTO")) + { + 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->label_axis[PIVOT_AXIS_ROW] = PIVOT_AXIS_COLUMN; + else if (lex_match_id (lexer, "LAYER")) + t->label_axis[PIVOT_AXIS_ROW] = PIVOT_AXIS_LAYER; + else + { + lex_error_expecting (lexer, "OPPOSITE", "LAYER"); + goto error; + } + } + else if (lex_match_id (lexer, "COLLABELS")) + { + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "OPPOSITE")) + t->label_axis[PIVOT_AXIS_COLUMN] = PIVOT_AXIS_ROW; + else if (lex_match_id (lexer, "LAYER")) + t->label_axis[PIVOT_AXIS_COLUMN] = PIVOT_AXIS_LAYER; + else + { + lex_error_expecting (lexer, "OPPOSITE", "LAYER"); + goto error; + } + } + else + { + lex_error_expecting (lexer, "AUTO", "ROWLABELS", + "COLLABELS"); + goto error; + } + } + } + else if (lex_match_id (lexer, "CRITERIA")) + { + if (!lex_force_match_id (lexer, "CILEVEL")) + goto error; + lex_match (lexer, T_EQUALS); + + if (!lex_force_num_range_halfopen (lexer, "CILEVEL", 0, 100)) + goto error; + t->cilevel = lex_number (lexer); + lex_get (lexer); + } + else if (lex_match_id (lexer, "CATEGORIES")) + { + if (!ctables_table_parse_categories (lexer, dataset_dict (ds), + ct, t)) + goto error; + } + else if (lex_match_id (lexer, "TITLES")) + { + do + { + char **textp; + if (lex_match_id (lexer, "CAPTION")) + textp = &t->caption; + else if (lex_match_id (lexer, "CORNER")) + textp = &t->corner; + else if (lex_match_id (lexer, "TITLE")) + textp = &t->title; + else + { + lex_error_expecting (lexer, "CAPTION", "CORNER", "TITLE"); + goto error; + } + lex_match (lexer, T_EQUALS); + + struct string s = DS_EMPTY_INITIALIZER; + while (lex_is_string (lexer)) + { + if (!ds_is_empty (&s)) + ds_put_byte (&s, ' '); + put_title_text (&s, lex_tokss (lexer), now, + lexer, dataset_dict (ds), + expr_start, expr_end); + lex_get (lexer); + } + free (*textp); + *textp = ds_steal_cstr (&s); + } + while (lex_token (lexer) != T_SLASH + && lex_token (lexer) != T_ENDCMD); + } + else if (lex_match_id (lexer, "SIGTEST")) + { + if (!t->chisq) + { + t->chisq = xmalloc (sizeof *t->chisq); + *t->chisq = (struct ctables_chisq) { + .alpha = .05, + .include_mrsets = true, + .all_visible = true, + }; + } + + do + { + if (lex_match_id (lexer, "TYPE")) + { + lex_match (lexer, T_EQUALS); + if (!lex_force_match_id (lexer, "CHISQUARE")) + goto error; + } + else if (lex_match_id (lexer, "ALPHA")) + { + lex_match (lexer, T_EQUALS); + if (!lex_force_num_range_halfopen (lexer, "ALPHA", 0, 1)) + goto error; + t->chisq->alpha = lex_number (lexer); + lex_get (lexer); + } + else if (lex_match_id (lexer, "INCLUDEMRSETS")) + { + lex_match (lexer, T_EQUALS); + if (parse_bool (lexer, &t->chisq->include_mrsets)) + goto error; + } + else if (lex_match_id (lexer, "CATEGORIES")) + { + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "ALLVISIBLE")) + t->chisq->all_visible = true; + else if (lex_match_id (lexer, "SUBTOTALS")) + t->chisq->all_visible = false; + else + { + lex_error_expecting (lexer, + "ALLVISIBLE", "SUBTOTALS"); + goto error; + } + } + else + { + lex_error_expecting (lexer, "TYPE", "ALPHA", + "INCLUDEMRSETS", "CATEGORIES"); + goto error; + } + } + while (lex_token (lexer) != T_SLASH + && lex_token (lexer) != T_ENDCMD); + } + else if (lex_match_id (lexer, "COMPARETEST")) + { + if (!t->pairwise) + { + t->pairwise = xmalloc (sizeof *t->pairwise); + *t->pairwise = (struct ctables_pairwise) { + .type = PROP, + .alpha = { .05, .05 }, + .adjust = BONFERRONI, + .include_mrsets = true, + .meansvariance_allcats = true, + .all_visible = true, + .merge = false, + .apa_style = true, + .show_sig = false, + }; + } + + do + { + if (lex_match_id (lexer, "TYPE")) + { + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "PROP")) + t->pairwise->type = PROP; + else if (lex_match_id (lexer, "MEAN")) + t->pairwise->type = MEAN; + else + { + lex_error_expecting (lexer, "PROP", "MEAN"); + goto error; + } + } + else if (lex_match_id (lexer, "ALPHA")) + { + lex_match (lexer, T_EQUALS); + + if (!lex_force_num_range_open (lexer, "ALPHA", 0, 1)) + goto error; + double a0 = lex_number (lexer); + lex_get (lexer); + + lex_match (lexer, T_COMMA); + if (lex_is_number (lexer)) + { + if (!lex_force_num_range_open (lexer, "ALPHA", 0, 1)) + goto error; + double a1 = lex_number (lexer); + lex_get (lexer); + + t->pairwise->alpha[0] = MIN (a0, a1); + t->pairwise->alpha[1] = MAX (a0, a1); + } + else + t->pairwise->alpha[0] = t->pairwise->alpha[1] = a0; + } + else if (lex_match_id (lexer, "ADJUST")) + { + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "BONFERRONI")) + t->pairwise->adjust = BONFERRONI; + else if (lex_match_id (lexer, "BH")) + t->pairwise->adjust = BH; + else if (lex_match_id (lexer, "NONE")) + t->pairwise->adjust = 0; + else + { + lex_error_expecting (lexer, "BONFERRONI", "BH", + "NONE"); + goto error; + } + } + else if (lex_match_id (lexer, "INCLUDEMRSETS")) + { + lex_match (lexer, T_EQUALS); + if (!parse_bool (lexer, &t->pairwise->include_mrsets)) + goto error; + } + else if (lex_match_id (lexer, "MEANSVARIANCE")) + { + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "ALLCATS")) + t->pairwise->meansvariance_allcats = true; + else if (lex_match_id (lexer, "TESTEDCATS")) + t->pairwise->meansvariance_allcats = false; + else + { + lex_error_expecting (lexer, "ALLCATS", "TESTEDCATS"); + goto error; + } + } + else if (lex_match_id (lexer, "CATEGORIES")) + { + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "ALLVISIBLE")) + t->pairwise->all_visible = true; + else if (lex_match_id (lexer, "SUBTOTALS")) + t->pairwise->all_visible = false; + else + { + lex_error_expecting (lexer, "ALLVISIBLE", + "SUBTOTALS"); + goto error; + } + } + else if (lex_match_id (lexer, "MERGE")) + { + lex_match (lexer, T_EQUALS); + if (!parse_bool (lexer, &t->pairwise->merge)) + goto error; + } + else if (lex_match_id (lexer, "STYLE")) + { + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "APA")) + t->pairwise->apa_style = true; + else if (lex_match_id (lexer, "SIMPLE")) + t->pairwise->apa_style = false; + else + { + lex_error_expecting (lexer, "APA", "SIMPLE"); + goto error; + } + } + else if (lex_match_id (lexer, "SHOWSIG")) + { + lex_match (lexer, T_EQUALS); + if (!parse_bool (lexer, &t->pairwise->show_sig)) + goto error; + } + else + { + lex_error_expecting (lexer, "TYPE", "ALPHA", "ADJUST", + "INCLUDEMRSETS", "MEANSVARIANCE", + "CATEGORIES", "MERGE", "STYLE", + "SHOWSIG"); + goto error; + } + } + while (lex_token (lexer) != T_SLASH + && lex_token (lexer) != T_ENDCMD); + } + else + { + lex_error_expecting (lexer, "TABLE", "SLABELS", "CLABELS", + "CRITERIA", "CATEGORIES", "TITLES", + "SIGTEST", "COMPARETEST"); + goto error; + } + + if (!lex_match (lexer, T_SLASH)) + break; + } + + 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); + + bool ok = ctables_execute (ds, ct); + ctables_destroy (ct); + return ok ? CMD_SUCCESS : CMD_FAILURE; + +error: + ctables_destroy (ct); + return CMD_FAILURE; +} +