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., 59 Temple Place - Suite 330, Boston, MA
- 02111-1307, USA. */
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ 02110-1301, USA. */
#include <config.h>
#include "error.h"
#include "vfm.h"
#include "vfmP.h"
+#include "gettext.h"
+#define _(msgid) gettext (msgid)
+
#include "debug-print.h"
/* Rearranging and reducing a dictionary. */
{
OP_READ, /* GET or IMPORT. */
OP_SAVE, /* SAVE or XSAVE. */
- OP_EXPORT, /* EXPORT. */
- OP_MATCH /* MATCH FILES. */
+ OP_EXPORT /* EXPORT. */
};
-static int trim_dictionary (struct dictionary *,
- enum operation, int *compress);
+static bool trim_dictionary (struct dictionary *,
+ enum operation, int *compress);
\f
/* GET input program. */
struct get_pgm
static struct save_trns *
cmd_save_internal (void)
{
- struct file_handle *fh;
+ struct file_handle *fh = NULL;
struct dictionary *dict = NULL;
struct save_trns *t = NULL;
int compress = get_scompression ();
+ const int default_version = 3;
+ int version = default_version;
+ short no_name_table = 0;
t = xmalloc (sizeof *t);
t->h.proc = save_trns_proc;
t->map = NULL;
case_nullify (&t->bounce);
- lex_match ('/');
- if (lex_match_id ("OUTFILE"))
- lex_match ('=');
- fh = fh_parse ();
- if (fh == NULL)
- goto error;
+
+ /* Read most of the subcommands. */
+ for (;;)
+ {
+ if (lex_match_id ("VERSION"))
+ {
+ lex_match ('=');
+ if (lex_force_int ())
+ {
+ version = lex_integer ();
+ lex_get ();
+
+ if (lex_match_id ("X"))
+ no_name_table = 1;
+ }
+ }
+ else if (lex_match_id ("OUTFILE"))
+ {
+ lex_match ('=');
+
+ fh = fh_parse ();
+ if (fh == NULL)
+ goto error;
+
+ }
+ if ( ! lex_match('/') )
+ break;
+
+ }
+
+ if (token != '.')
+ {
+ lex_error (_("expecting end of command"));
+ goto error;
+ }
+
+ if ( fh == NULL )
+ {
+ msg ( ME, _("The required %s subcommand was not present"), "OUTFILE");
+ goto error;
+ }
+
+ if ( version != default_version )
+ {
+ msg (MW, _("Unsupported sysfile version: %d. Using version %d instead."),
+ version, default_version);
+
+ version = default_version;
+ }
dict = dict_clone (default_dict);
start_case_map (dict);
if (t->map != NULL)
case_create (&t->bounce, dict_get_next_value_idx (dict));
- t->writer = sfm_open_writer (fh, dict, compress);
+ t->writer = sfm_open_writer (fh, dict, compress, no_name_table);
if (t->writer == NULL)
goto error;
}
}
-static int rename_variables (struct dictionary *dict);
+static bool rename_variables (struct dictionary *dict);
+static bool drop_variables (struct dictionary *dict);
+static bool keep_variables (struct dictionary *dict);
/* Commands that read and write system files share a great deal
of common syntactic structure for rearranging and dropping
write a system file, *COMPRESS is set to 1 if the system file
should be compressed, 0 otherwise.
- Returns nonzero on success, zero on failure. */
-/* FIXME: IN, FIRST, LAST, MAP. */
-static int
+ Returns true on success, false on failure. */
+static bool
trim_dictionary (struct dictionary *dict, enum operation op, int *compress)
{
assert ((compress != NULL) == (op == OP_SAVE));
free (v);
}
- while (op == OP_MATCH || lex_match ('/'))
+ while (lex_match ('/'))
{
+ bool ok = true;
+
if (op == OP_SAVE && lex_match_id ("COMPRESSED"))
*compress = 1;
else if (op == OP_SAVE && lex_match_id ("UNCOMPRESSED"))
*compress = 0;
else if (lex_match_id ("DROP"))
- {
- struct variable **v;
- int nv;
-
- lex_match ('=');
- if (!parse_variables (dict, &v, &nv, PV_NONE))
- return 0;
- dict_delete_vars (dict, v, nv);
- free (v);
- }
+ ok = drop_variables (dict);
else if (lex_match_id ("KEEP"))
- {
- struct variable **v;
- int nv;
- int i;
-
- lex_match ('=');
- if (!parse_variables (dict, &v, &nv, PV_NONE))
- return 0;
-
- /* Move the specified variables to the beginning. */
- dict_reorder_vars (dict, v, nv);
-
- /* Delete the remaining variables. */
- v = xrealloc (v, (dict_get_var_cnt (dict) - nv) * sizeof *v);
- for (i = nv; i < dict_get_var_cnt (dict); i++)
- v[i - nv] = dict_get_var (dict, i);
- dict_delete_vars (dict, v, dict_get_var_cnt (dict) - nv);
- free (v);
- }
+ ok = keep_variables (dict);
else if (lex_match_id ("RENAME"))
- {
- if (!rename_variables (dict))
- return 0;
- }
+ ok = rename_variables (dict);
else
{
- lex_error (_("while expecting a valid subcommand"));
- return 0;
- }
-
- if (dict_get_var_cnt (dict) == 0)
- {
- msg (SE, _("All variables deleted from system file dictionary."));
- return 0;
+ lex_error (_("expecting a valid subcommand"));
+ ok = false;
}
- if (op == OP_MATCH)
- goto success;
+ if (!ok)
+ return false;
}
- if (token != '.')
- {
- lex_error (_("expecting end of command"));
- return 0;
- }
+ if (!lex_end_of_command ())
+ return false;
- success:
- if (op != OP_MATCH)
- dict_compact_values (dict);
- return 1;
+ dict_compact_values (dict);
+ return true;
}
/* Parses and performs the RENAME subcommand of GET and SAVE. */
-static int
+static bool
rename_variables (struct dictionary *dict)
{
int i;
if (!lex_force_match ('=')
|| !lex_force_id ())
return 0;
- if (!strncmp (tokid, v->name, 8))
- return 1;
if (dict_lookup_var (dict, tokid) != NULL)
{
msg (SE, _("Cannot rename %s as %s because there already exists "
return success;
}
+
+/* Parses and performs the DROP subcommand of GET and SAVE.
+ Returns true if successful, false on failure.*/
+static bool
+drop_variables (struct dictionary *dict)
+{
+ struct variable **v;
+ int nv;
+
+ lex_match ('=');
+ if (!parse_variables (dict, &v, &nv, PV_NONE))
+ return false;
+ dict_delete_vars (dict, v, nv);
+ free (v);
+
+ if (dict_get_var_cnt (dict) == 0)
+ {
+ msg (SE, _("Cannot DROP all variables from dictionary."));
+ return false;
+ }
+ return true;
+}
+
+/* Parses and performs the KEEP subcommand of GET and SAVE.
+ Returns true if successful, false on failure.*/
+static bool
+keep_variables (struct dictionary *dict)
+{
+ struct variable **v;
+ int nv;
+ int i;
+
+ lex_match ('=');
+ if (!parse_variables (dict, &v, &nv, PV_NONE))
+ return false;
+
+ /* Move the specified variables to the beginning. */
+ dict_reorder_vars (dict, v, nv);
+
+ /* Delete the remaining variables. */
+ v = xrealloc (v, (dict_get_var_cnt (dict) - nv) * sizeof *v);
+ for (i = nv; i < dict_get_var_cnt (dict); i++)
+ v[i - nv] = dict_get_var (dict, i);
+ dict_delete_vars (dict, v, dict_get_var_cnt (dict) - nv);
+ free (v);
+
+ return true;
+}
\f
/* EXPORT procedure. */
struct export_proc
struct file_handle *handle; /* File handle. */
struct sfm_reader *reader; /* System file reader. */
struct dictionary *dict; /* Dictionary from system file. */
- char in[9]; /* Name of the variable from IN=. */
- char first[9], last[9]; /* Name of the variables from FIRST=, LAST=. */
+
+ /* IN subcommand. */
+ char *in_name; /* Variable name. */
+ struct variable *in_var; /* Variable (in master dictionary). */
+
struct ccase input; /* Input record. */
};
struct mtf_file *head; /* First file mentioned on FILE or TABLE. */
struct mtf_file *tail; /* Last file mentioned on FILE or TABLE. */
- struct variable **by; /* Variables on the BY subcommand. */
size_t by_cnt; /* Number of variables on BY subcommand. */
+ /* Names of FIRST, LAST variables. */
+ char first[LONG_NAME_LEN + 1], last[LONG_NAME_LEN + 1];
+
struct dictionary *dict; /* Dictionary of output file. */
struct case_sink *sink; /* Sink to receive output. */
- struct ccase *mtf_case; /* Case used for output. */
+ struct ccase mtf_case; /* Case used for output. */
unsigned seq_num; /* Have we initialized this variable? */
unsigned *seq_nums; /* Sequence numbers for each var in dict. */
struct mtf_file *first_table = NULL;
struct mtf_file *iter;
- int seen = 0;
+ bool used_active_file = false;
+ bool saw_table = false;
+ bool saw_in = false;
mtf.head = mtf.tail = NULL;
- mtf.by = NULL;
mtf.by_cnt = 0;
+ mtf.first[0] = '\0';
+ mtf.last[0] = '\0';
mtf.dict = dict_create ();
mtf.sink = NULL;
- mtf.mtf_case = NULL;
+ case_nullify (&mtf.mtf_case);
mtf.seq_num = 0;
mtf.seq_nums = NULL;
dict_set_case_limit (mtf.dict, dict_get_case_limit (default_dict));
-
- do
- {
- lex_match ('/');
- if (lex_match (T_BY))
- {
- if (seen & 1)
- {
- msg (SE, _("The BY subcommand may be given once at most."));
- goto error;
- }
- seen |= 1;
-
- lex_match ('=');
- if (!parse_variables (mtf.dict, &mtf.by, &mtf.by_cnt,
- PV_NO_DUPLICATE | PV_NO_SCRATCH))
- goto error;
- }
- else if (token != T_ID)
- {
- lex_error (NULL);
- goto error;
- }
- else if (lex_id_match ("FILE", tokid) || lex_id_match ("TABLE", tokid))
- {
- struct mtf_file *file = xmalloc (sizeof *file);
+ lex_match ('/');
+ while (token == T_ID
+ && (lex_id_match ("FILE", tokid) || lex_id_match ("TABLE", tokid)))
+ {
+ struct mtf_file *file = xmalloc (sizeof *file);
- if (lex_match_id ("FILE"))
- file->type = MTF_FILE;
- else if (lex_match_id ("TABLE"))
- {
- file->type = MTF_TABLE;
- seen |= 4;
- }
- else
- assert (0);
+ if (lex_match_id ("FILE"))
+ file->type = MTF_FILE;
+ else if (lex_match_id ("TABLE"))
+ {
+ file->type = MTF_TABLE;
+ saw_table = true;
+ }
+ else
+ assert (0);
+ lex_match ('=');
+
+ file->by = NULL;
+ file->handle = NULL;
+ file->reader = NULL;
+ file->dict = NULL;
+ file->in_name = NULL;
+ file->in_var = NULL;
+ case_nullify (&file->input);
+
+ /* FILEs go first, then TABLEs. */
+ if (file->type == MTF_TABLE || first_table == NULL)
+ {
+ file->next = NULL;
+ file->prev = mtf.tail;
+ if (mtf.tail)
+ mtf.tail->next = file;
+ mtf.tail = file;
+ if (mtf.head == NULL)
+ mtf.head = file;
+ if (file->type == MTF_TABLE && first_table == NULL)
+ first_table = file;
+ }
+ else
+ {
+ assert (file->type == MTF_FILE);
+ file->next = first_table;
+ file->prev = first_table->prev;
+ if (first_table->prev)
+ first_table->prev->next = file;
+ else
+ mtf.head = file;
+ first_table->prev = file;
+ }
- file->by = NULL;
+ if (lex_match ('*'))
+ {
file->handle = NULL;
file->reader = NULL;
- file->dict = NULL;
- file->in[0] = '\0';
- file->first[0] = '\0';
- file->last[0] = '\0';
- case_nullify (&file->input);
-
- /* FILEs go first, then TABLEs. */
- if (file->type == MTF_TABLE || first_table == NULL)
- {
- file->next = NULL;
- file->prev = mtf.tail;
- if (mtf.tail)
- mtf.tail->next = file;
- mtf.tail = file;
- if (mtf.head == NULL)
- mtf.head = file;
- if (file->type == MTF_TABLE && first_table == NULL)
- first_table = file;
- }
- else
- {
- assert (file->type == MTF_FILE);
- file->next = first_table;
- file->prev = first_table->prev;
- if (first_table->prev)
- first_table->prev->next = file;
- else
- mtf.head = file;
- first_table->prev = file;
- }
-
- lex_match ('=');
-
- if (lex_match ('*'))
- {
- file->handle = NULL;
- file->reader = NULL;
- if (seen & 2)
- {
- msg (SE, _("The active file may not be specified more "
- "than once."));
- goto error;
- }
- seen |= 2;
-
- assert (pgm_state != STATE_INPUT);
- if (pgm_state == STATE_INIT)
- {
- msg (SE, _("Cannot specify the active file since no active "
- "file has been defined."));
- goto error;
- }
-
- if (temporary != 0)
- {
- msg (SE,
- _("MATCH FILES may not be used after TEMPORARY when "
- "the active file is an input source. "
- "Temporary transformations will be made permanent."));
- cancel_temporary ();
- }
-
- file->dict = default_dict;
- }
- else
- {
- file->handle = fh_parse ();
- if (file->handle == NULL)
- goto error;
-
- file->reader = sfm_open_reader (file->handle, &file->dict, NULL);
- if (file->reader == NULL)
- goto error;
+ if (used_active_file)
+ {
+ msg (SE, _("The active file may not be specified more "
+ "than once."));
+ goto error;
+ }
+ used_active_file = true;
- case_create (&file->input, dict_get_next_value_idx (file->dict));
- }
- }
- else if (lex_id_match ("IN", tokid)
- || lex_id_match ("FIRST", tokid)
- || lex_id_match ("LAST", tokid))
- {
- const char *sbc;
- char *name;
-
- if (mtf.tail == NULL)
- {
- msg (SE, _("IN, FIRST, and LAST subcommands may not occur "
- "before the first FILE or TABLE."));
- goto error;
- }
+ assert (pgm_state != STATE_INPUT);
+ if (pgm_state == STATE_INIT)
+ {
+ msg (SE, _("Cannot specify the active file since no active "
+ "file has been defined."));
+ goto error;
+ }
- if (lex_match_id ("IN"))
- {
- name = mtf.tail->in;
- sbc = "IN";
- }
- else if (lex_match_id ("FIRST"))
- {
- name = mtf.tail->first;
- sbc = "FIRST";
- }
- else if (lex_match_id ("LAST"))
- {
- name = mtf.tail->last;
- sbc = "LAST";
- }
- else
+ if (temporary != 0)
{
- assert (0);
- abort ();
+ msg (SE,
+ _("MATCH FILES may not be used after TEMPORARY when "
+ "the active file is an input source. "
+ "Temporary transformations will be made permanent."));
+ cancel_temporary ();
}
- lex_match ('=');
- if (token != T_ID)
- {
- lex_error (NULL);
- goto error;
- }
+ file->dict = default_dict;
+ }
+ else
+ {
+ file->handle = fh_parse ();
+ if (file->handle == NULL)
+ goto error;
- if (*name)
- {
- msg (SE, _("Multiple %s subcommands for a single FILE or "
- "TABLE."),
- sbc);
- goto error;
- }
- strcpy (name, tokid);
- lex_get ();
+ file->reader = sfm_open_reader (file->handle, &file->dict, NULL);
+ if (file->reader == NULL)
+ goto error;
- if (!dict_create_var (mtf.dict, name, 0))
- {
- msg (SE, _("Duplicate variable name %s while creating %s "
- "variable."),
- name, sbc);
- goto error;
- }
- }
- else if (lex_id_match ("RENAME", tokid)
- || lex_id_match ("KEEP", tokid)
- || lex_id_match ("DROP", tokid))
+ case_create (&file->input, dict_get_next_value_idx (file->dict));
+ }
+
+ while (lex_match ('/'))
+ if (lex_match_id ("RENAME"))
+ {
+ if (!rename_variables (file->dict))
+ goto error;
+ }
+ else if (lex_match_id ("IN"))
+ {
+ lex_match ('=');
+ if (token != T_ID)
+ {
+ lex_error (NULL);
+ goto error;
+ }
+
+ if (file->in_name != NULL)
+ {
+ msg (SE, _("Multiple IN subcommands for a single FILE or "
+ "TABLE."));
+ goto error;
+ }
+ file->in_name = xstrdup (tokid);
+ lex_get ();
+ saw_in = true;
+ }
+
+ mtf_merge_dictionary (mtf.dict, file);
+ }
+
+ while (token != '.')
+ {
+ if (lex_match (T_BY))
{
- if (mtf.tail == NULL)
+ struct variable **by;
+
+ if (mtf.by_cnt)
{
- msg (SE, _("RENAME, KEEP, and DROP subcommands may not occur "
- "before the first FILE or TABLE."));
+ msg (SE, _("BY may appear at most once."));
goto error;
}
-
- if (!trim_dictionary (mtf.tail->dict, OP_MATCH, NULL))
+
+ lex_match ('=');
+ if (!parse_variables (mtf.dict, &by, &mtf.by_cnt,
+ PV_NO_DUPLICATE | PV_NO_SCRATCH))
goto error;
+
+ for (iter = mtf.head; iter != NULL; iter = iter->next)
+ {
+ int i;
+
+ iter->by = xmalloc (sizeof *iter->by * mtf.by_cnt);
+
+ for (i = 0; i < mtf.by_cnt; i++)
+ {
+ iter->by[i] = dict_lookup_var (iter->dict, by[i]->name);
+ if (iter->by[i] == NULL)
+ {
+ msg (SE, _("File %s lacks BY variable %s."),
+ iter->handle ? handle_get_name (iter->handle) : "*",
+ by[i]->name);
+ free (by);
+ goto error;
+ }
+ }
+ }
+ free (by);
}
+ else if (lex_match_id ("FIRST"))
+ {
+ if (mtf.first[0] != '\0')
+ {
+ msg (SE, _("FIRST may appear at most once."));
+ goto error;
+ }
+
+ lex_match ('=');
+ if (!lex_force_id ())
+ goto error;
+ strcpy (mtf.first, tokid);
+ lex_get ();
+ }
+ else if (lex_match_id ("LAST"))
+ {
+ if (mtf.last[0] != '\0')
+ {
+ msg (SE, _("LAST may appear at most once."));
+ goto error;
+ }
+
+ lex_match ('=');
+ if (!lex_force_id ())
+ goto error;
+ strcpy (mtf.last, tokid);
+ lex_get ();
+ }
else if (lex_match_id ("MAP"))
{
/* FIXME. */
}
+ else if (lex_match_id ("DROP"))
+ {
+ if (!drop_variables (mtf.dict))
+ goto error;
+ }
+ else if (lex_match_id ("KEEP"))
+ {
+ if (!keep_variables (mtf.dict))
+ goto error;
+ }
else
{
lex_error (NULL);
goto error;
}
- }
- while (token != '.');
- for (iter = mtf.head; iter != NULL; iter = iter->next)
- mtf_merge_dictionary (mtf.dict, iter);
+ if (!lex_match ('/') && token != '.')
+ {
+ lex_end_of_command ();
+ goto error;
+ }
+ }
- if (seen & 4)
+ if (mtf.by_cnt == 0)
{
- if (!(seen & 1))
- {
- msg (SE, _("The BY subcommand is required when a TABLE subcommand "
- "is given."));
- goto error;
- }
+ if (saw_table)
+ {
+ msg (SE, _("BY is required when TABLE is specified."));
+ goto error;
+ }
+ if (saw_in)
+ {
+ msg (SE, _("BY is required when IN is specified."));
+ goto error;
+ }
}
- if (seen & 1)
+ /* Set up mapping from each file's variables to master
+ variables. */
+ for (iter = mtf.head; iter != NULL; iter = iter->next)
{
- for (iter = mtf.head; iter != NULL; iter = iter->next)
- {
- int i;
-
- iter->by = xmalloc (sizeof *iter->by * mtf.by_cnt);
+ struct dictionary *d = iter->dict;
+ int i;
- for (i = 0; i < mtf.by_cnt; i++)
- {
- iter->by[i] = dict_lookup_var (iter->dict, mtf.by[i]->name);
- if (iter->by[i] == NULL)
- {
- msg (SE, _("File %s lacks BY variable %s."),
- iter->handle ? handle_get_name (iter->handle) : "*",
- mtf.by[i]->name);
- goto error;
- }
- }
- }
+ for (i = 0; i < dict_get_var_cnt (d); i++)
+ {
+ struct variable *v = dict_get_var (d, i);
+ struct variable *mv = dict_lookup_var (mtf.dict, v->name);
+ if (mv != NULL)
+ set_master (v, mv);
+ }
}
+ /* Add IN variables to master dictionary. */
+ for (iter = mtf.head; iter != NULL; iter = iter->next)
+ if (iter->in_name != NULL)
+ {
+ iter->in_var = dict_create_var (mtf.dict, iter->in_name, 0);
+ if (iter->in_var == NULL)
+ {
+ msg (SE, _("IN variable name %s duplicates an "
+ "existing variable name."),
+ iter->in_var->name);
+ goto error;
+ }
+ iter->in_var->print = iter->in_var->write
+ = make_output_format (FMT_F, 1, 0);
+ }
+
/* MATCH FILES performs an n-way merge on all its input files.
Abstract algorithm:
2. If no FILEs are left, stop. Otherwise, proceed to step 3.
- 3. Find the FILE input record with minimum BY values. Store all
- the values from this input record into the output record.
-
- 4. Find all the FILE input records with BY values identical to
- the minimums. Store all the values from these input records into
+ 3. Find the FILE input record(s) that have minimum BY
+ values. Store all the values from these input records into
the output record.
- 5. For every TABLE, read another record as long as the BY values
+ 4. For every TABLE, read another record as long as the BY values
on the TABLE's input record are less than the FILEs' BY values.
If an exact match is found, store all the values from the TABLE
input record into the output record.
- 6. Write the output record.
+ 5. Write the output record.
- 7. Read another record from each input file FILE and TABLE that
+ 6. Read another record from each input file FILE and TABLE that
we stored values from above. If we come to the end of one of the
input files, remove it from the list of input files.
- 8. Repeat from step 2.
+ 7. Repeat from step 2.
- Unfortunately, this algorithm can't be directly implemented
- because there's no function to read a record from the active
- file; instead, it has to be done using callbacks.
+ Unfortunately, this algorithm can't be implemented in a
+ straightforward way because there's no function to read a
+ record from the active file. Instead, it has to be written
+ as a state machine.
FIXME: For merging large numbers of files (more than 10?) a
better algorithm would use a heap for finding minimum
values. */
- if (!(seen & 2))
+ if (!used_active_file)
discard_variables ();
+ dict_compact_values (mtf.dict);
mtf.sink = create_case_sink (&storage_sink_class, mtf.dict, NULL);
+ if (mtf.sink->class->open != NULL)
+ mtf.sink->class->open (mtf.sink);
- mtf.seq_nums = xmalloc (dict_get_var_cnt (mtf.dict)
- * sizeof *mtf.seq_nums);
- memset (mtf.seq_nums, 0,
- dict_get_var_cnt (mtf.dict) * sizeof *mtf.seq_nums);
- mtf.mtf_case = xmalloc (dict_get_case_size (mtf.dict));
+ mtf.seq_nums = xcalloc (dict_get_var_cnt (mtf.dict), sizeof *mtf.seq_nums);
+ case_create (&mtf.mtf_case, dict_get_next_value_idx (mtf.dict));
- mtf_read_nonactive_records (NULL);
- if (seen & 2)
- procedure (mtf_processing, NULL);
- mtf_processing_finish (NULL);
+ mtf_read_nonactive_records (&mtf);
+ if (used_active_file)
+ procedure (mtf_processing, &mtf);
+ mtf_processing_finish (&mtf);
+
+ free_case_source (vfm_source);
+ vfm_source = NULL;
dict_destroy (default_dict);
default_dict = mtf.dict;
return CMD_FAILURE;
}
-/* Repeats 2...8 an arbitrary number of times. */
+/* Repeats 2...7 an arbitrary number of times. */
static void
mtf_processing_finish (void *mtf_)
{
if (file->dict != default_dict)
dict_destroy (file->dict);
case_destroy (&file->input);
+ free (file->in_name);
free (file);
}
for (iter = mtf->head; iter; iter = next)
{
next = iter->next;
-
mtf_free_file (iter);
}
- free (mtf->by);
if (mtf->dict)
dict_destroy (mtf->dict);
+ case_destroy (&mtf->mtf_case);
free (mtf->seq_nums);
}
mtf_delete_file_in_place (struct mtf_proc *mtf, struct mtf_file **file)
{
struct mtf_file *f = *file;
+ int i;
if (f->prev)
f->prev->next = f->next;
mtf->tail = f->prev;
*file = f->next;
- {
- int i;
-
- for (i = 0; i < dict_get_var_cnt (f->dict); i++)
- {
- struct variable *v = dict_get_var (f->dict, i);
- union value *out = case_data_rw (mtf->mtf_case, get_master (v)->fv);
+ if (f->in_var != NULL)
+ case_data_rw (&mtf->mtf_case, f->in_var->fv)->f = 0.;
+ for (i = 0; i < dict_get_var_cnt (f->dict); i++)
+ {
+ struct variable *v = dict_get_var (f->dict, i);
+ struct variable *mv = get_master (v);
+ if (mv != NULL)
+ {
+ union value *out = case_data_rw (&mtf->mtf_case, mv->fv);
- if (v->type == NUMERIC)
- out->f = SYSMIS;
- else
- memset (out->s, ' ', v->width);
- }
- }
+ if (v->type == NUMERIC)
+ out->f = SYSMIS;
+ else
+ memset (out->s, ' ', v->width);
+ }
+ }
mtf_free_file (f);
}
/* Read a record from every input file except the active file. */
static void
-mtf_read_nonactive_records (void *mtf_ UNUSED)
+mtf_read_nonactive_records (void *mtf_)
{
struct mtf_proc *mtf = mtf_;
- struct mtf_file *iter;
+ struct mtf_file *iter, *next;
- for (iter = mtf->head; iter; )
+ for (iter = mtf->head; iter != NULL; iter = next)
{
- if (iter->handle)
- {
- if (!sfm_read_case (iter->reader, &iter->input))
- mtf_delete_file_in_place (mtf, &iter);
- else
- iter = iter->next;
- }
- else
- iter = iter->next;
+ next = iter->next;
+ if (iter->handle && !sfm_read_case (iter->reader, &iter->input))
+ mtf_delete_file_in_place (mtf, &iter);
}
}
struct mtf_file *a, struct mtf_file *b,
struct ccase *c)
{
- struct ccase *a_input, *b_input;
- int i;
-
+ struct ccase *ca = case_is_null (&a->input) ? c : &a->input;
+ struct ccase *cb = case_is_null (&b->input) ? c : &b->input;
assert ((a == NULL) + (b == NULL) + (c == NULL) <= 1);
- a_input = case_is_null (&a->input) ? c : &a->input;
- b_input = case_is_null (&b->input) ? c : &b->input;
- for (i = 0; i < mtf->by_cnt; i++)
- {
- assert (a->by[i]->type == b->by[i]->type);
- assert (a->by[i]->width == b->by[i]->width);
-
- if (a->by[i]->type == NUMERIC)
- {
- double af = case_num (a_input, a->by[i]->fv);
- double bf = case_num (b_input, b->by[i]->fv);
-
- if (af < bf)
- return -1;
- else if (af > bf)
- return 1;
- }
- else
- {
- int result;
-
- assert (a->by[i]->type == ALPHA);
- result = memcmp (case_str (a_input, a->by[i]->fv),
- case_str (b_input, b->by[i]->fv),
- a->by[i]->width);
- if (result < 0)
- return -1;
- else if (result > 0)
- return 1;
- }
- }
- return 0;
+ return case_compare_2dict (ca, cb, a->by, b->by, mtf->by_cnt);
}
/* Perform one iteration of steps 3...7 above. */
static int
-mtf_processing (struct ccase *c, void *mtf_ UNUSED)
+mtf_processing (struct ccase *c, void *mtf_)
{
struct mtf_proc *mtf = mtf_;
- struct mtf_file *min_head, *min_tail; /* Files with minimum BY values. */
- struct mtf_file *max_head, *max_tail; /* Files with non-minimum BY values. */
- struct mtf_file *iter; /* Iterator. */
- for (;;)
+ /* Do we need another record from the active file? */
+ bool read_active_file;
+
+ assert (mtf->head != NULL);
+ if (mtf->head->type == MTF_TABLE)
+ return 1;
+
+ do
{
- /* If the active file doesn't have the minimum BY values, don't
- return because that would cause a record to be skipped. */
- int advance = 1;
+ struct mtf_file *min_head, *min_tail; /* Files with minimum BY values. */
+ struct mtf_file *max_head, *max_tail; /* Files with non-minimum BYs. */
+ struct mtf_file *iter, *next;
- if (mtf->head->type == MTF_TABLE)
- return 0;
+ read_active_file = false;
- /* 3. Find the FILE input record with minimum BY values. Store
- all the values from this input record into the output record.
-
- 4. Find all the FILE input records with BY values identical
- to the minimums. Store all the values from these input
- records into the output record. */
+ /* 3. Find the FILE input record(s) that have minimum BY
+ values. Store all the values from these input records into
+ the output record. */
min_head = min_tail = mtf->head;
max_head = max_tail = NULL;
for (iter = mtf->head->next; iter && iter->type == MTF_FILE;
- iter = iter->next)
- switch (mtf_compare_BY_values (mtf, min_head, iter, c))
- {
- case -1:
- if (max_head)
- max_tail = max_tail->next_min = iter;
- else
- max_head = max_tail = iter;
- break;
-
- case 0:
+ iter = iter->next)
+ {
+ int cmp = mtf_compare_BY_values (mtf, min_head, iter, c);
+ if (cmp < 0)
+ {
+ if (max_head)
+ max_tail = max_tail->next_min = iter;
+ else
+ max_head = max_tail = iter;
+ }
+ else if (cmp == 0)
min_tail = min_tail->next_min = iter;
- break;
-
- case 1:
- if (max_head)
- {
- max_tail->next_min = min_head;
- max_tail = min_tail;
- }
- else
- {
- max_head = min_head;
- max_tail = min_tail;
- }
- min_head = min_tail = iter;
- break;
-
- default:
- assert (0);
- }
-
- /* 5. For every TABLE, read another record as long as the BY
+ else /* cmp > 0 */
+ {
+ if (max_head)
+ {
+ max_tail->next_min = min_head;
+ max_tail = min_tail;
+ }
+ else
+ {
+ max_head = min_head;
+ max_tail = min_tail;
+ }
+ min_head = min_tail = iter;
+ }
+ }
+
+ /* 4. For every TABLE, read another record as long as the BY
values on the TABLE's input record are less than the FILEs'
BY values. If an exact match is found, store all the values
from the TABLE input record into the output record. */
- while (iter)
+ for (; iter != NULL; iter = next)
{
- struct mtf_file *next = iter->next;
-
assert (iter->type == MTF_TABLE);
- if (iter->handle == NULL)
- advance = 0;
-
- again:
- switch (mtf_compare_BY_values (mtf, min_head, iter, c))
- {
- case -1:
- if (max_head)
- max_tail = max_tail->next_min = iter;
- else
- max_head = max_tail = iter;
- break;
-
- case 0:
- min_tail = min_tail->next_min = iter;
- break;
-
- case 1:
- if (iter->handle == NULL)
- return 1;
- if (sfm_read_case (iter->reader, &iter->input))
- goto again;
- mtf_delete_file_in_place (mtf, &iter);
- break;
-
- default:
- assert (0);
- }
-
- iter = next;
+ next = iter->next;
+ for (;;)
+ {
+ int cmp = mtf_compare_BY_values (mtf, min_head, iter, c);
+ if (cmp < 0)
+ {
+ if (max_head)
+ max_tail = max_tail->next_min = iter;
+ else
+ max_head = max_tail = iter;
+ }
+ else if (cmp == 0)
+ min_tail = min_tail->next_min = iter;
+ else /* cmp > 0 */
+ {
+ if (iter->handle == NULL)
+ return 1;
+ if (sfm_read_case (iter->reader, &iter->input))
+ continue;
+ mtf_delete_file_in_place (mtf, &iter);
+ }
+ break;
+ }
}
/* Next sequence number. */
mtf->seq_num++;
-
+
/* Store data to all the records we are using. */
if (min_tail)
min_tail->next_min = NULL;
for (i = 0; i < dict_get_var_cnt (iter->dict); i++)
{
struct variable *v = dict_get_var (iter->dict, i);
- struct ccase *record;
- union value *out;
+ struct variable *mv = get_master (v);
- if (mtf->seq_nums[get_master (v)->index] == mtf->seq_num)
- continue;
- mtf->seq_nums[get_master (v)->index] = mtf->seq_num;
-
- record = case_is_null (&iter->input) ? c : &iter->input;
-
- assert (v->type == NUMERIC || v->type == ALPHA);
- out = case_data_rw (mtf->mtf_case, get_master (v)->fv);
- if (v->type == NUMERIC)
- out->f = case_num (record, v->fv);
- else
- memcpy (out->s, case_str (record, v->fv), v->width);
- }
+ if (mv != NULL && mtf->seq_nums[mv->index] != mtf->seq_num)
+ {
+ struct ccase *record
+ = case_is_null (&iter->input) ? c : &iter->input;
+ union value *out = case_data_rw (&mtf->mtf_case, mv->fv);
+
+ mtf->seq_nums[mv->index] = mtf->seq_num;
+ if (v->type == NUMERIC)
+ out->f = case_num (record, v->fv);
+ else
+ memcpy (out->s, case_str (record, v->fv), v->width);
+ }
+ }
+ if (iter->in_var != NULL)
+ case_data_rw (&mtf->mtf_case, iter->in_var->fv)->f = 1.;
+
+ if (iter->type == MTF_FILE && iter->handle == NULL)
+ read_active_file = true;
}
- /* Store missing values to all the records we're not using. */
+ /* Store missing values to all the records we're not
+ using. */
if (max_tail)
max_tail->next_min = NULL;
for (iter = max_head; iter; iter = iter->next_min)
for (i = 0; i < dict_get_var_cnt (iter->dict); i++)
{
struct variable *v = dict_get_var (iter->dict, i);
- union value *out;
-
- if (mtf->seq_nums[get_master (v)->index] == mtf->seq_num)
- continue;
- mtf->seq_nums[get_master (v)->index] = mtf->seq_num;
-
- out = case_data_rw (mtf->mtf_case, get_master (v)->fv);
- if (v->type == NUMERIC)
- out->f = SYSMIS;
- else
- memset (out->s, ' ', v->width);
- }
+ struct variable *mv = get_master (v);
+
+ if (mv != NULL && mtf->seq_nums[mv->index] != mtf->seq_num)
+ {
+ union value *out = case_data_rw (&mtf->mtf_case, mv->fv);
+ mtf->seq_nums[mv->index] = mtf->seq_num;
- if (iter->handle == NULL)
- advance = 0;
+ if (v->type == NUMERIC)
+ out->f = SYSMIS;
+ else
+ memset (out->s, ' ', v->width);
+ }
+ }
+ if (iter->in_var != NULL)
+ case_data_rw (&mtf->mtf_case, iter->in_var->fv)->f = 0.;
}
- /* 6. Write the output record. */
- mtf->sink->class->write (mtf->sink, mtf->mtf_case);
+ /* 5. Write the output record. */
+ mtf->sink->class->write (mtf->sink, &mtf->mtf_case);
- /* 7. Read another record from each input file FILE and TABLE
+ /* 6. Read another record from each input file FILE and TABLE
that we stored values from above. If we come to the end of
one of the input files, remove it from the list of input
files. */
- for (iter = min_head; iter && iter->type == MTF_FILE; )
+ for (iter = min_head; iter && iter->type == MTF_FILE; iter = next)
{
- struct mtf_file *next = iter->next_min;
-
- if (iter->reader != NULL)
- {
- if (!sfm_read_case (iter->reader, &iter->input))
- mtf_delete_file_in_place (mtf, &iter);
- }
-
- iter = next;
+ next = iter->next_min;
+ if (iter->reader != NULL
+ && !sfm_read_case (iter->reader, &iter->input))
+ mtf_delete_file_in_place (mtf, &iter);
}
-
- if (advance)
- break;
}
+ while (!read_active_file
+ && mtf->head != NULL && mtf->head->type == MTF_FILE);
- return (mtf->head && mtf->head->type != MTF_TABLE);
+ return mtf->head != NULL && mtf->head->type == MTF_FILE;
}
/* Merge the dictionary for file F into master dictionary M. */
{
struct dictionary *d = f->dict;
const char *d_docs, *m_docs;
+ int i;
if (dict_get_label (m) == NULL)
dict_set_label (m, dict_get_label (d));
}
}
- dict_compact_values (d);
+ for (i = 0; i < dict_get_var_cnt (d); i++)
+ {
+ struct variable *dv = dict_get_var (d, i);
+ struct variable *mv = dict_lookup_var (m, dv->name);
- {
- int i;
+ if (dict_class_from_id (dv->name) == DC_SCRATCH)
+ continue;
- for (i = 0; i < dict_get_var_cnt (d); i++)
- {
- struct variable *dv = dict_get_var (d, i);
- struct variable *mv = dict_lookup_var (m, dv->name);
-
- assert (dv->type == ALPHA || dv->width == 0);
- assert (!mv || mv->type == ALPHA || mv->width == 0);
- if (mv && dv->width == mv->width)
- {
- if (val_labs_count (dv->val_labs)
- && !val_labs_count (mv->val_labs))
- mv->val_labs = val_labs_copy (dv->val_labs);
- if (dv->miss_type != MISSING_NONE
- && mv->miss_type == MISSING_NONE)
- copy_missing_values (mv, dv);
- }
- if (mv && dv->label && !mv->label)
- mv->label = xstrdup (dv->label);
- if (!mv)
- {
- mv = dict_clone_var (m, dv, dv->name);
- assert (mv != NULL);
- }
- else if (mv->width != dv->width)
- {
- msg (SE, _("Variable %s in file %s (%s) has different "
- "type or width from the same variable in "
- "earlier file (%s)."),
- dv->name, handle_get_name (f->handle),
- var_type_description (dv), var_type_description (mv));
- return 0;
- }
- set_master (dv, mv);
- }
- }
+ if (mv != NULL)
+ {
+ if (mv->width != dv->width)
+ {
+ msg (SE, _("Variable %s in file %s (%s) has different "
+ "type or width from the same variable in "
+ "earlier file (%s)."),
+ dv->name, handle_get_name (f->handle),
+ var_type_description (dv), var_type_description (mv));
+ return 0;
+ }
+
+ if (dv->width == mv->width)
+ {
+ if (val_labs_count (dv->val_labs)
+ && !val_labs_count (mv->val_labs))
+ mv->val_labs = val_labs_copy (dv->val_labs);
+ if (dv->miss_type != MISSING_NONE
+ && mv->miss_type == MISSING_NONE)
+ copy_missing_values (mv, dv);
+ }
+
+ if (dv->label && !mv->label)
+ mv->label = xstrdup (dv->label);
+ }
+ else
+ mv = dict_clone_var_assert (m, dv, dv->name);
+ }
return 1;
}
static struct variable *
get_master (struct variable *v)
{
- assert (v->aux != NULL);
return v->aux;
}
\f
projects / pspp-builds.git / blobdiff