/* PSPP - a program for statistical analysis.
- Copyright (C) 1997-9, 2000, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+ Copyright (C) 1997-9, 2000, 2006, 2007, 2008, 2009, 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
bool is_sorted; /* Is file presorted on the BY variables? */
/* IN subcommand. */
- char in_name[VAR_NAME_LEN + 1];
+ char *in_name;
struct variable *in_var;
};
bool saw_sort = false;
struct casereader *active_file = NULL;
- char first_name[VAR_NAME_LEN + 1] = "";
- char last_name[VAR_NAME_LEN + 1] = "";
+ char *first_name = NULL;
+ char *last_name = NULL;
struct taint *taint = NULL;
dict_set_case_limit (proc.dict, dict_get_case_limit (dataset_dict (ds)));
- lex_match (lexer, '/');
+ lex_match (lexer, T_SLASH);
for (;;)
{
struct comb_file *file;
}
else
break;
- lex_match (lexer, '=');
+ lex_match (lexer, T_EQUALS);
if (proc.n_files >= allocated_files)
proc.files = x2nrealloc (proc.files, &allocated_files,
file->reader = NULL;
file->data = NULL;
file->is_sorted = true;
- file->in_name[0] = '\0';
+ file->in_name = NULL;
file->in_var = NULL;
- if (lex_match (lexer, '*'))
+ if (lex_match (lexer, T_ASTERISK))
{
if (!proc_has_active_file (ds))
{
goto error;
}
- while (lex_match (lexer, '/'))
+ while (lex_match (lexer, T_SLASH))
if (lex_match_id (lexer, "RENAME"))
{
if (!parse_dict_rename (lexer, file->dict))
}
else if (lex_match_id (lexer, "IN"))
{
- lex_match (lexer, '=');
+ lex_match (lexer, T_EQUALS);
if (lex_token (lexer) != T_ID)
{
lex_error (lexer, NULL);
goto error;
}
- if (file->in_name[0])
+ if (file->in_name)
{
msg (SE, _("Multiple IN subcommands for a single FILE or "
"TABLE."));
goto error;
}
- strcpy (file->in_name, lex_tokid (lexer));
+ file->in_name = xstrdup (lex_tokcstr (lexer));
lex_get (lexer);
}
else if (lex_match_id (lexer, "SORT"))
merge_dictionary (proc.dict, file);
}
- while (lex_token (lexer) != '.')
+ while (lex_token (lexer) != T_ENDCMD)
{
if (lex_match (lexer, T_BY))
{
}
saw_by = true;
- lex_match (lexer, '=');
+ lex_match (lexer, T_EQUALS);
if (!parse_sort_criteria (lexer, proc.dict, &proc.by_vars,
&by_vars, NULL))
goto error;
struct comb_file *file = &proc.files[i];
size_t j;
- for (j = 0; j < subcase_get_n_values (&proc.by_vars); j++)
+ for (j = 0; j < subcase_get_n_fields (&proc.by_vars); j++)
{
const char *name = var_get_name (by_vars[j]);
struct variable *var = dict_lookup_var (file->dict, name);
}
else if (command != COMB_UPDATE && lex_match_id (lexer, "FIRST"))
{
- if (first_name[0] != '\0')
+ if (first_name != NULL)
{
lex_sbc_only_once ("FIRST");
goto error;
}
- lex_match (lexer, '=');
+ lex_match (lexer, T_EQUALS);
if (!lex_force_id (lexer))
goto error;
- strcpy (first_name, lex_tokid (lexer));
+ first_name = xstrdup (lex_tokcstr (lexer));
lex_get (lexer);
}
else if (command != COMB_UPDATE && lex_match_id (lexer, "LAST"))
{
- if (last_name[0] != '\0')
+ if (last_name != NULL)
{
lex_sbc_only_once ("LAST");
goto error;
}
- lex_match (lexer, '=');
+ lex_match (lexer, T_EQUALS);
if (!lex_force_id (lexer))
goto error;
- strcpy (last_name, lex_tokid (lexer));
+ last_name = xstrdup (lex_tokcstr (lexer));
lex_get (lexer);
}
else if (lex_match_id (lexer, "MAP"))
goto error;
}
- if (!lex_match (lexer, '/') && lex_token (lexer) != '.')
+ if (!lex_match (lexer, T_SLASH) && lex_token (lexer) != T_ENDCMD)
{
lex_end_of_command (lexer);
goto error;
}
if (n_tables)
{
- msg (SE, _("BY is required when TABLE is specified."));
+ msg (SE, _("BY is required when %s is specified."), "TABLE");
goto error;
}
if (saw_sort)
{
- msg (SE, _("BY is required when SORT is specified."));
+ msg (SE, _("BY is required when %s is specified."), "SORT");
goto error;
}
}
}
}
- proc.output = autopaging_writer_create (dict_get_next_value_idx (proc.dict));
+ proc.output = autopaging_writer_create (dict_get_proto (proc.dict));
taint = taint_clone (casewriter_get_taint (proc.output));
/* Set up case matcher. */
free_comb_proc (&proc);
+ free (first_name);
+ free (last_name);
+
return taint_destroy (taint) ? CMD_SUCCESS : CMD_CASCADING_FAILURE;
error:
proc_commit (ds);
free_comb_proc (&proc);
taint_destroy (taint);
+ free (first_name);
+ free (last_name);
return CMD_CASCADING_FAILURE;
}
m_docs = dict_get_documents (m);
- /* If the input files have different encodings, then
+ /* FIXME: If the input files have different encodings, then
+ the result is undefined.
+ The correct thing to do would be to convert to an encoding
+ which can cope with all the input files (eg UTF-8).
*/
file_encoding = dict_get_encoding (f->dict);
if ( file_encoding != NULL)
ds_put_format (&s, _("In an earlier file, %s was a string "
"variable with width %d."),
var_name, var_get_width (mv));
- msg (SE, ds_cstr (&s));
+ msg (SE, "%s", ds_cstr (&s));
ds_destroy (&s);
return false;
}
var_set_label (mv, var_get_label (dv));
}
else
- mv = dict_clone_var_assert (m, dv, var_get_name (dv));
+ mv = dict_clone_var_assert (m, dv);
}
return true;
}
-/* If VAR_NAME is a non-empty string, attempts to create a
+/* If VAR_NAME is non-NULL, attempts to create a
variable named VAR_NAME, with format F1.0, in DICT, and stores
a pointer to the variable in *VAR. Returns true if
successful, false if the variable name is a duplicate (in
which case a message saying that the variable specified on the
- given SUBCOMMAND is a duplicate is emitted). Also returns
- true, without doing anything, if VAR_NAME is null or empty. */
+ given SUBCOMMAND is a duplicate is emitted).
+
+ Does nothing and returns true if VAR_NAME is null. */
static bool
create_flag_var (const char *subcommand, const char *var_name,
struct dictionary *dict, struct variable **var)
{
- if (var_name[0] != '\0')
+ if (var_name != NULL)
{
struct fmt_spec format = fmt_for_output (FMT_F, 1, 0);
*var = dict_create_var (dict, var_name, 0);
dict_destroy (file->dict);
casereader_destroy (file->reader);
case_unref (file->data);
+ free (file->in_name);
}
free (proc->files);
proc->files = NULL;
dict_destroy (proc->dict);
casewriter_destroy (proc->output);
case_matcher_destroy (proc->matcher);
+ if (proc->prev_BY)
+ {
+ caseproto_destroy_values (subcase_get_proto (&proc->by_vars),
+ proc->prev_BY);
+ free (proc->prev_BY);
+ }
subcase_destroy (&proc->by_vars);
case_unref (proc->buffered_case);
- free (proc->prev_BY);
}
\f
static bool scan_table (struct comb_file *, union value by[]);
struct ccase *output;
size_t i;
- output = case_create (dict_get_next_value_idx (proc->dict));
+ output = case_create (dict_get_proto (proc->dict));
for (i = 0; i < n_vars; i++)
{
struct variable *v = dict_get_var (proc->dict, i);
if (new_BY)
{
- size_t n = (subcase_get_n_values (&proc->by_vars)
- * sizeof (union value));
+ size_t n_values = subcase_get_n_fields (&proc->by_vars);
+ const struct caseproto *proto = subcase_get_proto (&proc->by_vars);
if (proc->prev_BY == NULL)
- proc->prev_BY = xmalloc (n);
- memcpy (proc->prev_BY, by, n);
+ {
+ proc->prev_BY = xmalloc (n_values * sizeof *proc->prev_BY);
+ caseproto_init_values (proto, proc->prev_BY);
+ }
+ caseproto_copy (subcase_get_proto (&proc->by_vars), 0, n_values,
+ proc->prev_BY, by);
}
}
}
projects / pspp-builds.git / blobdiff