/* PSPP - a program for statistical analysis.
- Copyright (C) 1997-9, 2000, 2006, 2008 Free Software Foundation, Inc.
+ Copyright (C) 1997-9, 2000, 2006, 2008, 2009, 2010 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
struct subcase sort; /* Sort criteria (break variables). */
const struct variable **break_vars; /* Break variables. */
size_t break_var_cnt; /* Number of break variables. */
- struct ccase break_case; /* Last values of break variables. */
+ struct ccase *break_case; /* Last values of break variables. */
enum missing_treatment missing; /* How to treat missing values. */
struct agr_var *agr_vars; /* First aggregate variable. */
memset(&agr, 0 , sizeof (agr));
agr.missing = ITEMWISE;
- case_nullify (&agr.break_case);
+ agr.break_case = NULL;
agr.dict = dict_create ();
agr.src_dict = dict;
dict_set_documents (agr.dict, dict_get_documents (dict));
/* OUTFILE subcommand must be first. */
+ lex_match (lexer, '/');
if (!lex_force_match_id (lexer, "OUTFILE"))
goto error;
lex_match (lexer, '=');
agr.break_var_cnt = subcase_get_n_fields (&agr.sort);
for (i = 0; i < agr.break_var_cnt; i++)
- dict_clone_var_assert (agr.dict, agr.break_vars[i],
- var_get_name (agr.break_vars[i]));
+ dict_clone_var_assert (agr.dict, agr.break_vars[i]);
/* BREAK must follow the options. */
break;
so TEMPORARY is moot. */
proc_cancel_temporary_transformations (ds);
proc_discard_output (ds);
- output = autopaging_writer_create (dict_get_next_value_idx (agr.dict));
+ output = autopaging_writer_create (dict_get_proto (agr.dict));
}
else
{
casegrouper_get_next_group (grouper, &group);
casereader_destroy (group))
{
- struct ccase c;
-
- if (!casereader_peek (group, 0, &c))
+ struct ccase *c = casereader_peek (group, 0);
+ if (c == NULL)
{
casereader_destroy (group);
continue;
}
- initialize_aggregate_info (&agr, &c);
- case_destroy (&c);
+ initialize_aggregate_info (&agr, c);
+ case_unref (c);
- for (; casereader_read (group, &c); case_destroy (&c))
- accumulate_aggregate_info (&agr, &c);
+ for (; (c = casereader_read (group)) != NULL; case_unref (c))
+ accumulate_aggregate_info (&agr, c);
dump_aggregate_info (&agr, output);
}
if (!casegrouper_destroy (grouper))
size_t n_dest_prev = n_dest;
if (!parse_DATA_LIST_vars (lexer, &dest, &n_dest,
- PV_APPEND | PV_SINGLE | PV_NO_SCRATCH))
+ (PV_APPEND | PV_SINGLE | PV_NO_SCRATCH
+ | PV_NO_DUPLICATE)))
goto error;
/* Assign empty labels. */
}
if (function->alpha_type == VAL_STRING)
- destvar = dict_clone_var (agr->dict, v->src, dest[i]);
+ destvar = dict_clone_var_as (agr->dict, v->src, dest[i]);
else
{
assert (var_is_numeric (v->src)
subcase_destroy (&agr->sort);
free (agr->break_vars);
- case_destroy (&agr->break_case);
+ case_unref (agr->break_case);
for (iter = agr->agr_vars; iter; iter = next)
{
next = iter->next;
else if (iter->function == SD)
moments1_destroy (iter->moments);
- var_destroy (iter->subject);
- var_destroy (iter->weight);
+ dict_destroy_internal_var (iter->subject);
+ dict_destroy_internal_var (iter->weight);
free (iter);
}
case MEDIAN:
{
double wv ;
- struct ccase cout;
- case_create (&cout, 2);
+ struct ccase *cout;
+
+ cout = case_create (casewriter_get_proto (iter->writer));
- case_data_rw (&cout, iter->subject)->f =
- case_data (input, iter->src)->f;
+ case_data_rw (cout, iter->subject)->f
+ = case_data (input, iter->src)->f;
wv = dict_get_case_weight (agr->src_dict, input, NULL);
- case_data_rw (&cout, iter->weight)->f = wv;
+ case_data_rw (cout, iter->weight)->f = wv;
iter->cc += wv;
- casewriter_write (iter->writer, &cout);
- case_destroy (&cout);
+ casewriter_write (iter->writer, cout);
}
break;
case SD:
iter->int1 = 1;
break;
case MAX | FSTRING:
- if (memcmp (iter->string, v->s, src_width) < 0)
- memcpy (iter->string, v->s, src_width);
+ if (memcmp (iter->string, value_str (v, src_width), src_width) < 0)
+ memcpy (iter->string, value_str (v, src_width), src_width);
iter->int1 = 1;
break;
case MIN:
iter->int1 = 1;
break;
case MIN | FSTRING:
- if (memcmp (iter->string, v->s, src_width) > 0)
- memcpy (iter->string, v->s, src_width);
+ if (memcmp (iter->string, value_str (v, src_width), src_width) > 0)
+ memcpy (iter->string, value_str (v, src_width), src_width);
iter->int1 = 1;
break;
case FGT:
break;
case FGT | FSTRING:
case PGT | FSTRING:
- if (memcmp (iter->arg[0].c, v->s, src_width) < 0)
+ if (memcmp (iter->arg[0].c,
+ value_str (v, src_width), src_width) < 0)
iter->dbl[0] += weight;
iter->dbl[1] += weight;
break;
break;
case FLT | FSTRING:
case PLT | FSTRING:
- if (memcmp (iter->arg[0].c, v->s, src_width) > 0)
+ if (memcmp (iter->arg[0].c,
+ value_str (v, src_width), src_width) > 0)
iter->dbl[0] += weight;
iter->dbl[1] += weight;
break;
break;
case FIN | FSTRING:
case PIN | FSTRING:
- if (memcmp (iter->arg[0].c, v->s, src_width) <= 0
- && memcmp (iter->arg[1].c, v->s, src_width) >= 0)
+ if (memcmp (iter->arg[0].c,
+ value_str (v, src_width), src_width) <= 0
+ && memcmp (iter->arg[1].c,
+ value_str (v, src_width), src_width) >= 0)
iter->dbl[0] += weight;
iter->dbl[1] += weight;
break;
break;
case FOUT | FSTRING:
case POUT | FSTRING:
- if (memcmp (iter->arg[0].c, v->s, src_width) > 0
- || memcmp (iter->arg[1].c, v->s, src_width) < 0)
+ if (memcmp (iter->arg[0].c,
+ value_str (v, src_width), src_width) > 0
+ || memcmp (iter->arg[1].c,
+ value_str (v, src_width), src_width) < 0)
iter->dbl[0] += weight;
iter->dbl[1] += weight;
break;
case FIRST | FSTRING:
if (iter->int1 == 0)
{
- memcpy (iter->string, v->s, src_width);
+ memcpy (iter->string, value_str (v, src_width), src_width);
iter->int1 = 1;
}
break;
iter->int1 = 1;
break;
case LAST | FSTRING:
- memcpy (iter->string, v->s, src_width);
+ memcpy (iter->string, value_str (v, src_width), src_width);
iter->int1 = 1;
break;
case NMISS:
static void
dump_aggregate_info (struct agr_proc *agr, struct casewriter *output)
{
- struct ccase c;
-
- case_create (&c, dict_get_next_value_idx (agr->dict));
+ struct ccase *c = case_create (dict_get_proto (agr->dict));
{
int value_idx = 0;
for (i = 0; i < agr->break_var_cnt; i++)
{
const struct variable *v = agr->break_vars[i];
- size_t value_cnt = var_get_value_cnt (v);
- memcpy (case_data_rw_idx (&c, value_idx),
- case_data (&agr->break_case, v),
- sizeof (union value) * value_cnt);
- value_idx += value_cnt;
+ value_copy (case_data_rw_idx (c, value_idx),
+ case_data (agr->break_case, v),
+ var_get_width (v));
+ value_idx++;
}
}
for (i = agr->agr_vars; i; i = i->next)
{
- union value *v = case_data_rw (&c, i->dest);
-
+ union value *v = case_data_rw (c, i->dest);
+ int width = var_get_width (i->dest);
if (agr->missing == COLUMNWISE && i->saw_missing
&& (i->function & FUNC) != N && (i->function & FUNC) != NU
&& (i->function & FUNC) != NMISS && (i->function & FUNC) != NUMISS)
{
- if (var_is_alpha (i->dest))
- memset (v->s, ' ', var_get_width (i->dest));
- else
- v->f = SYSMIS;
-
+ value_set_missing (v, width);
casewriter_destroy (i->writer);
-
continue;
}
case MEDIAN:
{
struct casereader *sorted_reader;
- struct order_stats *median = percentile_create (0.5, i->cc);
+ struct percentile *median = percentile_create (0.5, i->cc);
+ struct order_stats *os = &median->parent;
sorted_reader = casewriter_make_reader (i->writer);
- order_stats_accumulate (&median, 1,
+ order_stats_accumulate (&os, 1,
sorted_reader,
i->weight,
i->subject,
i->exclude);
- v->f = percentile_calculate ((struct percentile *) median,
- PC_HAVERAGE);
+ v->f = percentile_calculate (median, PC_HAVERAGE);
- statistic_destroy ((struct statistic *) median);
+ statistic_destroy (&median->parent.parent);
}
break;
case SD:
case MAX | FSTRING:
case MIN | FSTRING:
if (i->int1)
- memcpy (v->s, i->string, var_get_width (i->dest));
+ memcpy (value_str_rw (v, width), i->string, width);
else
- memset (v->s, ' ', var_get_width (i->dest));
+ value_set_missing (v, width);
break;
case FGT:
case FGT | FSTRING:
case FIRST | FSTRING:
case LAST | FSTRING:
if (i->int1)
- memcpy (v->s, i->string, var_get_width (i->dest));
+ memcpy (value_str_rw (v, width), i->string, width);
else
- memset (v->s, ' ', var_get_width (i->dest));
+ value_set_missing (v, width);
break;
case N_NO_VARS:
v->f = i->dbl[0];
}
}
- casewriter_write (output, &c);
+ casewriter_write (output, c);
}
/* Resets the state for all the aggregate functions. */
{
struct agr_var *iter;
- case_destroy (&agr->break_case);
- case_clone (&agr->break_case, input);
+ case_unref (agr->break_case);
+ agr->break_case = case_ref (input);
for (iter = agr->agr_vars; iter; iter = iter->next)
{
break;
case MEDIAN:
{
+ struct caseproto *proto;
struct subcase ordering;
+ proto = caseproto_create ();
+ proto = caseproto_add_width (proto, 0);
+ proto = caseproto_add_width (proto, 0);
+
if ( ! iter->subject)
- iter->subject = var_create_internal (0);
+ iter->subject = dict_create_internal_var (0, 0);
if ( ! iter->weight)
- iter->weight = var_create_internal (1);
+ iter->weight = dict_create_internal_var (1, 0);
subcase_init_var (&ordering, iter->subject, SC_ASCEND);
- iter->writer = sort_create_writer (&ordering, 2);
+ iter->writer = sort_create_writer (&ordering, proto);
subcase_destroy (&ordering);
+ caseproto_unref (proto);
iter->cc = 0;
}
projects / pspp / blobdiff