#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"
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_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) \
double e_valid; /* Effective weight */
double e_count;
double e_total;
+ double u_valid; /* Unweighted. */
+ double u_count;
+ double u_total;
};
enum ctables_summary_variant
CTPO_CONSTANT, /* 5 */
CTPO_CAT_NUMBER, /* [5] */
CTPO_CAT_STRING, /* ["STRING"] */
- CTPO_CAT_RANGE, /* [LO THRU 5] */
+ 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_STRING, in dictionary encoding. */
struct substring string;
- /* CTPO_CAT_RANGE. */
- double range[2];
+ /* CTPO_CAT_NRANGE. */
+ double nrange[2];
+
+ /* CTPO_CAT_SRANGE. */
+ struct substring srange[2];
/* CTPO_CAT_SUBTOTAL. */
size_t subtotal_index;
/* Explicit category lists. */
CCT_NUMBER,
CCT_STRING,
- CCT_RANGE,
+ CCT_NRANGE, /* Numerical range. */
+ CCT_SRANGE, /* String range. */
CCT_MISSING,
CCT_OTHERNM,
CCT_POSTCOMPUTE,
union
{
- double number; /* CCT_NUMBER. */
+ double number; /* CCT_NUMBER. */
struct substring string; /* CCT_STRING, in dictionary encoding. */
- double range[2]; /* CCT_RANGE. */
+ double nrange[2]; /* CCT_NRANGE. */
+ struct substring srange[2]; /* CCT_SRANGE. */
struct
{
switch (cat->type)
{
case CCT_NUMBER:
- case CCT_RANGE:
+ case CCT_NRANGE:
case CCT_MISSING:
case CCT_OTHERNM:
case CCT_POSTCOMPUTE:
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);
}
}
+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)
case CCT_STRING:
return ss_equals (a->string, b->string);
- case CCT_RANGE:
- return a->range[0] == b->range[0] && a->range[1] == b->range[1];
+ 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:
const struct ctables_summary_spec *src)
{
*dst = *src;
- dst->label = xstrdup (src->label);
+ dst->label = xstrdup_if_nonnull (src->label);
}
static void
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_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 struct ctables_category
-cct_range (double low, double high)
+cct_nrange (double low, double high)
{
return (struct ctables_category) {
- .type = CCT_RANGE,
- .range = { low, high }
+ .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 }
};
}
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,
return ctables_table_parse_subtotal (lexer, true, cat);
else if (lex_match_id (lexer, "LO"))
{
- if (!lex_force_match_id (lexer, "THRU") || lex_force_num (lexer))
+ 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;
- *cat = cct_range (-DBL_MAX, lex_number (lexer));
- lex_get (lexer);
}
else if (lex_is_number (lexer))
{
if (lex_match_id (lexer, "THRU"))
{
if (lex_match_id (lexer, "HI"))
- *cat = cct_range (number, DBL_MAX);
+ *cat = cct_nrange (number, DBL_MAX);
else
{
if (!lex_force_num (lexer))
return false;
- *cat = cct_range (number, lex_number (lexer));
+ *cat = cct_nrange (number, lex_number (lexer));
lex_get (lexer);
}
}
}
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 (" "));
-
- *cat = (struct ctables_category) { .type = CCT_STRING, .string = s };
- lex_get (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))
{
best = cat;
break;
- case CTPO_CAT_RANGE:
- if (cat->type == CCT_RANGE
- && cat->range[0] == e->range[0]
- && cat->range[1] == e->range[1])
+ 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_NUMBER:
case CTPO_CAT_STRING:
- case CTPO_CAT_RANGE:
+ case CTPO_CAT_NRANGE:
case CTPO_CAT_MISSING:
case CTPO_CAT_OTHERNM:
case CTPO_CAT_SUBTOTAL:
}
}
+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)
break;
case CCT_NUMBER:
- case CCT_RANGE:
+ case CCT_NRANGE:
for (size_t j = 0; j < n_vars; j++)
if (var_is_alpha (vars[j]))
{
case CCT_STRING:
if (parse_strings)
{
- union value v;
- char *error = data_in (cat->string, dict_get_encoding (dict),
- common_format->type,
- 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 (common_format->type), error);
- free (error);
- return false;
- }
+ 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 = v.f;
+ cat->number = n;
}
- else
+ else if (!all_strings (vars, n_vars, cat))
+ return false;
+ break;
+
+ case CCT_SRANGE:
+ if (parse_strings)
{
- 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;
- }
+ 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_NUMBER:
case CCT_STRING:
- case CCT_RANGE:
+ case CCT_NRANGE:
+ case CCT_SRANGE:
case CCT_MISSING:
case CCT_OTHERNM:
cat->subtotal = subtotal;
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_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);
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_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;
}
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:
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:
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;
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:
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;
}
{
case CTSF_COUNT:
case CTSF_ECOUNT:
+ case CTSF_UCOUNT:
return s->count;
case CTSF_ROWPCT_COUNT:
: 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:
: 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:
: SYSMIS);
}
- case CTSF_MISSING:
- return s->count;
+ 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:
- return s->count;
-
+ case CSTF_UTOTALN:
case CTSF_VALIDN:
- return s->count;
-
+ case CTSF_UVALIDN:
case CTSF_EVALIDN:
return s->count;
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);
}
case CTSF_SEMEAN:
+ case CTSF_USEMEAN:
{
double weight, variance;
moments1_calculate (s->moments, &weight, NULL, &variance, NULL, NULL);
}
case CTSF_STDDEV:
+ case CTSF_USTDDEV:
{
double variance;
moments1_calculate (s->moments, NULL, NULL, &variance, NULL, NULL);
}
case CTSF_SUM:
+ case CTSF_USUM:
{
double weight, mean;
moments1_calculate (s->moments, &weight, &mean, NULL, NULL, NULL);
}
case CTSF_VARIANCE:
+ case CTSF_UVARIANCE:
{
double variance;
moments1_calculate (s->moments, NULL, NULL, &variance, NULL, NULL);
case CTSF_LAYERPCT_SUM:
case CTSF_LAYERROWPCT_SUM:
case CTSF_LAYERCOLPCT_SUM:
+ 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:
NOT_REACHED ();
case CTSF_MEDIAN:
case CTSF_PTILE:
+ case CTSF_UMEDIAN:
+ case CTSF_UPTILE:
if (s->writer)
{
struct casereader *reader = casewriter_make_reader (s->writer);
return s->ovalue;
case CTSF_MODE:
+ case CTSF_UMODE:
if (s->writer)
{
struct casereader *reader = casewriter_make_reader (s->writer);
/* Must be equal. */
continue;
- case CCT_RANGE:
+ case CCT_NRANGE:
+ case CCT_SRANGE:
case CCT_MISSING:
case CCT_OTHERNM:
{
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)
break;
case CCT_STRING:
- {
- struct substring s = ss_buffer (CHAR_CAST (char *, v->s),
- var_get_width (var));
- ss_rtrim (&s, ss_cstr (" "));
- printf ("%d '%.*s' ?=? '%.*s'\n",
- var_get_width (var),
- (int) cat->string.length, cat->string.string,
- (int) s.length, s.string);
- if (ss_equals (cat->string, s))
- return cat;
- }
+ 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_RANGE:
- if ((cat->range[0] == -DBL_MAX || v->f >= cat->range[0])
- && (cat->range[1] == DBL_MAX || v->f <= cat->range[1]))
+ case CCT_SRANGE:
+ if (in_string_range (v, var, cat->srange))
return cat;
break;
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;
}
}
}
if (var_missing)
is_missing = true;
- printf ("ctables_cell_insert %s: ", var_get_name (var));
cats[a][i] = ctables_categories_match (
s->table->categories[var_get_dict_index (var)], value, var);
if (!cats[a][i])
}
static struct pivot_value *
-ctables_category_create_label (const struct ctables_category *cat,
- const struct variable *var,
- const union value *value)
+ctables_category_create_label__ (const struct ctables_category *cat,
+ const struct variable *var,
+ const union value *value)
{
return (cat->type == CCT_TOTAL || cat->type == CCT_SUBTOTAL
? pivot_value_new_user_text (cat->total_label, SIZE_MAX)
- : cat->type == CCT_POSTCOMPUTE && cat->pc->label
- ? pivot_value_new_user_text (cat->pc->label, SIZE_MAX)
: pivot_value_new_var_value (var, value));
}
+static struct 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)
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_table *t = s->table;
const struct ctables_nest *specs_nest = s->nests[t->summary_axis];
const struct ctables_summary_spec_set *specs = &specs_nest->specs[tc->sv];
- size_t j = 0 /* XXX */;
- return ctables_summary_value (tc, &tc->summaries[j], &specs->specs[j]);
+ return ctables_summary_value (tc, &tc->summaries[ctx->summary_idx],
+ &specs->specs[ctx->summary_idx]);
}
static double
case CTPO_CONSTANT:
return e->number;
- case CTPO_CAT_RANGE:
+ case CTPO_CAT_NRANGE:
+ case CTPO_CAT_SRANGE:
{
struct ctables_cell_value cv = {
.category = ctables_find_category_for_postcompute (ctx->cats, e)
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);
+ for (enum pivot_axis_type pc_a = 0; ; pc_a++)
+ {
+ assert (pc_a < PIVOT_N_AXES);
+ 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_a_p)
+ *pc_a_p = pc_a;
+ if (pc_a_idx_p)
+ *pc_a_idx_p = pc_a_idx;
+ return cv->category->pc;
+ }
+ }
+ }
+
+ NOT_REACHED ();
+}
+
static double
ctables_cell_calculate_postcompute (const struct ctables_section *s,
- const struct ctables_cell *cell)
+ 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;
size_t pc_a_idx;
- const struct ctables_postcompute *pc;
- for (pc_a = 0; ; pc_a++)
+ const struct ctables_postcompute *pc = ctables_cell_postcompute (
+ s, cell, &pc_a, &pc_a_idx);
+
+ if (pc->specs)
{
- assert (pc_a < PIVOT_N_AXES);
- for (pc_a_idx = 0; pc_a_idx < s->nests[pc_a]->n; pc_a_idx++)
+ for (size_t i = 0; i < pc->specs->n; i++)
{
- const struct ctables_cell_value *cv = &cell->axes[pc_a].cvs[pc_a_idx];
- if (cv->category->type == CCT_POSTCOMPUTE)
+ const struct ctables_summary_spec *ss2 = &pc->specs->specs[i];
+ if (ss->function == ss2->function
+ && ss->percentile == ss2->percentile)
{
- pc = cv->category->pc;
- goto found;
+ *format = ss2->format;
+ *is_ctables_format = ss2->is_ctables_format;
+ break;
}
}
}
-found: ;
const struct variable *var = s->nests[pc_a]->vars[pc_a_idx];
const struct ctables_categories *cats = s->table->categories[
.cats = cats,
.pc_a = pc_a,
.pc_a_idx = pc_a_idx,
+ .summary_idx = summary_idx,
};
return ctables_pcexpr_evaluate (&ctx, pc->expr);
}
pivot_table_set_caption (
pt, pivot_value_new_user_text (t->caption, SIZE_MAX));
if (t->corner)
- pivot_table_set_caption (
+ pivot_table_set_corner_text (
pt, pivot_value_new_user_text (t->corner, SIZE_MAX));
bool summary_dimension = (t->summary_axis != t->slabels_axis
const struct ctables_category *cat = ctables_categories_match (c, &value->value, var);
assert (cat != NULL);
pivot_category_create_leaf (d->root, ctables_category_create_label (
- cat, t->clabels_example, &value->value));
+ c, cat, t->clabels_example,
+ &value->value));
}
}
else if (level->type == CTL_CATEGORY)
{
const struct ctables_cell_value *cv = &cell->axes[a].cvs[level->var_idx];
- label = ctables_category_create_label (cv->category,
- var, &cv->value);
+ label = ctables_category_create_label (
+ t->categories[var_get_dict_index (var)],
+ cv->category, var, &cv->value);
}
else
NOT_REACHED ();
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)
- : ctables_summary_value (cell, &cell->summaries[j], ss));
+ ? 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
- && (cell->postcompute
- ? false /* XXX */
- : ctables_summary_function_is_count (ss->function)))
+ && ctables_summary_function_is_count (ss->function))
{
value = pivot_value_new_user_text_nocopy (
xasprintf ("<%d", ct->hide_threshold));
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 (specs->specs[j].is_ctables_format)
+ else if (is_ctables_format)
{
char *s = data_out_stretchy (&(union value) { .f = d },
- "UTF-8",
- &specs->specs[j].format,
+ "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 = specs->specs[j].format;
+ value->numeric.format = format;
}
pivot_table_put (pt, dindexes, n_dindexes, value);
}
}
break;
- case CCT_RANGE:
+ 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->range[0] && vl->value.f <= c->range[1])
+ 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;
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_CONSTANT:
case CTPO_CAT_NUMBER:
- case CTPO_CAT_RANGE:
+ case CTPO_CAT_NRANGE:
case CTPO_CAT_MISSING:
case CTPO_CAT_OTHERNM:
case CTPO_CAT_SUBTOTAL:
};
static const struct operator *
-match_operator (struct lexer *lexer, const struct operator ops[], size_t n_ops)
+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)
}
static struct ctables_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)
+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 = match_operator (lexer, ops, n_ops);
+ const struct operator *op
+ = ctable_pcexpr_match_operator (lexer, ops, n_ops);
if (!op)
{
if (op_count > 1 && chain_warning)
}
static struct ctables_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)
+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 parse_binary_operators__ (lexer, dict, ops, n_ops, parse_next_level,
- chain_warning, lhs);
+ return ctable_pcexpr_parse_binary_operators__ (lexer, dict, ops, n_ops,
+ parse_next_level,
+ chain_warning, lhs);
}
-static struct ctables_pcexpr *parse_add (struct lexer *, struct dictionary *);
+static struct ctables_pcexpr *ctable_pcexpr_parse_add (struct lexer *,
+ struct dictionary *);
static struct ctables_pcexpr
-ctpo_cat_range (double low, double high)
+ctpo_cat_nrange (double low, double high)
{
return (struct ctables_pcexpr) {
- .op = CTPO_CAT_RANGE,
- .range = { low, high },
+ .op = CTPO_CAT_NRANGE,
+ .nrange = { low, high },
};
}
static struct ctables_pcexpr *
-parse_primary (struct lexer *lexer, struct dictionary *dict)
+ctable_pcexpr_parse_primary (struct lexer *lexer, struct dictionary *dict)
{
int start_ofs = lex_ofs (lexer);
struct ctables_pcexpr e;
{
if (!lex_force_match_id (lexer, "THRU") || lex_force_num (lexer))
return false;
- e = ctpo_cat_range (-DBL_MAX, lex_number (lexer));
+ e = ctpo_cat_nrange (-DBL_MAX, lex_number (lexer));
lex_get (lexer);
}
else if (lex_is_number (lexer))
if (lex_match_id (lexer, "THRU"))
{
if (lex_match_id (lexer, "HI"))
- e = ctpo_cat_range (number, DBL_MAX);
+ e = ctpo_cat_nrange (number, DBL_MAX);
else
{
if (!lex_force_num (lexer))
return false;
- e = ctpo_cat_range (number, lex_number (lexer));
+ e = ctpo_cat_nrange (number, lex_number (lexer));
lex_get (lexer);
}
}
}
else if (lex_match (lexer, T_LPAREN))
{
- struct ctables_pcexpr *ep = parse_add (lexer, dict);
+ struct ctables_pcexpr *ep = ctable_pcexpr_parse_add (lexer, dict);
if (!ep)
return NULL;
if (!lex_force_match (lexer, T_RPAREN))
}
static struct ctables_pcexpr *
-parse_exp (struct lexer *lexer, struct dictionary *dict)
+ctable_pcexpr_parse_exp (struct lexer *lexer, struct dictionary *dict)
{
static const struct operator op = { T_EXP, CTPO_POW };
"To disable this warning, insert parentheses.");
if (lex_token (lexer) != T_NEG_NUM || lex_next_token (lexer, 1) != T_EXP)
- return parse_binary_operators (lexer, dict, &op, 1,
- parse_primary, chain_warning);
+ 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). */
};
lex_get (lexer);
- struct ctables_pcexpr *node = parse_binary_operators__ (
- lexer, dict, &op, 1, parse_primary, chain_warning, lhs);
+ struct ctables_pcexpr *node = ctable_pcexpr_parse_binary_operators__ (
+ lexer, dict, &op, 1,
+ ctable_pcexpr_parse_primary, chain_warning, lhs);
if (!node)
return NULL;
/* Parses the unary minus level. */
static struct ctables_pcexpr *
-parse_neg (struct lexer *lexer, struct dictionary *dict)
+ctable_pcexpr_parse_neg (struct lexer *lexer, struct dictionary *dict)
{
int start_ofs = lex_ofs (lexer);
if (!lex_match (lexer, T_DASH))
- return parse_exp (lexer, dict);
+ return ctable_pcexpr_parse_exp (lexer, dict);
- struct ctables_pcexpr *inner = parse_neg (lexer, dict);
+ struct ctables_pcexpr *inner = ctable_pcexpr_parse_neg (lexer, dict);
if (!inner)
return NULL;
/* Parses the multiplication and division level. */
static struct ctables_pcexpr *
-parse_mul (struct lexer *lexer, struct dictionary *dict)
+ctable_pcexpr_parse_mul (struct lexer *lexer, struct dictionary *dict)
{
static const struct operator ops[] =
{
{ T_SLASH, CTPO_DIV },
};
- return parse_binary_operators (lexer, dict, ops, sizeof ops / sizeof *ops,
- parse_neg, NULL);
+ 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 *
-parse_add (struct lexer *lexer, struct dictionary *dict)
+ctable_pcexpr_parse_add (struct lexer *lexer, struct dictionary *dict)
{
static const struct operator ops[] =
{
{ T_NEG_NUM, CTPO_ADD },
};
- return parse_binary_operators (lexer, dict, ops, sizeof ops / sizeof *ops,
- parse_mul, NULL);
+ return ctable_pcexpr_parse_binary_operators (lexer, dict,
+ ops, sizeof ops / sizeof *ops,
+ ctable_pcexpr_parse_mul, NULL);
}
static struct ctables_postcompute *
}
int expr_start = lex_ofs (lexer);
- struct ctables_pcexpr *expr = parse_add (lexer, dict);
+ 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))
{
/* Parse format. */
struct fmt_spec format;
- if (!parse_format_specifier (lexer, &format)
- || !fmt_check_output (&format)
- || !fmt_check_type_compat (&format, VAL_NUMERIC))
+ bool is_ctables_format;
+ if (!parse_ctables_format_specifier (lexer, &format, &is_ctables_format))
goto error;
if (sss->n >= sss->allocated)
.function = function,
.percentile = percentile,
.format = format,
+ .is_ctables_format = is_ctables_format,
};
}
return true;
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)
{
.postcomputes = HMAP_INITIALIZER (ct->postcomputes),
};
+ time_t now = time (NULL);
+
struct ctf
{
enum fmt_type type;
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))
goto error;
}
}
+ int expr_end = lex_ofs (lexer);
if (!t->axes[PIVOT_AXIS_ROW] && !t->axes[PIVOT_AXIS_COLUMN]
&& !t->axes[PIVOT_AXIS_LAYER])
{
if (!ds_is_empty (&s))
ds_put_byte (&s, ' ');
- ds_put_substring (&s, lex_tokss (lexer));
+ put_title_text (&s, lex_tokss (lexer), now,
+ lexer, dataset_dict (ds),
+ expr_start, expr_end);
lex_get (lexer);
}
free (*textp);
projects / pspp / blobdiff