projects
/
pspp-builds.git
/ blobdiff
commit
grep
author
committer
pickaxe
?
search:
re
summary
|
shortlog
|
log
|
commit
|
commitdiff
|
tree
raw
|
inline
| side by side
MODIFY VARIABLES: Eliminate VAR_NAME_LEN limit on variable names.
[pspp-builds.git]
/
src
/
language
/
dictionary
/
modify-variables.c
diff --git
a/src/language/dictionary/modify-variables.c
b/src/language/dictionary/modify-variables.c
index ad6a48e49962ba142d8a313ee5bd83addf75ebe9..aae81222c5d8d475ccc7873a857933b457f35515 100644
(file)
--- a/
src/language/dictionary/modify-variables.c
+++ b/
src/language/dictionary/modify-variables.c
@@
-1,43
+1,42
@@
-/* PSPP - computes sample statistics.
- Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
- Written by Ben Pfaff <blp@gnu.org>.
+/* PSPP - a program for statistical analysis.
+ Copyright (C) 1997-9, 2000, 2010, 2011 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 the Free Software Foundation; either version 2 of the
-
License, or
(at your option) any later version.
+ 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
- This program is distributed in the hope that it will be useful,
but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU
- General Public License for more details.
+ This program is distributed in the hope that it will be useful,
+
but
WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ G
NU G
eneral Public License for more details.
You should have received a copy of the GNU General Public License
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- 02110-1301, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include <config.h>
#include <config.h>
+
#include <stdlib.h>
#include <stdlib.h>
-#include <libpspp/message.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/assertion.h>
#include <libpspp/array.h>
#include <libpspp/array.h>
-#include <libpspp/alloc.h>
#include <libpspp/bit-vector.h>
#include <libpspp/bit-vector.h>
-#include <language/command.h>
#include <libpspp/compiler.h>
#include <libpspp/compiler.h>
-#include <data/dictionary.h>
#include <libpspp/message.h>
#include <libpspp/message.h>
-#include <libpspp/hash.h>
-#include <language/lexer/lexer.h>
#include <libpspp/misc.h>
#include <libpspp/str.h>
#include <libpspp/misc.h>
#include <libpspp/str.h>
-#include <data/variable.h>
-#include
<procedure.h>
+
+#include
"xalloc.h"
#include "gettext.h"
#define _(msgid) gettext (msgid)
#include "gettext.h"
#define _(msgid) gettext (msgid)
-/* FIXME: should change weighting variable, etc. */
/* These control the ordering produced by
compare_variables_given_ordering(). */
struct ordering
/* These control the ordering produced by
compare_variables_given_ordering(). */
struct ordering
@@
-50,7
+49,7
@@
struct ordering
static struct ordering forward_positional_ordering = {1, 1};
static int compare_variables_given_ordering (const void *, const void *,
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
/* Explains how to modify the variables in a dictionary. */
struct var_modification
@@
-69,12
+68,12
@@
struct var_modification
size_t rename_cnt;
};
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
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. */
{
/* Bits indicated whether we've already encountered a subcommand of
this type. */
@@
-88,7
+87,7
@@
cmd_modify_vars (void)
size_t i;
size_t i;
- if (proc_make_temporary_transformations_permanent ())
+ if (proc_make_temporary_transformations_permanent (
ds
))
msg (SE, _("MODIFY VARS may not be used after TEMPORARY. "
"Temporary transformations will be made permanent."));
msg (SE, _("MODIFY VARS may not be used after TEMPORARY. "
"Temporary transformations will be made permanent."));
@@
-101,36
+100,36
@@
cmd_modify_vars (void)
vm.drop_cnt = 0;
/* Parse each subcommand. */
vm.drop_cnt = 0;
/* Parse each subcommand. */
- lex_match (
'/'
);
+ lex_match (
lexer, T_SLASH
);
for (;;)
{
for (;;)
{
- if (lex_match_id ("REORDER"))
+ if (lex_match_id (
lexer,
"REORDER"))
{
struct variable **v = NULL;
size_t nv = 0;
if (already_encountered & 1)
{
{
struct variable **v = NULL;
size_t nv = 0;
if (already_encountered & 1)
{
- msg (SE, _("
REORDER subcommand may be given at most once.")
);
+ msg (SE, _("
%s subcommand may be given at most once."), "REORDER"
);
goto done;
}
already_encountered |= 1;
goto done;
}
already_encountered |= 1;
- lex_match (
'='
);
+ lex_match (
lexer, T_EQUALS
);
do
{
struct ordering ordering;
size_t prev_nv = nv;
ordering.forward = ordering.positional = 1;
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;
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;
ordering.positional = 0;
- if (lex_match (
T_ALL) || token == '/' || token == '.'
)
+ if (lex_match (
lexer, T_ALL) || lex_token (lexer) == T_SLASH || lex_token (lexer) == T_ENDCMD
)
{
if (prev_nv != 0)
{
{
if (prev_nv != 0)
{
@@
-138,23
+137,23
@@
cmd_modify_vars (void)
"of variables."));
goto done;
}
"of variables."));
goto done;
}
- dict_get_vars
(default_dict, &v, &nv, 1u <<
DC_SYSTEM);
+ dict_get_vars
_mutable (dataset_dict (ds), &v, &nv,
DC_SYSTEM);
}
else
{
}
else
{
- if (!lex_match (
'('
))
+ if (!lex_match (
lexer, T_LPAREN
))
{
{
- msg (SE, _("`(' expected on
REORDER subcommand.")
);
+ msg (SE, _("`(' expected on
%s subcommand."), "REORDER"
);
free (v);
goto done;
}
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;
}
PV_APPEND | PV_NO_DUPLICATE))
{
free (v);
goto done;
}
- if (!lex_match (
')'
))
+ if (!lex_match (
lexer, T_RPAREN
))
{
msg (SE, _("`)' expected following variable names on "
"REORDER subcommand."));
{
msg (SE, _("`)' expected following variable names on "
"REORDER subcommand."));
@@
-165,46
+164,49
@@
cmd_modify_vars (void)
sort (&v[prev_nv], nv - prev_nv, sizeof *v,
compare_variables_given_ordering, &ordering);
}
sort (&v[prev_nv], nv - prev_nv, sizeof *v,
compare_variables_given_ordering, &ordering);
}
- while (token != '/' && token != '.');
+ while (lex_token (lexer) != T_SLASH
+ && lex_token (lexer) != T_ENDCMD);
vm.reorder_vars = v;
vm.reorder_cnt = nv;
}
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)
{
{
if (already_encountered & 2)
{
- msg (SE, _("
RENAME subcommand may be given at most once.")
);
+ msg (SE, _("
%s subcommand may be given at most once."), "RENAME"
);
goto done;
}
already_encountered |= 2;
goto done;
}
already_encountered |= 2;
- lex_match (
'='
);
+ lex_match (
lexer, T_EQUALS
);
do
{
size_t prev_nv_1 = vm.rename_cnt;
size_t prev_nv_2 = vm.rename_cnt;
do
{
size_t prev_nv_1 = vm.rename_cnt;
size_t prev_nv_2 = vm.rename_cnt;
- if (!lex_match (
'('
))
+ if (!lex_match (
lexer, T_LPAREN
))
{
{
- msg (SE, _("`(' expected on
RENAME subcommand.")
);
+ msg (SE, _("`(' expected on
%s subcommand."), "RENAME"
);
goto done;
}
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;
PV_APPEND | PV_NO_DUPLICATE))
goto done;
- if (!lex_match (
'='
))
+ if (!lex_match (
lexer, T_EQUALS
))
{
msg (SE, _("`=' expected between lists of new and old variable "
"names on RENAME subcommand."));
goto done;
}
{
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)
{
msg (SE, _("Differing number of variables in old name list "
goto done;
if (prev_nv_1 != vm.rename_cnt)
{
msg (SE, _("Differing number of variables in old name list "
-
"(%d) and in new name list (%d
)."),
+
"(%zu) and in new name list (%zu
)."),
vm.rename_cnt - prev_nv_2, prev_nv_1 - prev_nv_2);
for (i = 0; i < prev_nv_1; i++)
free (vm.new_names[i]);
vm.rename_cnt - prev_nv_2, prev_nv_1 - prev_nv_2);
for (i = 0; i < prev_nv_1; i++)
free (vm.new_names[i]);
@@
-212,30
+214,31
@@
cmd_modify_vars (void)
vm.new_names = NULL;
goto done;
}
vm.new_names = NULL;
goto done;
}
- if (!lex_match (
')'
))
+ if (!lex_match (
lexer, T_RPAREN
))
{
msg (SE, _("`)' expected after variable lists on RENAME "
"subcommand."));
goto done;
}
}
{
msg (SE, _("`)' expected after variable lists on RENAME "
"subcommand."));
goto done;
}
}
- while (token != '.' && token != '/');
+ while (lex_token (lexer) != T_ENDCMD
+ && lex_token (lexer) != T_SLASH);
}
}
- 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;
if (already_encountered & 4)
{
{
struct variable **keep_vars, **all_vars, **drop_vars;
size_t keep_cnt, all_cnt, drop_cnt;
if (already_encountered & 4)
{
- msg (SE, _("KEEP subcommand may be given at most once. It may
not
"
-
"
be given in conjunction with the DROP subcommand."));
+ msg (SE, _("KEEP subcommand may be given at most once. It may "
+
"not
be given in conjunction with the DROP subcommand."));
goto done;
}
already_encountered |= 4;
goto done;
}
already_encountered |= 4;
- lex_match (
'='
);
- if (!parse_variables (
default_dict
, &keep_vars, &keep_cnt, PV_NONE))
+ lex_match (
lexer, T_EQUALS
);
+ 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
goto done;
/* Transform the list of variables to keep into a list of
@@
-244,7
+247,7
@@
cmd_modify_vars (void)
sort (keep_vars, keep_cnt, sizeof *keep_vars,
compare_variables_given_ordering, &forward_positional_ordering);
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
_mutable (dataset_dict (ds)
, &all_vars, &all_cnt, 0);
assert (all_cnt >= keep_cnt);
drop_cnt = all_cnt - keep_cnt;
assert (all_cnt >= keep_cnt);
drop_cnt = all_cnt - keep_cnt;
@@
-256,7
+259,7
@@
cmd_modify_vars (void)
compare_variables_given_ordering,
&forward_positional_ordering)
!= drop_cnt)
compare_variables_given_ordering,
&forward_positional_ordering)
!= drop_cnt)
-
assert (0
);
+
NOT_REACHED (
);
free (keep_vars);
free (all_vars);
free (keep_vars);
free (all_vars);
@@
-264,7
+267,7
@@
cmd_modify_vars (void)
vm.drop_vars = drop_vars;
vm.drop_cnt = drop_cnt;
}
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;
{
struct variable **drop_vars;
size_t drop_cnt;
@@
-278,50
+281,50
@@
cmd_modify_vars (void)
}
already_encountered |= 4;
}
already_encountered |= 4;
- lex_match (
'='
);
- if (!parse_variables (
default_dict
, &drop_vars, &drop_cnt, PV_NONE))
+ lex_match (
lexer, T_EQUALS
);
+ 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;
}
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 (d
efault_dict
);
+ struct dictionary *temp = dict_clone (d
ataset_dict (ds)
);
int success = rearrange_dict (temp, &vm);
int success = rearrange_dict (temp, &vm);
- if (success)
+ if (success)
{
{
- /* FIXME: display new dictionary. */
+ /* FIXME: display new dictionary. */
}
dict_destroy (temp);
}
else
{
}
dict_destroy (temp);
}
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_tokcstr (lexer)
);
else
msg (SE, _("Subcommand name expected."));
goto done;
}
else
msg (SE, _("Subcommand name expected."));
goto done;
}
- if (
token == '.'
)
+ if (
lex_token (lexer) == T_ENDCMD
)
break;
break;
- if (
token != '/'
)
+ if (
lex_token (lexer) != T_SLASH
)
{
msg (SE, _("`/' or `.' expected."));
goto done;
}
{
msg (SE, _("`/' or `.' expected."));
goto done;
}
- lex_get ();
+ lex_get (
lexer
);
}
if (already_encountered & (1 | 4))
{
/* Read the data. */
}
if (already_encountered & (1 | 4))
{
/* Read the data. */
- if (!proc
edure (NULL, NULL))
- goto done;
+ if (!proc
_execute (ds))
+ goto done;
}
}
- if (!rearrange_dict (d
efault_dict
, &vm))
- goto done;
+ if (!rearrange_dict (d
ataset_dict (ds)
, &vm))
+ goto done;
ret_code = CMD_SUCCESS;
ret_code = CMD_SUCCESS;
@@
-339,7
+342,7
@@
done:
ORDERING, returning a strcmp()-type result. */
static int
compare_variables_given_ordering (const void *a_, const void *b_,
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_;
{
struct variable *const *pa = a_;
struct variable *const *pb = b_;
@@
-349,9
+352,13
@@
compare_variables_given_ordering (const void *a_, const void *b_,
int result;
if (ordering->positional)
int result;
if (ordering->positional)
- result = a->index < b->index ? -1 : a->index > b->index;
+ {
+ 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
else
- result = strcasecmp (
a->name, b->name
);
+ result = strcasecmp (
var_get_name (a), var_get_name (b)
);
if (!ordering->forward)
result = -result;
return result;
if (!ordering->forward)
result = -result;
return result;
@@
-361,14
+368,14
@@
compare_variables_given_ordering (const void *a_, const void *b_,
struct var_renaming
{
struct variable *var;
struct var_renaming
{
struct variable *var;
- c
har new_name[LONG_NAME_LEN + 1]
;
+ c
onst char *new_name
;
};
/* A algo_compare_func that compares new_name members in struct
var_renaming structures A and B. */
static int
compare_var_renaming_by_new_name (const void *a_, const void *b_,
};
/* A algo_compare_func that compares new_name members in struct
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_;
{
const struct var_renaming *a = a_;
const struct var_renaming *b = b_;
@@
-381,7
+388,7
@@
compare_var_renaming_by_new_name (const void *a_, const void *b_,
otherwise, and issues an error message. */
static int
validate_var_modification (const struct dictionary *d,
otherwise, and issues an error message. */
static int
validate_var_modification (const struct dictionary *d,
- const struct var_modification *vm)
+ const struct var_modification *vm)
{
/* Variable reordering can't be a problem, so we don't simulate
it. Variable renaming can cause duplicate names, but
{
/* Variable reordering can't be a problem, so we don't simulate
it. Variable renaming can cause duplicate names, but
@@
-398,7
+405,7
@@
validate_var_modification (const struct dictionary *d,
size_t i;
/* All variables, in index order. */
size_t i;
/* All variables, in index order. */
- dict_get_vars (d, &all_vars, &all_cnt, 0);
+ dict_get_vars
_mutable
(d, &all_vars, &all_cnt, 0);
/* Drop variables, in index order. */
drop_cnt = vm->drop_cnt;
/* Drop variables, in index order. */
drop_cnt = vm->drop_cnt;
@@
-417,18
+424,18
@@
validate_var_modification (const struct dictionary *d,
keep_vars,
compare_variables_given_ordering,
&forward_positional_ordering) != keep_cnt)
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);
/* Copy variables into var_renaming array. */
var_renaming = xnmalloc (keep_cnt, sizeof *var_renaming);
- for (i = 0; i < keep_cnt; i++)
+ for (i = 0; i < keep_cnt; i++)
{
var_renaming[i].var = keep_vars[i];
{
var_renaming[i].var = keep_vars[i];
-
strcpy (var_renaming[i].new_name, keep_vars[i]->name
);
+
var_renaming[i].new_name = var_get_name (keep_vars[i]
);
}
}
-
+
/* Rename variables in var_renaming array. */
/* Rename variables in var_renaming array. */
- for (i = 0; i < vm->rename_cnt; i++)
+ for (i = 0; i < vm->rename_cnt; i++)
{
struct variable *const *kv;
struct var_renaming *vr;
{
struct variable *const *kv;
struct var_renaming *vr;
@@
-442,7
+449,7
@@
validate_var_modification (const struct dictionary *d,
continue;
vr = var_renaming + (kv - keep_vars);
continue;
vr = var_renaming + (kv - keep_vars);
-
strcpy (vr->new_name, vm->new_names[i])
;
+
vr->new_name = vm->new_names[i]
;
}
/* Sort var_renaming array by new names and check for
}
/* Sort var_renaming array by new names and check for
@@
-462,11
+469,11
@@
validate_var_modification (const struct dictionary *d,
}
/* Reoders, removes, and renames variables in dictionary D
}
/* 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. */
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;
rearrange_dict (struct dictionary *d, const struct var_modification *vm)
{
char **rename_old_names;
@@
-480,14
+487,14
@@
rearrange_dict (struct dictionary *d, const struct var_modification *vm)
/* Check whether the modifications will cause duplicate
names. */
if (!validate_var_modification (d, vm))
/* 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++)
/* 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 (v
m->rename_vars[i]->name
);
+ rename_old_names[i] = xstrdup (v
ar_get_name (vm->rename_vars[i])
);
/* Reorder and delete variables. */
dict_reorder_vars (d, vm->reorder_vars, vm->reorder_cnt);
/* Reorder and delete variables. */
dict_reorder_vars (d, vm->reorder_vars, vm->reorder_cnt);
@@
-502,7
+509,7
@@
rearrange_dict (struct dictionary *d, const struct var_modification *vm)
struct variable *var = dict_lookup_var (d, rename_old_names[i]);
if (var == NULL)
continue;
struct variable *var = dict_lookup_var (d, rename_old_names[i]);
if (var == NULL)
continue;
-
+
rename_vars[rename_cnt] = var;
rename_new_names[rename_cnt] = vm->new_names[i];
rename_cnt++;
rename_vars[rename_cnt] = var;
rename_new_names[rename_cnt] = vm->new_names[i];
rename_cnt++;
@@
-511,7
+518,7
@@
rearrange_dict (struct dictionary *d, const struct var_modification *vm)
/* Do renaming. */
if (dict_rename_vars (d, rename_vars, rename_new_names, rename_cnt,
NULL) == 0)
/* 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++)
/* Clean up. */
for (i = 0; i < vm->rename_cnt; i++)
@@
-520,5
+527,5
@@
rearrange_dict (struct dictionary *d, const struct var_modification *vm)
free (rename_vars);
free (rename_new_names);
free (rename_vars);
free (rename_new_names);
- return
1
;
+ return
true
;
}
}