/* PSPP - computes sample statistics.
Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
- Written by Ben Pfaff <blp@gnu.org>.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
02110-1301, USA. */
#include <config.h>
+
#include <stdlib.h>
-#include "message.h"
-#include "array.h"
-#include "alloc.h"
-#include "bit-vector.h"
-#include "command.h"
-#include "compiler.h"
-#include "dictionary.h"
-#include "message.h"
-#include "hash.h"
-#include "lexer.h"
-#include "misc.h"
-#include "str.h"
-#include "variable.h"
-#include "procedure.h"
+
+#include <data/dictionary.h>
+#include <data/procedure.h>
+#include <data/variable.h>
+#include <language/command.h>
+#include <language/lexer/lexer.h>
+#include <language/lexer/variable-parser.h>
+#include <libpspp/alloc.h>
+#include <libpspp/assertion.h>
+#include <libpspp/array.h>
+#include <libpspp/bit-vector.h>
+#include <libpspp/compiler.h>
+#include <libpspp/hash.h>
+#include <libpspp/message.h>
+#include <libpspp/message.h>
+#include <libpspp/misc.h>
+#include <libpspp/str.h>
#include "gettext.h"
#define _(msgid) gettext (msgid)
static struct ordering forward_positional_ordering = {1, 1};
static int compare_variables_given_ordering (const void *, const void *,
- void *ordering);
+ const void *ordering);
/* Explains how to modify the variables in a dictionary. */
struct var_modification
size_t rename_cnt;
};
-static int rearrange_dict (struct dictionary *d,
+static bool rearrange_dict (struct dictionary *d,
const struct var_modification *vm);
/* Performs MODIFY VARS command. */
int
-cmd_modify_vars (void)
+cmd_modify_vars (struct lexer *lexer, struct dataset *ds)
{
/* Bits indicated whether we've already encountered a subcommand of
this type. */
size_t i;
- if (temporary != 0)
- {
- msg (SE, _("MODIFY VARS may not be used after TEMPORARY. "
- "Temporary transformations will be made permanent."));
- cancel_temporary ();
- }
+ if (proc_make_temporary_transformations_permanent (ds))
+ msg (SE, _("MODIFY VARS may not be used after TEMPORARY. "
+ "Temporary transformations will be made permanent."));
vm.reorder_vars = NULL;
vm.reorder_cnt = 0;
vm.drop_cnt = 0;
/* Parse each subcommand. */
- lex_match ('/');
+ lex_match (lexer, '/');
for (;;)
{
- if (lex_match_id ("REORDER"))
+ if (lex_match_id (lexer, "REORDER"))
{
struct variable **v = NULL;
size_t nv = 0;
}
already_encountered |= 1;
- lex_match ('=');
+ lex_match (lexer, '=');
do
{
struct ordering ordering;
size_t prev_nv = nv;
ordering.forward = ordering.positional = 1;
- if (lex_match_id ("FORWARD"));
- else if (lex_match_id ("BACKWARD"))
+ if (lex_match_id (lexer, "FORWARD"));
+ else if (lex_match_id (lexer, "BACKWARD"))
ordering.forward = 0;
- if (lex_match_id ("POSITIONAL"));
- else if (lex_match_id ("ALPHA"))
+ if (lex_match_id (lexer, "POSITIONAL"));
+ else if (lex_match_id (lexer, "ALPHA"))
ordering.positional = 0;
- if (lex_match (T_ALL) || token == '/' || token == '.')
+ if (lex_match (lexer, T_ALL) || lex_token (lexer) == '/' || lex_token (lexer) == '.')
{
if (prev_nv != 0)
{
"of variables."));
goto done;
}
- dict_get_vars (default_dict, &v, &nv, 1u << DC_SYSTEM);
+ dict_get_vars (dataset_dict (ds), &v, &nv, 1u << DC_SYSTEM);
}
else
{
- if (!lex_match ('('))
+ if (!lex_match (lexer, '('))
{
msg (SE, _("`(' expected on REORDER subcommand."));
free (v);
goto done;
}
- if (!parse_variables (default_dict, &v, &nv,
+ if (!parse_variables (lexer, dataset_dict (ds), &v, &nv,
PV_APPEND | PV_NO_DUPLICATE))
{
free (v);
goto done;
}
- if (!lex_match (')'))
+ if (!lex_match (lexer, ')'))
{
msg (SE, _("`)' expected following variable names on "
"REORDER subcommand."));
sort (&v[prev_nv], nv - prev_nv, sizeof *v,
compare_variables_given_ordering, &ordering);
}
- while (token != '/' && token != '.');
+ while (lex_token (lexer) != '/' && lex_token (lexer) != '.');
vm.reorder_vars = v;
vm.reorder_cnt = nv;
}
- else if (lex_match_id ("RENAME"))
+ else if (lex_match_id (lexer, "RENAME"))
{
if (already_encountered & 2)
{
}
already_encountered |= 2;
- lex_match ('=');
+ lex_match (lexer, '=');
do
{
size_t prev_nv_1 = vm.rename_cnt;
size_t prev_nv_2 = vm.rename_cnt;
- if (!lex_match ('('))
+ if (!lex_match (lexer, '('))
{
msg (SE, _("`(' expected on RENAME subcommand."));
goto done;
}
- if (!parse_variables (default_dict, &vm.rename_vars, &vm.rename_cnt,
+ if (!parse_variables (lexer, dataset_dict (ds),
+ &vm.rename_vars, &vm.rename_cnt,
PV_APPEND | PV_NO_DUPLICATE))
goto done;
- if (!lex_match ('='))
+ if (!lex_match (lexer, '='))
{
msg (SE, _("`=' expected between lists of new and old variable "
"names on RENAME subcommand."));
goto done;
}
- if (!parse_DATA_LIST_vars (&vm.new_names, &prev_nv_1, PV_APPEND))
+ if (!parse_DATA_LIST_vars (lexer, &vm.new_names,
+ &prev_nv_1, PV_APPEND))
goto done;
if (prev_nv_1 != vm.rename_cnt)
{
vm.new_names = NULL;
goto done;
}
- if (!lex_match (')'))
+ if (!lex_match (lexer, ')'))
{
msg (SE, _("`)' expected after variable lists on RENAME "
"subcommand."));
goto done;
}
}
- while (token != '.' && token != '/');
+ while (lex_token (lexer) != '.' && lex_token (lexer) != '/');
}
- else if (lex_match_id ("KEEP"))
+ else if (lex_match_id (lexer, "KEEP"))
{
struct variable **keep_vars, **all_vars, **drop_vars;
size_t keep_cnt, all_cnt, drop_cnt;
}
already_encountered |= 4;
- lex_match ('=');
- if (!parse_variables (default_dict, &keep_vars, &keep_cnt, PV_NONE))
+ lex_match (lexer, '=');
+ if (!parse_variables (lexer, dataset_dict (ds), &keep_vars, &keep_cnt, PV_NONE))
goto done;
/* Transform the list of variables to keep into a list of
sort (keep_vars, keep_cnt, sizeof *keep_vars,
compare_variables_given_ordering, &forward_positional_ordering);
- dict_get_vars (default_dict, &all_vars, &all_cnt, 0);
+ dict_get_vars (dataset_dict (ds), &all_vars, &all_cnt, 0);
assert (all_cnt >= keep_cnt);
drop_cnt = all_cnt - keep_cnt;
compare_variables_given_ordering,
&forward_positional_ordering)
!= drop_cnt)
- assert (0);
+ NOT_REACHED ();
free (keep_vars);
free (all_vars);
vm.drop_vars = drop_vars;
vm.drop_cnt = drop_cnt;
}
- else if (lex_match_id ("DROP"))
+ else if (lex_match_id (lexer, "DROP"))
{
struct variable **drop_vars;
size_t drop_cnt;
}
already_encountered |= 4;
- lex_match ('=');
- if (!parse_variables (default_dict, &drop_vars, &drop_cnt, PV_NONE))
+ lex_match (lexer, '=');
+ if (!parse_variables (lexer, dataset_dict (ds), &drop_vars, &drop_cnt, PV_NONE))
goto done;
vm.drop_vars = drop_vars;
vm.drop_cnt = drop_cnt;
}
- else if (lex_match_id ("MAP"))
+ else if (lex_match_id (lexer, "MAP"))
{
- struct dictionary *temp = dict_clone (default_dict);
+ struct dictionary *temp = dict_clone (dataset_dict (ds));
int success = rearrange_dict (temp, &vm);
if (success)
{
}
else
{
- if (token == T_ID)
- msg (SE, _("Unrecognized subcommand name `%s'."), tokid);
+ if (lex_token (lexer) == T_ID)
+ msg (SE, _("Unrecognized subcommand name `%s'."), lex_tokid (lexer));
else
msg (SE, _("Subcommand name expected."));
goto done;
}
- if (token == '.')
+ if (lex_token (lexer) == '.')
break;
- if (token != '/')
+ if (lex_token (lexer) != '/')
{
msg (SE, _("`/' or `.' expected."));
goto done;
}
- lex_get ();
+ lex_get (lexer);
}
if (already_encountered & (1 | 4))
{
/* Read the data. */
- if (!procedure (NULL, NULL))
+ if (!procedure (ds,NULL, NULL))
goto done;
}
- if (!rearrange_dict (default_dict, &vm))
+ if (!rearrange_dict (dataset_dict (ds), &vm))
goto done;
ret_code = CMD_SUCCESS;
ORDERING, returning a strcmp()-type result. */
static int
compare_variables_given_ordering (const void *a_, const void *b_,
- void *ordering_)
+ const void *ordering_)
{
struct variable *const *pa = a_;
struct variable *const *pb = b_;
const struct ordering *ordering = ordering_;
int result;
- if (ordering->positional)
- result = a->index < b->index ? -1 : a->index > b->index;
+ if (ordering->positional)
+ {
+ size_t a_index = var_get_dict_index (a);
+ size_t b_index = var_get_dict_index (b);
+ result = a_index < b_index ? -1 : a_index > b_index;
+ }
else
- result = strcasecmp (a->name, b->name);
+ result = strcasecmp (var_get_name (a), var_get_name (b));
if (!ordering->forward)
result = -result;
return result;
var_renaming structures A and B. */
static int
compare_var_renaming_by_new_name (const void *a_, const void *b_,
- void *foo UNUSED)
+ const void *aux UNUSED)
{
const struct var_renaming *a = a_;
const struct var_renaming *b = b_;
keep_vars,
compare_variables_given_ordering,
&forward_positional_ordering) != keep_cnt)
- assert (0);
+ NOT_REACHED ();
/* Copy variables into var_renaming array. */
var_renaming = xnmalloc (keep_cnt, sizeof *var_renaming);
for (i = 0; i < keep_cnt; i++)
{
var_renaming[i].var = keep_vars[i];
- strcpy (var_renaming[i].new_name, keep_vars[i]->name);
+ strcpy (var_renaming[i].new_name, var_get_name (keep_vars[i]));
}
/* Rename variables in var_renaming array. */
}
/* Reoders, removes, and renames variables in dictionary D
- according to VM. Returns nonzero if successful, zero if there
+ according to VM. Returns true if successful, false if there
would have been duplicate variable names if the modifications
had been carried out. In the latter case, the dictionary is
not modified. */
-static int
+static bool
rearrange_dict (struct dictionary *d, const struct var_modification *vm)
{
char **rename_old_names;
/* Check whether the modifications will cause duplicate
names. */
if (!validate_var_modification (d, vm))
- return 0;
+ return false;
/* Record the old names of variables to rename. After
variables are deleted, we can't depend on the variables to
still exist, but we can still look them up by name. */
rename_old_names = xnmalloc (vm->rename_cnt, sizeof *rename_old_names);
for (i = 0; i < vm->rename_cnt; i++)
- rename_old_names[i] = xstrdup (vm->rename_vars[i]->name);
+ rename_old_names[i] = xstrdup (var_get_name (vm->rename_vars[i]));
/* Reorder and delete variables. */
dict_reorder_vars (d, vm->reorder_vars, vm->reorder_cnt);
/* Do renaming. */
if (dict_rename_vars (d, rename_vars, rename_new_names, rename_cnt,
NULL) == 0)
- assert (0);
+ NOT_REACHED ();
/* Clean up. */
for (i = 0; i < vm->rename_cnt; i++)
free (rename_vars);
free (rename_new_names);
- return 1;
+ return true;
}
projects / pspp-builds.git / blobdiff