/* Totals and subtotals. */
CCT_SUBTOTAL,
- CCT_HSUBTOTAL,
CCT_TOTAL,
/* Implicit category lists. */
struct ctables_category *subtotal;
+ bool hide;
+
union
{
double number; /* CCT_NUMBER. */
char *string; /* CCT_STRING. */
double range[2]; /* CCT_RANGE. */
- char *total_label; /* CCT_SUBTOTAL, CCT_HSUBTOTAL, CCT_TOTAL. */
+
+ struct
+ {
+ char *total_label; /* CCT_SUBTOTAL, CCT_TOTAL. */
+ bool hide_subcategories; /* CCT_SUBTOTAL. */
+ };
+
const struct ctables_postcompute *pc; /* CCT_POSTCOMPUTE. */
/* CCT_VALUE, CCT_LABEL, CCT_FUNCTION. */
break;
case CCT_SUBTOTAL:
- case CCT_HSUBTOTAL:
case CCT_TOTAL:
free (cat->total_label);
break;
return a->pc == b->pc;
case CCT_SUBTOTAL:
- case CCT_HSUBTOTAL:
case CCT_TOTAL:
return !strcmp (a->total_label, b->total_label);
}
static bool
-ctables_table_parse_subtotal (struct lexer *lexer,
- enum ctables_category_type cct,
+ctables_table_parse_subtotal (struct lexer *lexer, bool hide_subcategories,
struct ctables_category *cat)
{
char *total_label;
else
total_label = xstrdup (_("Subtotal"));
- *cat = (struct ctables_category) { .type = cct, .total_label = total_label };
+ *cat = (struct ctables_category) {
+ .type = CCT_SUBTOTAL,
+ .hide_subcategories = hide_subcategories,
+ .total_label = total_label
+ };
return true;
}
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, CCT_SUBTOTAL, cat);
+ return ctables_table_parse_subtotal (lexer, false, cat);
else if (lex_match_id (lexer, "HSUBTOTAL"))
- return ctables_table_parse_subtotal (lexer, CCT_HSUBTOTAL, cat);
+ return ctables_table_parse_subtotal (lexer, true, cat);
else if (lex_match_id (lexer, "LO"))
{
if (!lex_force_match_id (lexer, "THRU") || lex_force_num (lexer))
return true;
}
-static const struct ctables_category *
+static struct ctables_category *
ctables_find_category_for_postcompute (const struct ctables_categories *cats,
const struct ctables_pcexpr *e)
{
- const struct ctables_category *best = NULL;
+ struct ctables_category *best = NULL;
size_t n_subtotals = 0;
for (size_t i = 0; i < cats->n_cats; i++)
{
- const struct ctables_category *cat = &cats->cats[i];
+ struct ctables_category *cat = &cats->cats[i];
switch (e->op)
{
case CTPO_CAT_NUMBER:
break;
case CTPO_CAT_SUBTOTAL:
- if (cat->type == CCT_SUBTOTAL || cat->type == CCT_HSUBTOTAL)
+ if (cat->type == CCT_SUBTOTAL)
{
n_subtotals++;
if (e->subtotal_index == n_subtotals)
static bool
ctables_recursive_check_postcompute (const struct ctables_pcexpr *e,
- const struct ctables_category *cat,
+ struct ctables_category *pc_cat,
const struct ctables_categories *cats,
const struct msg_location *cats_location)
{
case CTPO_CAT_OTHERNM:
case CTPO_CAT_SUBTOTAL:
case CTPO_CAT_TOTAL:
- if (!ctables_find_category_for_postcompute (cats, e))
- {
- 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
- || cats->cats[i].type == CCT_HSUBTOTAL);
- 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;
- }
- }
+ {
+ 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, cat->location,
- _("Computed category &%s references a category not included "
- "in the category list."),
- 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;
- }
- return true;
+ msg_at (SE, pc_cat->location,
+ _("Computed category &%s references a category not included "
+ "in the category list."),
+ 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_NEG:
for (size_t i = 0; i < 2; i++)
if (e->subs[i] && !ctables_recursive_check_postcompute (
- e->subs[i], cat, cats, cats_location))
+ e->subs[i], pc_cat, cats, cats_location))
return false;
return true;
= lex_ofs_location (lexer, cats_start_ofs, lex_ofs (lexer) - 1);
for (size_t i = 0; i < c->n_cats; i++)
{
- const struct ctables_category *cat = &c->cats[i];
+ struct ctables_category *cat = &c->cats[i];
if (cat->type == CCT_POSTCOMPUTE
&& !ctables_recursive_check_postcompute (cat->pc->expr, cat,
c, cats_location))
break;
case CCT_SUBTOTAL:
- case CCT_HSUBTOTAL:
subtotal = cat;
break;
case CCT_NUMBER:
case CCT_STRING:
case CCT_SUBTOTAL:
- case CCT_HSUBTOTAL:
case CCT_TOTAL:
case CCT_POSTCOMPUTE:
/* Must be equal. */
break;
case CCT_SUBTOTAL:
- case CCT_HSUBTOTAL:
case CCT_TOTAL:
break;
hash = hash_pointer (cats[a][i], hash);
if (cats[a][i]->type != CCT_TOTAL
&& cats[a][i]->type != CCT_SUBTOTAL
- && cats[a][i]->type != CCT_HSUBTOTAL)
+ && cats[a][i]->type != CCT_POSTCOMPUTE)
hash = value_hash (case_data (c, nest->vars[i]),
var_get_width (nest->vars[i]), hash);
else
&& (cats[a][i] != cell->axes[a].cvs[i].category
|| (cats[a][i]->type != CCT_TOTAL
&& cats[a][i]->type != CCT_SUBTOTAL
- && cats[a][i]->type != CCT_HSUBTOTAL
+ && cats[a][i]->type != CCT_POSTCOMPUTE
&& !value_equal (case_data (c, nest->vars[i]),
&cell->axes[a].cvs[i].value,
var_get_width (nest->vars[i])))))
for (size_t i = 0; i < nest->n; i++)
{
const struct ctables_category *cat = cats[a][i];
-
if (i != nest->scale_idx)
{
const struct ctables_category *subtotal = cat->subtotal;
- if (subtotal && subtotal->type == CCT_HSUBTOTAL)
+ if (cat->hide || (subtotal && subtotal->hide_subcategories))
cell->hide = true;
- if (cat->type == CCT_TOTAL || cat->type == CCT_SUBTOTAL || cat->type == CCT_HSUBTOTAL)
+ if (cat->type == CCT_TOTAL
+ || cat->type == CCT_SUBTOTAL
+ || cat->type == CCT_POSTCOMPUTE)
cell->contributes_to_domains = false;
}
const struct variable *var,
const union value *value)
{
- return (cat->type == CCT_TOTAL || cat->type == CCT_SUBTOTAL || cat->type == CCT_HSUBTOTAL
+ return (cat->type == CCT_TOTAL || cat->type == CCT_SUBTOTAL
? pivot_value_new_user_text (cat->total_label, SIZE_MAX)
+ : cat->type == CCT_POSTCOMPUTE && cat->pc->label
+ ? pivot_value_new_user_text (cat->pc->label, SIZE_MAX)
: pivot_value_new_var_value (var, value));
}
if (prev->axes[a].cvs[var_idx].category != c)
break;
else if (c->type != CCT_SUBTOTAL
- && c->type != CCT_HSUBTOTAL
&& c->type != CCT_TOTAL
+ && c->type != CCT_POSTCOMPUTE
&& !value_equal (&prev->axes[a].cvs[var_idx].value,
&cell->axes[a].cvs[var_idx].value,
var_get_type (nest->vars[var_idx])))
break;
case CCT_SUBTOTAL:
- case CCT_HSUBTOTAL:
case CCT_TOTAL:
break;
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_section_value *sv;
union value *value = case_data_rw (c, var);
value_destroy (value, width);
value_clone (value, &sv->value, width);
- cats[a][a_idx] = ctables_categories_match (
- s->table->categories[var_get_dict_index (var)], value, var);
+ 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)
+ {
+ printf ("%s:%d\n", __FILE__, __LINE__);
+ cats[a][a_idx] = cat;
+ ctables_section_recurse_add_empty_categories (s, cats, c, a, a_idx + 1);
+ }
+ }
}
}
static bool
ctables_parse_pcompute (struct lexer *lexer, struct ctables *ct)
{
- int start_ofs = lex_ofs (lexer) - 1;
+ int pcompute_start = lex_ofs (lexer) - 1;
if (!lex_force_match (lexer, T_AND) || !lex_force_id (lexer))
return false;
return false;
}
+ int expr_start = lex_ofs (lexer);
struct ctables_pcexpr *expr = parse_add (lexer);
+ int expr_end = lex_ofs (lexer) - 1;
if (!expr || !lex_force_match (lexer, T_RPAREN))
{
free (name);
return false;
}
+ int pcompute_end = lex_ofs (lexer) - 1;
- struct msg_location *location = lex_ofs_location (lexer, start_ofs,
- 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)
}
pc->expr = expr;
pc->location = location;
+ if (!pc->label)
+ pc->label = lex_ofs_representation (lexer, expr_start, expr_end);
return true;
}
projects / pspp / blobdiff