X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;ds=inline;f=src%2Flanguage%2Fstats%2Frank.q;h=12024239f09ca5666739986d98acf1892a96b0ad;hb=888d0f91d57e0c3c5a4206c30ac71eb87bf44227;hp=fec2ee7fc67909a0fa9f2a5059ed5c14e5d32f67;hpb=e070d7ddf78446b9852c61c9af84ad3659bac3b3;p=pspp-builds.git diff --git a/src/language/stats/rank.q b/src/language/stats/rank.q index fec2ee7f..12024239 100644 --- a/src/language/stats/rank.q +++ b/src/language/stats/rank.q @@ -148,7 +148,7 @@ struct rank_spec /* Function to use for testing for missing values */ -static is_missing_func *value_is_missing; +static mv_is_missing_func *value_is_missing; static struct rank_spec *rank_specs; static size_t n_rank_specs; @@ -216,17 +216,18 @@ create_var_label (struct variable *dest_var, for (g = 0 ; g < n_group_vars ; ++g ) { if ( g > 0 ) ds_put_cstr (&group_var_str, " "); - ds_put_cstr (&group_var_str, group_vars[g]->name); + ds_put_cstr (&group_var_str, var_get_name (group_vars[g])); } ds_put_format (&label, _("%s of %s by %s"), function_name[f], - src_var->name, ds_cstr (&group_var_str)); + var_get_name (src_var), ds_cstr (&group_var_str)); ds_destroy (&group_var_str); } else - ds_put_format (&label,_("%s of %s"), function_name[f], src_var->name); + ds_put_format (&label, _("%s of %s"), + function_name[f], var_get_name (src_var)); - dest_var->label = strdup (ds_cstr (&label) ); + var_set_label (dest_var, ds_cstr (&label)); ds_destroy (&label); } @@ -247,13 +248,13 @@ rank_cmd (struct dataset *ds, const struct sort_criteria *sc, { struct variable *v = dict_get_split_vars (dataset_dict (ds))[i]; criteria.crits[i].fv = v->fv; - criteria.crits[i].width = v->width; + criteria.crits[i].width = var_get_width (v); criteria.crits[i].dir = SRT_ASCEND; } for (i = 0; i < n_group_vars; i++) { criteria.crits[i + n_splits].fv = group_vars[i]->fv; - criteria.crits[i + n_splits].width = group_vars[i]->width; + criteria.crits[i + n_splits].width = var_get_width (group_vars[i]); criteria.crits[i + n_splits].dir = SRT_ASCEND; } for (i = 0 ; i < sc->crit_cnt ; ++i ) @@ -279,7 +280,7 @@ rank_cmd (struct dataset *ds, const struct sort_criteria *sc, out = rank_sorted_casefile (sorted_cf, &criteria, dataset_dict (ds), rank_specs, n_rank_specs, - i, &src_vars[i]->miss) ; + i, var_get_missing_values (src_vars[i])); if ( NULL == out ) { result = false ; @@ -599,7 +600,7 @@ rank_sorted_casefile (struct casefile *cf, const struct missing_values *mv) { struct casefile *dest = fastfile_create (casefile_get_value_cnt (cf)); - struct casereader *lookahead = casefile_get_reader (cf); + struct casereader *lookahead = casefile_get_reader (cf, NULL); struct casereader *pos = casereader_clone (lookahead); struct ccase group_case; bool warn = true; @@ -685,8 +686,8 @@ create_rank_variable (struct dictionary *dict, enum RANK_FUNC f, if ( NULL == var ) { - snprintf(name, SHORT_NAME_LEN + 1, "%c%s", - function_name[f][0], src_var->name); + snprintf (name, SHORT_NAME_LEN + 1, "%c%s", + function_name[f][0], var_get_name (src_var)); var = dict_create_var(dict, name, 0); } @@ -724,12 +725,11 @@ create_rank_variable (struct dictionary *dict, enum RANK_FUNC f, return NULL; } - var->write = var->print = dest_format[f]; + var_set_both_formats (var, &dest_format[f]); return var; } -int cmd_rank(struct dataset *ds); static void rank_cleanup(void) @@ -758,14 +758,14 @@ rank_cleanup(void) } int -cmd_rank (struct dataset *ds) +cmd_rank (struct lexer *lexer, struct dataset *ds) { bool result; struct variable *order; size_t i; n_rank_specs = 0; - if ( !parse_rank (ds, &cmd, NULL) ) + if ( !parse_rank (lexer, ds, &cmd, NULL) ) { rank_cleanup (); return CMD_FAILURE; @@ -835,7 +835,7 @@ cmd_rank (struct dataset *ds) ds_init_empty (&varlist); for ( g = 0 ; g < n_group_vars ; ++g ) { - ds_put_cstr (&varlist, group_vars[g]->name); + ds_put_cstr (&varlist, var_get_name (group_vars[g])); if ( g < n_group_vars - 1) ds_put_cstr (&varlist, " "); @@ -845,10 +845,10 @@ cmd_rank (struct dataset *ds) rank_specs[i].rfunc == PROPORTION ) tab_output_text (TAT_PRINTF, _("%s into %s(%s of %s using %s BY %s)"), - src_vars[v]->name, - rank_specs[i].destvars[v]->name, + var_get_name (src_vars[v]), + var_get_name (rank_specs[i].destvars[v]), function_name[rank_specs[i].rfunc], - src_vars[v]->name, + var_get_name (src_vars[v]), fraction_name(), ds_cstr (&varlist) ); @@ -856,10 +856,10 @@ cmd_rank (struct dataset *ds) else tab_output_text (TAT_PRINTF, _("%s into %s(%s of %s BY %s)"), - src_vars[v]->name, - rank_specs[i].destvars[v]->name, + var_get_name (src_vars[v]), + var_get_name (rank_specs[i].destvars[v]), function_name[rank_specs[i].rfunc], - src_vars[v]->name, + var_get_name (src_vars[v]), ds_cstr (&varlist) ); ds_destroy (&varlist); @@ -870,20 +870,20 @@ cmd_rank (struct dataset *ds) rank_specs[i].rfunc == PROPORTION ) tab_output_text (TAT_PRINTF, _("%s into %s(%s of %s using %s)"), - src_vars[v]->name, - rank_specs[i].destvars[v]->name, + var_get_name (src_vars[v]), + var_get_name (rank_specs[i].destvars[v]), function_name[rank_specs[i].rfunc], - src_vars[v]->name, + var_get_name (src_vars[v]), fraction_name() ); else tab_output_text (TAT_PRINTF, _("%s into %s(%s of %s)"), - src_vars[v]->name, - rank_specs[i].destvars[v]->name, + var_get_name (src_vars[v]), + var_get_name (rank_specs[i].destvars[v]), function_name[rank_specs[i].rfunc], - src_vars[v]->name + var_get_name (src_vars[v]) ); } } @@ -929,27 +929,28 @@ cmd_rank (struct dataset *ds) /* Parser for the variables sub command Returns 1 on success */ static int -rank_custom_variables (struct dataset *ds, struct cmd_rank *cmd UNUSED, void *aux UNUSED) +rank_custom_variables (struct lexer *lexer, struct dataset *ds, struct cmd_rank *cmd UNUSED, void *aux UNUSED) { static const int terminators[2] = {T_BY, 0}; - lex_match('='); + lex_match (lexer, '='); - if ((token != T_ID || dict_lookup_var (dataset_dict (ds), tokid) == NULL) - && token != T_ALL) + if ((lex_token (lexer) != T_ID || dict_lookup_var (dataset_dict (ds), lex_tokid (lexer)) == NULL) + && lex_token (lexer) != T_ALL) return 2; - sc = sort_parse_criteria (dataset_dict (ds), + sc = sort_parse_criteria (lexer, dataset_dict (ds), &src_vars, &n_src_vars, 0, terminators); - if ( lex_match(T_BY) ) + if ( lex_match (lexer, T_BY) ) { - if ((token != T_ID || dict_lookup_var (dataset_dict (ds), tokid) == NULL)) + if ((lex_token (lexer) != T_ID || dict_lookup_var (dataset_dict (ds), lex_tokid (lexer)) == NULL)) { return 2; } - if (!parse_variables (dataset_dict (ds), &group_vars, &n_group_vars, + if (!parse_variables (lexer, dataset_dict (ds), + &group_vars, &n_group_vars, PV_NO_DUPLICATE | PV_NUMERIC | PV_NO_SCRATCH) ) { free (group_vars); @@ -963,7 +964,7 @@ rank_custom_variables (struct dataset *ds, struct cmd_rank *cmd UNUSED, void *au /* Parse the [/rank INTO var1 var2 ... varN ] clause */ static int -parse_rank_function(struct dictionary *dict, struct cmd_rank *cmd UNUSED, enum RANK_FUNC f) +parse_rank_function (struct lexer *lexer, struct dictionary *dict, struct cmd_rank *cmd UNUSED, enum RANK_FUNC f) { int var_count = 0; @@ -975,16 +976,16 @@ parse_rank_function(struct dictionary *dict, struct cmd_rank *cmd UNUSED, enum R rank_specs[n_rank_specs - 1].destvars = xcalloc (sc->crit_cnt, sizeof (struct variable *)); - if (lex_match_id("INTO")) + if (lex_match_id (lexer, "INTO")) { struct variable *destvar; - while( token == T_ID ) + while( lex_token (lexer) == T_ID ) { - if ( dict_lookup_var (dict, tokid) != NULL ) + if ( dict_lookup_var (dict, lex_tokid (lexer)) != NULL ) { - msg(SE, _("Variable %s already exists."), tokid); + msg(SE, _("Variable %s already exists."), lex_tokid (lexer)); return 0; } if ( var_count >= sc->crit_cnt ) @@ -993,10 +994,10 @@ parse_rank_function(struct dictionary *dict, struct cmd_rank *cmd UNUSED, enum R return 0; } - destvar = create_rank_variable (dict, f, src_vars[var_count], tokid); + destvar = create_rank_variable (dict, f, src_vars[var_count], lex_tokid (lexer)); rank_specs[n_rank_specs - 1].destvars[var_count] = destvar ; - lex_get(); + lex_get (lexer); ++var_count; } } @@ -1006,74 +1007,74 @@ parse_rank_function(struct dictionary *dict, struct cmd_rank *cmd UNUSED, enum R static int -rank_custom_rank(struct dataset *ds, struct cmd_rank *cmd, void *aux UNUSED ) +rank_custom_rank (struct lexer *lexer, struct dataset *ds, struct cmd_rank *cmd, void *aux UNUSED ) { struct dictionary *dict = dataset_dict (ds); - return parse_rank_function (dict, cmd, RANK); + return parse_rank_function (lexer, dict, cmd, RANK); } static int -rank_custom_normal(struct dataset *ds, struct cmd_rank *cmd, void *aux UNUSED ) +rank_custom_normal (struct lexer *lexer, struct dataset *ds, struct cmd_rank *cmd, void *aux UNUSED ) { struct dictionary *dict = dataset_dict (ds); - return parse_rank_function (dict, cmd, NORMAL); + return parse_rank_function (lexer, dict, cmd, NORMAL); } static int -rank_custom_percent(struct dataset *ds, struct cmd_rank *cmd, void *aux UNUSED ) +rank_custom_percent (struct lexer *lexer, struct dataset *ds, struct cmd_rank *cmd, void *aux UNUSED ) { struct dictionary *dict = dataset_dict (ds); - return parse_rank_function (dict, cmd, PERCENT); + return parse_rank_function (lexer, dict, cmd, PERCENT); } static int -rank_custom_rfraction(struct dataset *ds, struct cmd_rank *cmd, void *aux UNUSED ) +rank_custom_rfraction (struct lexer *lexer, struct dataset *ds, struct cmd_rank *cmd, void *aux UNUSED ) { struct dictionary *dict = dataset_dict (ds); - return parse_rank_function (dict, cmd, RFRACTION); + return parse_rank_function (lexer, dict, cmd, RFRACTION); } static int -rank_custom_proportion(struct dataset *ds, struct cmd_rank *cmd, void *aux UNUSED ) +rank_custom_proportion (struct lexer *lexer, struct dataset *ds, struct cmd_rank *cmd, void *aux UNUSED ) { struct dictionary *dict = dataset_dict (ds); - return parse_rank_function (dict, cmd, PROPORTION); + return parse_rank_function (lexer, dict, cmd, PROPORTION); } static int -rank_custom_n (struct dataset *ds, struct cmd_rank *cmd, void *aux UNUSED ) +rank_custom_n (struct lexer *lexer, struct dataset *ds, struct cmd_rank *cmd, void *aux UNUSED ) { struct dictionary *dict = dataset_dict (ds); - return parse_rank_function (dict, cmd, N); + return parse_rank_function (lexer, dict, cmd, N); } static int -rank_custom_savage(struct dataset *ds, struct cmd_rank *cmd, void *aux UNUSED ) +rank_custom_savage (struct lexer *lexer, struct dataset *ds, struct cmd_rank *cmd, void *aux UNUSED ) { struct dictionary *dict = dataset_dict (ds); - return parse_rank_function (dict, cmd, SAVAGE); + return parse_rank_function (lexer, dict, cmd, SAVAGE); } static int -rank_custom_ntiles (struct dataset *ds, struct cmd_rank *cmd, void *aux UNUSED ) +rank_custom_ntiles (struct lexer *lexer, struct dataset *ds, struct cmd_rank *cmd, void *aux UNUSED ) { struct dictionary *dict = dataset_dict (ds); - if ( lex_force_match('(') ) + if ( lex_force_match (lexer, '(') ) { - if ( lex_force_int() ) + if ( lex_force_int (lexer) ) { - k_ntiles = lex_integer (); - lex_get(); - lex_force_match(')'); + k_ntiles = lex_integer (lexer); + lex_get (lexer); + lex_force_match (lexer, ')'); } else return 0; @@ -1081,5 +1082,5 @@ rank_custom_ntiles (struct dataset *ds, struct cmd_rank *cmd, void *aux UNUSED ) else return 0; - return parse_rank_function(dict, cmd, NTILES); + return parse_rank_function (lexer, dict, cmd, NTILES); }