/* Parses a list of sort fields and appends them to ORDERING,
which the caller must already have initialized.
Returns true if successful, false on error.
If SAW_DIRECTION is nonnull, sets *SAW_DIRECTION to true if at
least one parenthesized sort direction was specified, false
otherwise. */
bool
parse_sort_criteria (struct lexer *lexer, const struct dictionary *dict,
struct subcase *ordering,
const struct variable ***vars, bool *saw_direction)
{
const struct variable **local_vars = NULL;
size_t var_cnt = 0;
if (vars == NULL)
vars = &local_vars;
*vars = NULL;
if (saw_direction != NULL)
*saw_direction = false;
do
{
size_t prev_var_cnt = var_cnt;
enum subcase_direction direction;
size_t i;
/* Variables. */
if (!parse_variables_const (lexer, dict, vars, &var_cnt,
PV_APPEND | PV_NO_SCRATCH))
goto error;
/* Sort direction. */
if (lex_match (lexer, T_LPAREN))
{
if (lex_match_id (lexer, "D") || lex_match_id (lexer, "DOWN"))
direction = SC_DESCEND;
else if (lex_match_id (lexer, "A") || lex_match_id (lexer, "UP"))
direction = SC_ASCEND;
else
{
lex_error_expecting (lexer, "A", "D", NULL_SENTINEL);
goto error;
}
if (!lex_force_match (lexer, T_RPAREN))
goto error;
if (saw_direction != NULL)
*saw_direction = true;
}
else
direction = SC_ASCEND;
for (i = prev_var_cnt; i < var_cnt; i++)
{
const struct variable *var = (*vars)[i];
if (!subcase_add_var (ordering, var, direction))
msg (SW, _("Variable %s specified twice in sort criteria."),
var_get_name (var));
}
}
while (lex_token (lexer) == T_ID
&& dict_lookup_var (dict, lex_tokcstr (lexer)) != NULL);
free (local_vars);
return true;
error:
free (local_vars);
if (vars)
*vars = NULL;
return false;
}
int
cmd_save_translate (struct lexer *lexer, struct dataset *ds)
{
enum { CSV_FILE = 1, TAB_FILE } type;
struct dictionary *dict;
struct case_map *map;
struct casewriter *writer;
struct file_handle *handle;
struct csv_writer_options csv_opts;
bool replace;
bool retain_unselected;
bool recode_user_missing;
bool include_var_names;
bool use_value_labels;
bool use_print_formats;
char decimal;
char delimiter;
char qualifier;
bool ok;
type = 0;
dict = dict_clone (dataset_dict (ds));
map = NULL;
handle = NULL;
replace = false;
retain_unselected = true;
recode_user_missing = false;
include_var_names = false;
use_value_labels = false;
use_print_formats = false;
decimal = settings_get_decimal_char (FMT_F);
delimiter = 0;
qualifier = '"';
case_map_prepare_dict (dict);
dict_delete_scratch_vars (dict);
while (lex_match (lexer, T_SLASH))
{
if (lex_match_id (lexer, "OUTFILE"))
{
if (handle != NULL)
{
lex_sbc_only_once ("OUTFILE");
goto error;
}
lex_match (lexer, T_EQUALS);
handle = fh_parse (lexer, FH_REF_FILE, NULL);
if (handle == NULL)
goto error;
}
else if (lex_match_id (lexer, "TYPE"))
{
if (type != 0)
{
lex_sbc_only_once ("TYPE");
goto error;
}
lex_match (lexer, T_EQUALS);
if (lex_match_id (lexer, "CSV"))
type = CSV_FILE;
else if (lex_match_id (lexer, "TAB"))
type = TAB_FILE;
else
{
lex_error_expecting (lexer, "CSV", "TAB", NULL_SENTINEL);
goto error;
}
}
else if (lex_match_id (lexer, "REPLACE"))
replace = true;
else if (lex_match_id (lexer, "FIELDNAMES"))
include_var_names = true;
else if (lex_match_id (lexer, "MISSING"))
{
lex_match (lexer, T_EQUALS);
if (lex_match_id (lexer, "IGNORE"))
recode_user_missing = false;
else if (lex_match_id (lexer, "RECODE"))
recode_user_missing = true;
else
{
lex_error_expecting (lexer, "IGNORE", "RECODE", NULL_SENTINEL);
goto error;
}
}
else if (lex_match_id (lexer, "CELLS"))
{
lex_match (lexer, T_EQUALS);
if (lex_match_id (lexer, "VALUES"))
use_value_labels = false;
else if (lex_match_id (lexer, "LABELS"))
use_value_labels = true;
else
{
lex_error_expecting (lexer, "VALUES", "LABELS", NULL_SENTINEL);
goto error;
}
}
else if (lex_match_id (lexer, "TEXTOPTIONS"))
{
lex_match (lexer, T_EQUALS);
for (;;)
{
if (lex_match_id (lexer, "DELIMITER"))
{
lex_match (lexer, T_EQUALS);
if (!lex_force_string (lexer))
goto error;
/* XXX should support multibyte UTF-8 delimiters */
if (ss_length (lex_tokss (lexer)) != 1)
{
msg (SE, _("The %s string must contain exactly one "
"character."), "DELIMITER");
goto error;
}
delimiter = ss_first (lex_tokss (lexer));
lex_get (lexer);
}
else if (lex_match_id (lexer, "QUALIFIER"))
{
lex_match (lexer, T_EQUALS);
if (!lex_force_string (lexer))
goto error;
/* XXX should support multibyte UTF-8 qualifiers */
if (ss_length (lex_tokss (lexer)) != 1)
{
msg (SE, _("The %s string must contain exactly one "
"character."), "QUALIFIER");
goto error;
}
qualifier = ss_first (lex_tokss (lexer));
lex_get (lexer);
}
else if (lex_match_id (lexer, "DECIMAL"))
{
lex_match (lexer, T_EQUALS);
if (lex_match_id (lexer, "DOT"))
decimal = '.';
else if (lex_match_id (lexer, "COMMA"))
decimal = ',';
else
{
lex_error_expecting (lexer, "DOT", "COMMA",
NULL_SENTINEL);
goto error;
}
}
else if (lex_match_id (lexer, "FORMAT"))
{
lex_match (lexer, T_EQUALS);
if (lex_match_id (lexer, "PLAIN"))
use_print_formats = false;
else if (lex_match_id (lexer, "VARIABLE"))
use_print_formats = true;
else
{
lex_error_expecting (lexer, "PLAIN", "VARIABLE",
NULL_SENTINEL);
goto error;
}
}
else
break;
}
}
else if (lex_match_id (lexer, "UNSELECTED"))
{
lex_match (lexer, T_EQUALS);
if (lex_match_id (lexer, "RETAIN"))
retain_unselected = true;
else if (lex_match_id (lexer, "DELETE"))
retain_unselected = false;
else
{
lex_error_expecting (lexer, "RETAIN", "DELETE", NULL_SENTINEL);
goto error;
}
}
else if (!parse_dict_trim (lexer, dict))
goto error;
}
if (lex_end_of_command (lexer) != CMD_SUCCESS)
goto error;
if (type == 0)
{
lex_sbc_missing ("TYPE");
goto error;
}
else if (handle == NULL)
{
lex_sbc_missing ("OUTFILE");
goto error;
}
else if (!replace && fn_exists (fh_get_file_name (handle)))
{
msg (SE, _("Output file `%s' exists but REPLACE was not specified."),
fh_get_file_name (handle));
goto error;
}
dict_delete_scratch_vars (dict);
dict_compact_values (dict);
csv_opts.recode_user_missing = recode_user_missing;
csv_opts.include_var_names = include_var_names;
csv_opts.use_value_labels = use_value_labels;
csv_opts.use_print_formats = use_print_formats;
csv_opts.decimal = decimal;
csv_opts.delimiter = (delimiter ? delimiter
: type == TAB_FILE ? '\t'
: decimal == '.' ? ','
: ';');
csv_opts.qualifier = qualifier;
writer = csv_writer_open (handle, dict, &csv_opts);
if (writer == NULL)
goto error;
fh_unref (handle);
map = case_map_from_dict (dict);
if (map != NULL)
writer = case_map_create_output_translator (map, writer);
dict_destroy (dict);
casereader_transfer (proc_open_filtering (ds, !retain_unselected), writer);
ok = casewriter_destroy (writer);
ok = proc_commit (ds) && ok;
return ok ? CMD_SUCCESS : CMD_CASCADING_FAILURE;
error:
fh_unref (handle);
dict_destroy (dict);
case_map_destroy (map);
return CMD_FAILURE;
}
/* Parses and executes the AGGREGATE procedure. */
int
cmd_aggregate (struct lexer *lexer, struct dataset *ds)
{
struct dictionary *dict = dataset_dict (ds);
struct agr_proc agr;
struct file_handle *out_file = NULL;
struct casereader *input = NULL, *group;
struct casegrouper *grouper;
struct casewriter *output = NULL;
bool copy_documents = false;
bool presorted = false;
bool saw_direction;
bool ok;
memset(&agr, 0 , sizeof (agr));
agr.missing = ITEMWISE;
agr.src_dict = dict;
subcase_init_empty (&agr.sort);
/* OUTFILE subcommand must be first. */
lex_match (lexer, T_SLASH);
if (!lex_force_match_id (lexer, "OUTFILE"))
goto error;
lex_match (lexer, T_EQUALS);
if (!lex_match (lexer, T_ASTERISK))
{
out_file = fh_parse (lexer, FH_REF_FILE, dataset_session (ds));
if (out_file == NULL)
goto error;
}
if (out_file == NULL && lex_match_id (lexer, "MODE"))
{
lex_match (lexer, T_EQUALS);
if (lex_match_id (lexer, "ADDVARIABLES"))
{
agr.add_variables = true;
/* presorted is assumed in ADDVARIABLES mode */
presorted = true;
}
else if (lex_match_id (lexer, "REPLACE"))
{
agr.add_variables = false;
}
else
goto error;
}
if ( agr.add_variables )
agr.dict = dict_clone (dict);
else
agr.dict = dict_create (dict_get_encoding (dict));
dict_set_label (agr.dict, dict_get_label (dict));
dict_set_documents (agr.dict, dict_get_documents (dict));
/* Read most of the subcommands. */
for (;;)
{
lex_match (lexer, T_SLASH);
if (lex_match_id (lexer, "MISSING"))
{
lex_match (lexer, T_EQUALS);
if (!lex_match_id (lexer, "COLUMNWISE"))
{
lex_error_expecting (lexer, "COLUMNWISE", NULL);
goto error;
}
agr.missing = COLUMNWISE;
}
else if (lex_match_id (lexer, "DOCUMENT"))
copy_documents = true;
else if (lex_match_id (lexer, "PRESORTED"))
presorted = true;
else if (lex_force_match_id (lexer, "BREAK"))
{
int i;
lex_match (lexer, T_EQUALS);
if (!parse_sort_criteria (lexer, dict, &agr.sort, &agr.break_vars,
&saw_direction))
goto error;
agr.break_var_cnt = subcase_get_n_fields (&agr.sort);
if (! agr.add_variables)
for (i = 0; i < agr.break_var_cnt; i++)
dict_clone_var_assert (agr.dict, agr.break_vars[i]);
/* BREAK must follow the options. */
break;
}
else
goto error;
}
if (presorted && saw_direction)
msg (SW, _("When PRESORTED is specified, specifying sorting directions "
"with (A) or (D) has no effect. Output data will be sorted "
"the same way as the input data."));
/* Read in the aggregate functions. */
lex_match (lexer, T_SLASH);
if (!parse_aggregate_functions (lexer, dict, &agr))
goto error;
/* Delete documents. */
if (!copy_documents)
dict_clear_documents (agr.dict);
/* Cancel SPLIT FILE. */
dict_set_split_vars (agr.dict, NULL, 0);
/* Initialize. */
agr.case_cnt = 0;
if (out_file == NULL)
{
/* The active dataset will be replaced by the aggregated data,
so TEMPORARY is moot. */
proc_cancel_temporary_transformations (ds);
proc_discard_output (ds);
output = autopaging_writer_create (dict_get_proto (agr.dict));
}
else
{
output = any_writer_open (out_file, agr.dict);
if (output == NULL)
goto error;
}
input = proc_open (ds);
if (!subcase_is_empty (&agr.sort) && !presorted)
{
input = sort_execute (input, &agr.sort);
subcase_clear (&agr.sort);
}
for (grouper = casegrouper_create_vars (input, agr.break_vars,
agr.break_var_cnt);
casegrouper_get_next_group (grouper, &group);
casereader_destroy (group))
{
struct casereader *placeholder = NULL;
struct ccase *c = casereader_peek (group, 0);
if (c == NULL)
{
casereader_destroy (group);
continue;
}
initialize_aggregate_info (&agr);
if ( agr.add_variables )
placeholder = casereader_clone (group);
{
struct ccase *cg;
for (; (cg = casereader_read (group)) != NULL; case_unref (cg))
accumulate_aggregate_info (&agr, cg);
}
if (agr.add_variables)
{
struct ccase *cg;
for (; (cg = casereader_read (placeholder)) != NULL; case_unref (cg))
dump_aggregate_info (&agr, output, cg);
casereader_destroy (placeholder);
}
else
{
dump_aggregate_info (&agr, output, c);
}
case_unref (c);
}
if (!casegrouper_destroy (grouper))
goto error;
if (!proc_commit (ds))
{
input = NULL;
goto error;
}
input = NULL;
if (out_file == NULL)
{
struct casereader *next_input = casewriter_make_reader (output);
if (next_input == NULL)
goto error;
dataset_set_dict (ds, agr.dict);
dataset_set_source (ds, next_input);
agr.dict = NULL;
}
else
{
ok = casewriter_destroy (output);
output = NULL;
if (!ok)
goto error;
}
agr_destroy (&agr);
fh_unref (out_file);
return CMD_SUCCESS;
error:
if (input != NULL)
proc_commit (ds);
casewriter_destroy (output);
agr_destroy (&agr);
fh_unref (out_file);
return CMD_CASCADING_FAILURE;
}
/* Parses the NUMERIC command. */
int
cmd_numeric (struct lexer *lexer, struct dataset *ds)
{
size_t i;
/* Names of variables to create. */
char **v;
size_t nv;
do
{
/* Format spec for variables to create. f.type==-1 if default is to
be used. */
struct fmt_spec f;
if (!parse_DATA_LIST_vars (lexer, dataset_dict (ds),
&v, &nv, PV_NO_DUPLICATE))
return CMD_FAILURE;
/* Get the optional format specification. */
if (lex_match (lexer, T_LPAREN))
{
if (!parse_format_specifier (lexer, &f))
goto fail;
if ( ! fmt_check_output (&f))
goto fail;
if (fmt_is_string (f.type))
{
char str[FMT_STRING_LEN_MAX + 1];
msg (SE, _("Format type %s may not be used with a numeric "
"variable."), fmt_to_string (&f, str));
goto fail;
}
if (!lex_match (lexer, T_RPAREN))
{
lex_error_expecting (lexer, "`)'", NULL_SENTINEL);
goto fail;
}
}
else
f.type = -1;
/* Create each variable. */
for (i = 0; i < nv; i++)
{
struct variable *new_var = dict_create_var (dataset_dict (ds), v[i], 0);
if (!new_var)
msg (SE, _("There is already a variable named %s."), v[i]);
else
{
if (f.type != -1)
var_set_both_formats (new_var, &f);
}
}
/* Clean up. */
for (i = 0; i < nv; i++)
free (v[i]);
free (v);
}
while (lex_match (lexer, T_SLASH));
return CMD_SUCCESS;
/* If we have an error at a point where cleanup is required,
flow-of-control comes here. */
fail:
for (i = 0; i < nv; i++)
free (v[i]);
free (v);
return CMD_FAILURE;
}
/* Parses SAVE or XSAVE or EXPORT or XEXPORT command.
WRITER_TYPE identifies the type of file to write,
and COMMAND_TYPE identifies the type of command.
On success, returns a writer.
For procedures only, sets *RETAIN_UNSELECTED to true if cases
that would otherwise be excluded by FILTER or USE should be
included.
On failure, returns a null pointer. */
static struct casewriter *
parse_write_command (struct lexer *lexer, struct dataset *ds,
enum writer_type writer_type,
enum command_type command_type,
bool *retain_unselected)
{
/* Common data. */
struct file_handle *handle; /* Output file. */
struct dictionary *dict; /* Dictionary for output file. */
struct casewriter *writer; /* Writer. */
struct case_map *map; /* Map from input data to data for writer. */
/* Common options. */
bool print_map; /* Print map? TODO. */
bool print_short_names; /* Print long-to-short name map. TODO. */
struct sfm_write_options sysfile_opts;
struct pfm_write_options porfile_opts;
assert (writer_type == SYSFILE_WRITER || writer_type == PORFILE_WRITER);
assert (command_type == XFORM_CMD || command_type == PROC_CMD);
assert ((retain_unselected != NULL) == (command_type == PROC_CMD));
if (command_type == PROC_CMD)
*retain_unselected = true;
handle = NULL;
dict = dict_clone (dataset_dict (ds));
writer = NULL;
map = NULL;
print_map = false;
print_short_names = false;
sysfile_opts = sfm_writer_default_options ();
porfile_opts = pfm_writer_default_options ();
case_map_prepare_dict (dict);
dict_delete_scratch_vars (dict);
lex_match (lexer, T_SLASH);
for (;;)
{
if (lex_match_id (lexer, "OUTFILE"))
{
if (handle != NULL)
{
lex_sbc_only_once ("OUTFILE");
goto error;
}
lex_match (lexer, T_EQUALS);
handle = fh_parse (lexer, FH_REF_FILE, NULL);
if (handle == NULL)
goto error;
}
else if (lex_match_id (lexer, "NAMES"))
print_short_names = true;
else if (lex_match_id (lexer, "PERMISSIONS"))
{
bool cw;
lex_match (lexer, T_EQUALS);
if (lex_match_id (lexer, "READONLY"))
cw = false;
else if (lex_match_id (lexer, "WRITEABLE"))
cw = true;
else
{
lex_error_expecting (lexer, "READONLY", "WRITEABLE",
NULL_SENTINEL);
goto error;
}
sysfile_opts.create_writeable = porfile_opts.create_writeable = cw;
}
else if (command_type == PROC_CMD && lex_match_id (lexer, "UNSELECTED"))
{
lex_match (lexer, T_EQUALS);
if (lex_match_id (lexer, "RETAIN"))
*retain_unselected = true;
else if (lex_match_id (lexer, "DELETE"))
*retain_unselected = false;
else
{
lex_error_expecting (lexer, "RETAIN", "DELETE", NULL_SENTINEL);
goto error;
}
}
else if (writer_type == SYSFILE_WRITER
&& lex_match_id (lexer, "COMPRESSED"))
sysfile_opts.compress = true;
else if (writer_type == SYSFILE_WRITER
&& lex_match_id (lexer, "UNCOMPRESSED"))
sysfile_opts.compress = false;
else if (writer_type == SYSFILE_WRITER
&& lex_match_id (lexer, "VERSION"))
{
lex_match (lexer, T_EQUALS);
if (!lex_force_int (lexer))
goto error;
sysfile_opts.version = lex_integer (lexer);
lex_get (lexer);
}
else if (writer_type == PORFILE_WRITER && lex_match_id (lexer, "TYPE"))
{
lex_match (lexer, T_EQUALS);
if (lex_match_id (lexer, "COMMUNICATIONS"))
porfile_opts.type = PFM_COMM;
else if (lex_match_id (lexer, "TAPE"))
porfile_opts.type = PFM_TAPE;
else
{
lex_error_expecting (lexer, "COMM", "TAPE", NULL_SENTINEL);
goto error;
}
}
else if (writer_type == PORFILE_WRITER && lex_match_id (lexer, "DIGITS"))
{
lex_match (lexer, T_EQUALS);
if (!lex_force_int (lexer))
goto error;
porfile_opts.digits = lex_integer (lexer);
lex_get (lexer);
}
else if (!parse_dict_trim (lexer, dict))
goto error;
if (!lex_match (lexer, T_SLASH))
break;
}
if (lex_end_of_command (lexer) != CMD_SUCCESS)
goto error;
if (handle == NULL)
{
lex_sbc_missing ("OUTFILE");
goto error;
}
dict_delete_scratch_vars (dict);
dict_compact_values (dict);
if (fh_get_referent (handle) == FH_REF_FILE)
{
switch (writer_type)
{
case SYSFILE_WRITER:
writer = sfm_open_writer (handle, dict, sysfile_opts);
break;
case PORFILE_WRITER:
writer = pfm_open_writer (handle, dict, porfile_opts);
break;
}
}
else
writer = any_writer_open (handle, dict);
if (writer == NULL)
goto error;
map = case_map_from_dict (dict);
if (map != NULL)
writer = case_map_create_output_translator (map, writer);
dict_destroy (dict);
fh_unref (handle);
return writer;
error:
fh_unref (handle);
casewriter_destroy (writer);
dict_destroy (dict);
case_map_destroy (map);
return NULL;
}