/* PSPP - a program for statistical analysis.
- Copyright (C) 1997-9, 2000, 2006, 2009, 2010, 2011 Free Software Foundation, Inc.
+ Copyright (C) 1997-9, 2000, 2006, 2009, 2010, 2011, 2012, 2013 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
+variables=custom;
missing=miss:!table/include/report;
+write[wr_]=none,cells,all;
- +format=fmt:!labels/nolabels/novallabs,
- val:!avalue/dvalue,
+ +format=val:!avalue/dvalue,
indx:!noindex/index,
tabl:!tables/notables,
box:!box/nobox,
/* A crosstabulation of 2 or more variables. */
struct pivot_table
{
+ struct crosstabs_proc *proc;
struct fmt_spec weight_format; /* Format for weight variable. */
double missing; /* Weight of missing cases. */
/* Integer mode variable info. */
struct var_range
{
+ struct hmap_node hmap_node; /* In struct crosstabs_proc var_ranges map. */
+ const struct variable *var; /* The variable. */
int min; /* Minimum value. */
int max; /* Maximum value + 1. */
int count; /* max - min. */
};
-static inline struct var_range *
-get_var_range (const struct variable *v)
-{
- return var_get_aux (v);
-}
-
struct crosstabs_proc
{
const struct dictionary *dict;
/* Variables specifies on VARIABLES. */
const struct variable **variables;
size_t n_variables;
+ struct hmap var_ranges;
/* TABLES. */
struct pivot_table *pivots;
bool descending; /* True if descending sort order is requested. */
};
+const struct var_range *get_var_range (const struct crosstabs_proc *,
+ const struct variable *);
+
static bool should_tabulate_case (const struct pivot_table *,
const struct ccase *, enum mv_class exclude);
static void tabulate_general_case (struct pivot_table *, const struct ccase *,
cmd_crosstabs (struct lexer *lexer, struct dataset *ds)
{
const struct variable *wv = dict_get_weight (dataset_dict (ds));
+ struct var_range *range, *next_range;
struct crosstabs_proc proc;
struct casegrouper *grouper;
struct casereader *input, *group;
proc.bad_warn = true;
proc.variables = NULL;
proc.n_variables = 0;
+ hmap_init (&proc.var_ranges);
proc.pivots = NULL;
proc.n_pivots = 0;
proc.descending = false;
proc.exclude = (cmd.miss == CRS_TABLE ? MV_ANY
: cmd.miss == CRS_INCLUDE ? MV_SYSTEM
: MV_NEVER);
- if (proc.mode == GENERAL && proc.mode == MV_NEVER)
+ if (proc.mode == GENERAL && proc.exclude == MV_NEVER)
{
msg (SE, _("Missing mode REPORT not allowed in general mode. "
"Assuming MISSING=TABLE."));
- proc.mode = MV_ANY;
+ proc.exclude = MV_ANY;
}
/* PIVOT. */
exit:
free (proc.variables);
+ HMAP_FOR_EACH_SAFE (range, next_range, struct var_range, hmap_node,
+ &proc.var_ranges)
+ {
+ hmap_delete (&proc.var_ranges, &range->hmap_node);
+ free (range);
+ }
for (pt = &proc.pivots[0]; pt < &proc.pivots[proc.n_pivots]; pt++)
{
free (pt->vars);
struct pivot_table *pt = &proc->pivots[proc->n_pivots++];
int j;
+ pt->proc = proc;
pt->weight_format = proc->weight_format;
pt->missing = 0.;
pt->n_vars = n_by;
for (i = orig_nv; i < proc->n_variables; i++)
{
+ const struct variable *var = proc->variables[i];
struct var_range *vr = xmalloc (sizeof *vr);
+
+ vr->var = var;
vr->min = min;
vr->max = max + 1.;
vr->count = max - min + 1;
- var_attach_aux (proc->variables[i], vr, var_dtor_free);
+ hmap_insert (&proc->var_ranges, &vr->hmap_node,
+ hash_pointer (var, 0));
}
if (lex_token (lexer) == T_SLASH)
\f
/* Data file processing. */
+const struct var_range *
+get_var_range (const struct crosstabs_proc *proc, const struct variable *var)
+{
+ if (!hmap_is_empty (&proc->var_ranges))
+ {
+ const struct var_range *range;
+
+ HMAP_FOR_EACH_IN_BUCKET (range, struct var_range, hmap_node,
+ hash_pointer (var, 0), &proc->var_ranges)
+ if (range->var == var)
+ return range;
+ }
+
+ return NULL;
+}
+
static bool
should_tabulate_case (const struct pivot_table *pt, const struct ccase *c,
enum mv_class exclude)
for (j = 0; j < pt->n_vars; j++)
{
const struct variable *var = pt->vars[j];
- struct var_range *range = get_var_range (var);
+ const struct var_range *range = get_var_range (pt->proc, var);
if (var_is_value_missing (var, case_data (c, var), exclude))
return false;
pt->missing = 0.0;
- /* Free only the members that were allocated in this
- function. The other pointer members are either both
- allocated and destroyed at a lower level (in
- output_pivot_table), or both allocated and destroyed at
- a higher level (in crs_custom_tables and free_proc,
+ /* Free the members that were allocated in this function(and the values
+ owned by the entries.
+
+ The other pointer members are either both allocated and destroyed at a
+ lower level (in output_pivot_table), or both allocated and destroyed
+ at a higher level (in crs_custom_tables and free_proc,
respectively). */
+ for (i = 0; i < pt->n_vars; i++)
+ {
+ int width = var_get_width (pt->vars[i]);
+ if (value_needs_init (width))
+ {
+ size_t j;
+
+ for (j = 0; j < pt->n_entries; j++)
+ value_destroy (&pt->entries[j]->values[i], width);
+ }
+ }
+
for (i = 0; i < pt->n_entries; i++)
free (pt->entries[i]);
free (pt->entries);
struct string vars;
int i;
- ds_init_cstr (&vars, var_get_name (pt->vars[0]));
+ ds_init_cstr (&vars, var_to_string (pt->vars[0]));
for (i = 1; i < pt->n_vars; i++)
- ds_put_format (&vars, " * %s", var_get_name (pt->vars[i]));
+ ds_put_format (&vars, " * %s", var_to_string (pt->vars[i]));
/* TRANSLATORS: The %s here describes a crosstabulation. It takes the
form "var1 * var2 * var3 * ...". */
ds_cstr (&vars));
ds_destroy (&vars);
+ free (pt->cols);
return;
}
/* First header line. */
tab_joint_text (table, x.n_consts + 1, 0,
(x.n_consts + 1) + (x.n_cols - 1), 0,
- TAB_CENTER | TAT_TITLE, var_get_name (x.vars[COL_VAR]));
+ TAB_CENTER | TAT_TITLE, var_to_string (x.vars[COL_VAR]));
tab_hline (table, TAL_1, x.n_consts + 1,
x.n_consts + 2 + x.n_cols - 2, 1);
x.n_consts + 2 - i - 1, 1,
TAB_RIGHT | TAT_TITLE, var_to_string (x.vars[i]));
tab_text (table, x.n_consts + 2 - 2, 1, TAB_RIGHT | TAT_TITLE,
- var_get_name (x.vars[ROW_VAR]));
+ var_to_string (x.vars[ROW_VAR]));
for (i = 0; i < x.n_cols; i++)
table_value_missing (proc, table, x.n_consts + 2 + i - 1, 1, TAB_RIGHT,
&x.cols[i], x.vars[COL_VAR]);
{
if (i)
ds_put_cstr (&title, " * ");
- ds_put_cstr (&title, var_get_name (x.vars[i]));
+ ds_put_cstr (&title, var_to_string (x.vars[i]));
}
for (i = 0; i < pt->n_consts; i++)
{
const struct variable *var = pt->const_vars[i];
char *s;
- ds_put_format (&title, ", %s=", var_get_name (var));
+ ds_put_format (&title, ", %s=", var_to_string (var));
/* Insert the formatted value of VAR without any leading spaces. */
s = data_out (&pt->const_values[i], var_get_encoding (var),
with index VAR_IDX takes on. The values are returned as a
malloc()'d array stored in *VALUES, with the number of values
stored in *VALUE_CNT.
- */
+
+ The caller must eventually free *VALUES, but each pointer in *VALUES points
+ to existing data not owned by *VALUES itself. */
static void
enum_var_values (const struct pivot_table *pt, int var_idx,
union value **valuesp, int *n_values, bool descending)
{
const struct variable *var = pt->vars[var_idx];
- struct var_range *range = get_var_range (var);
+ const struct var_range *range = get_var_range (pt->proc, var);
union value *values;
size_t i;
format_cell_entry (struct tab_table *table, int c, int r, double value,
char suffix, bool mark_missing, const struct dictionary *dict)
{
- const struct fmt_spec f = {FMT_F, 10, 1};
union value v;
char suffixes[3];
int suffix_len;
char *s;
v.f = value;
- s = data_out (&v, dict_get_encoding (dict), &f);
+ s = data_out (&v, dict_get_encoding (dict), settings_get_format ());
suffix_len = 0;
if (suffix != 0)
case 0:
if (var_is_numeric (cv))
sprintf (buf, _("Odds Ratio for %s (%g / %g)"),
- var_get_name (cv), c[0].f, c[1].f);
+ var_to_string (cv), c[0].f, c[1].f);
else
sprintf (buf, _("Odds Ratio for %s (%.*s / %.*s)"),
- var_get_name (cv),
+ var_to_string (cv),
cvw, value_str (&c[0], cvw),
cvw, value_str (&c[1], cvw));
break;
case 2:
if (var_is_numeric (rv))
sprintf (buf, _("For cohort %s = %g"),
- var_get_name (rv), pt->rows[i - 1].f);
+ var_to_string (rv), pt->rows[i - 1].f);
else
sprintf (buf, _("For cohort %s = %.*s"),
- var_get_name (rv),
+ var_to_string (rv),
rvw, value_str (&pt->rows[i - 1], rvw));
break;
}
if (k == 0)
string = NULL;
else if (k == 1)
- string = var_get_name (pt->vars[0]);
+ string = var_to_string (pt->vars[0]);
else
- string = var_get_name (pt->vars[1]);
+ string = var_to_string (pt->vars[1]);
tab_text_format (direct, j, 0, TAB_LEFT,
gettext (stats_names[j][k]), string);