* casereader-translator.c (struct casereader_translator): Change
[pspp-builds.git] / src / language / data-io / get.c
1 /* PSPP - a program for statistical analysis.
2    Copyright (C) 1997-9, 2000, 2006, 2007 Free Software Foundation, Inc.
3
4    This program is free software: you can redistribute it and/or modify
5    it under the terms of the GNU General Public License as published by
6    the Free Software Foundation, either version 3 of the License, or
7    (at your option) any later version.
8
9    This program is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12    GNU General Public License for more details.
13
14    You should have received a copy of the GNU General Public License
15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
16
17 #include <config.h>
18
19 #include <stdlib.h>
20
21 #include <data/any-reader.h>
22 #include <data/any-writer.h>
23 #include <data/case.h>
24 #include <data/case-map.h>
25 #include <data/casereader.h>
26 #include <data/casewriter.h>
27 #include <data/format.h>
28 #include <data/dictionary.h>
29 #include <data/por-file-writer.h>
30 #include <data/procedure.h>
31 #include <data/settings.h>
32 #include <data/sys-file-writer.h>
33 #include <data/transformations.h>
34 #include <data/value-labels.h>
35 #include <data/variable.h>
36 #include <language/command.h>
37 #include <language/data-io/file-handle.h>
38 #include <language/lexer/lexer.h>
39 #include <language/lexer/variable-parser.h>
40 #include <libpspp/alloc.h>
41 #include <libpspp/assertion.h>
42 #include <libpspp/compiler.h>
43 #include <libpspp/hash.h>
44 #include <libpspp/message.h>
45 #include <libpspp/misc.h>
46 #include <libpspp/str.h>
47 #include <libpspp/taint.h>
48
49 #include "gettext.h"
50 #define _(msgid) gettext (msgid)
51
52 static bool parse_dict_trim (struct lexer *, struct dictionary *);
53 \f
54 /* Reading system and portable files. */
55
56 /* Type of command. */
57 enum reader_command
58   {
59     GET_CMD,
60     IMPORT_CMD
61   };
62
63 static void get_translate_case (struct ccase *, struct ccase *, void *map_);
64 static bool get_destroy_case_map (void *map_);
65
66 /* Parses a GET or IMPORT command. */
67 static int
68 parse_read_command (struct lexer *lexer, struct dataset *ds, enum reader_command type)
69 {
70   struct casereader *reader = NULL;
71   struct file_handle *fh = NULL;
72   struct dictionary *dict = NULL;
73   struct case_map *map = NULL;
74
75   for (;;)
76     {
77       lex_match (lexer, '/');
78
79       if (lex_match_id (lexer, "FILE") || lex_token (lexer) == T_STRING)
80         {
81           lex_match (lexer, '=');
82
83           fh = fh_parse (lexer, FH_REF_FILE | FH_REF_SCRATCH);
84           if (fh == NULL)
85             goto error;
86         }
87       else if (type == IMPORT_CMD && lex_match_id (lexer, "TYPE"))
88         {
89           lex_match (lexer, '=');
90
91           if (lex_match_id (lexer, "COMM"))
92             type = PFM_COMM;
93           else if (lex_match_id (lexer, "TAPE"))
94             type = PFM_TAPE;
95           else
96             {
97               lex_error (lexer, _("expecting COMM or TAPE"));
98               goto error;
99             }
100         }
101       else
102         break;
103     }
104
105   if (fh == NULL)
106     {
107       lex_sbc_missing (lexer, "FILE");
108       goto error;
109     }
110
111   reader = any_reader_open (fh, &dict);
112   if (reader == NULL)
113     goto error;
114
115   case_map_prepare_dict (dict);
116
117   while (lex_token (lexer) != '.')
118     {
119       lex_match (lexer, '/');
120       if (!parse_dict_trim (lexer, dict))
121         goto error;
122     }
123   dict_compact_values (dict);
124
125   map = case_map_from_dict (dict);
126   if (map != NULL)
127     reader = casereader_create_translator (reader,
128                                            dict_get_next_value_idx (dict),
129                                            get_translate_case,
130                                            get_destroy_case_map,
131                                            map);
132
133   proc_set_active_file (ds, reader, dict);
134
135   return CMD_SUCCESS;
136
137  error:
138   casereader_destroy (reader);
139   if (dict != NULL)
140     dict_destroy (dict);
141   return CMD_CASCADING_FAILURE;
142 }
143
144 static void
145 get_translate_case (struct ccase *input, struct ccase *output,
146                     void *map_)
147 {
148   struct case_map *map = map_;
149   case_map_execute (map, input, output);
150   case_destroy (input);
151 }
152
153 static bool
154 get_destroy_case_map (void *map_)
155 {
156   struct case_map *map = map_;
157   case_map_destroy (map);
158   return true;
159 }
160 \f
161 /* GET. */
162 int
163 cmd_get (struct lexer *lexer, struct dataset *ds)
164 {
165   return parse_read_command (lexer, ds, GET_CMD);
166 }
167
168 /* IMPORT. */
169 int
170 cmd_import (struct lexer *lexer, struct dataset *ds)
171 {
172   return parse_read_command (lexer, ds, IMPORT_CMD);
173 }
174 \f
175 /* Writing system and portable files. */
176
177 /* Type of output file. */
178 enum writer_type
179   {
180     SYSFILE_WRITER,     /* System file. */
181     PORFILE_WRITER      /* Portable file. */
182   };
183
184 /* Type of a command. */
185 enum command_type
186   {
187     XFORM_CMD,          /* Transformation. */
188     PROC_CMD            /* Procedure. */
189   };
190
191 /* Parses SAVE or XSAVE or EXPORT or XEXPORT command.
192    WRITER_TYPE identifies the type of file to write,
193    and COMMAND_TYPE identifies the type of command.
194
195    On success, returns a writer.
196    For procedures only, sets *RETAIN_UNSELECTED to true if cases
197    that would otherwise be excluded by FILTER or USE should be
198    included.
199
200    On failure, returns a null pointer. */
201 static struct casewriter *
202 parse_write_command (struct lexer *lexer, struct dataset *ds,
203                      enum writer_type writer_type,
204                      enum command_type command_type,
205                      bool *retain_unselected)
206 {
207   /* Common data. */
208   struct file_handle *handle; /* Output file. */
209   struct dictionary *dict;    /* Dictionary for output file. */
210   struct casewriter *writer;  /* Writer. */
211   struct case_map *map;       /* Map from input data to data for writer. */
212
213   /* Common options. */
214   bool print_map;             /* Print map?  TODO. */
215   bool print_short_names;     /* Print long-to-short name map.  TODO. */
216   struct sfm_write_options sysfile_opts;
217   struct pfm_write_options porfile_opts;
218
219   assert (writer_type == SYSFILE_WRITER || writer_type == PORFILE_WRITER);
220   assert (command_type == XFORM_CMD || command_type == PROC_CMD);
221   assert ((retain_unselected != NULL) == (command_type == PROC_CMD));
222
223   if (command_type == PROC_CMD)
224     *retain_unselected = true;
225
226   handle = NULL;
227   dict = dict_clone (dataset_dict (ds));
228   writer = NULL;
229   map = NULL;
230   print_map = false;
231   print_short_names = false;
232   sysfile_opts = sfm_writer_default_options ();
233   porfile_opts = pfm_writer_default_options ();
234
235   case_map_prepare_dict (dict);
236   dict_delete_scratch_vars (dict);
237
238   lex_match (lexer, '/');
239   for (;;)
240     {
241       if (lex_match_id (lexer, "OUTFILE"))
242         {
243           if (handle != NULL)
244             {
245               lex_sbc_only_once ("OUTFILE");
246               goto error;
247             }
248
249           lex_match (lexer, '=');
250
251           handle = fh_parse (lexer, FH_REF_FILE | FH_REF_SCRATCH);
252           if (handle == NULL)
253             goto error;
254         }
255       else if (lex_match_id (lexer, "NAMES"))
256         print_short_names = true;
257       else if (lex_match_id (lexer, "PERMISSIONS"))
258         {
259           bool cw;
260
261           lex_match (lexer, '=');
262           if (lex_match_id (lexer, "READONLY"))
263             cw = false;
264           else if (lex_match_id (lexer, "WRITEABLE"))
265             cw = true;
266           else
267             {
268               lex_error (lexer, _("expecting %s or %s"), "READONLY", "WRITEABLE");
269               goto error;
270             }
271           sysfile_opts.create_writeable = porfile_opts.create_writeable = cw;
272         }
273       else if (command_type == PROC_CMD && lex_match_id (lexer, "UNSELECTED"))
274         {
275           lex_match (lexer, '=');
276           if (lex_match_id (lexer, "RETAIN"))
277             *retain_unselected = true;
278           else if (lex_match_id (lexer, "DELETE"))
279             *retain_unselected = false;
280           else
281             {
282               lex_error (lexer, _("expecting %s or %s"), "RETAIN", "DELETE");
283               goto error;
284             }
285         }
286       else if (writer_type == SYSFILE_WRITER && lex_match_id (lexer, "COMPRESSED"))
287         sysfile_opts.compress = true;
288       else if (writer_type == SYSFILE_WRITER && lex_match_id (lexer, "UNCOMPRESSED"))
289         sysfile_opts.compress = false;
290       else if (writer_type == SYSFILE_WRITER && lex_match_id (lexer, "VERSION"))
291         {
292           lex_match (lexer, '=');
293           if (!lex_force_int (lexer))
294             goto error;
295           sysfile_opts.version = lex_integer (lexer);
296           lex_get (lexer);
297         }
298       else if (writer_type == PORFILE_WRITER && lex_match_id (lexer, "TYPE"))
299         {
300           lex_match (lexer, '=');
301           if (lex_match_id (lexer, "COMMUNICATIONS"))
302             porfile_opts.type = PFM_COMM;
303           else if (lex_match_id (lexer, "TAPE"))
304             porfile_opts.type = PFM_TAPE;
305           else
306             {
307               lex_error (lexer, _("expecting %s or %s"), "COMM", "TAPE");
308               goto error;
309             }
310         }
311       else if (writer_type == PORFILE_WRITER && lex_match_id (lexer, "DIGITS"))
312         {
313           lex_match (lexer, '=');
314           if (!lex_force_int (lexer))
315             goto error;
316           porfile_opts.digits = lex_integer (lexer);
317           lex_get (lexer);
318         }
319       else if (!parse_dict_trim (lexer, dict))
320         goto error;
321
322       if (!lex_match (lexer, '/'))
323         break;
324     }
325   if (lex_end_of_command (lexer) != CMD_SUCCESS)
326     goto error;
327
328   if (handle == NULL)
329     {
330       lex_sbc_missing (lexer, "OUTFILE");
331       goto error;
332     }
333
334   dict_delete_scratch_vars (dict);
335   dict_compact_values (dict);
336
337   if (fh_get_referent (handle) == FH_REF_FILE)
338     {
339       switch (writer_type)
340         {
341         case SYSFILE_WRITER:
342           writer = sfm_open_writer (handle, dict, sysfile_opts);
343           break;
344         case PORFILE_WRITER:
345           writer = pfm_open_writer (handle, dict, porfile_opts);
346           break;
347         }
348     }
349   else
350     writer = any_writer_open (handle, dict);
351   if (writer == NULL)
352     goto error;
353
354   map = case_map_from_dict (dict);
355   if (map != NULL)
356     writer = casewriter_create_translator (writer,
357                                            case_map_get_value_cnt (map),
358                                            get_translate_case,
359                                            get_destroy_case_map,
360                                            map);
361   dict_destroy (dict);
362
363   return writer;
364
365  error:
366   casewriter_destroy (writer);
367   dict_destroy (dict);
368   case_map_destroy (map);
369   return NULL;
370 }
371 \f
372 /* SAVE and EXPORT. */
373
374 /* Parses and performs the SAVE or EXPORT procedure. */
375 static int
376 parse_output_proc (struct lexer *lexer, struct dataset *ds, enum writer_type writer_type)
377 {
378   bool retain_unselected;
379   struct variable *saved_filter_variable;
380   struct casewriter *output;
381   bool ok;
382
383   output = parse_write_command (lexer, ds, writer_type, PROC_CMD,
384                                 &retain_unselected);
385   if (output == NULL)
386     return CMD_CASCADING_FAILURE;
387
388   saved_filter_variable = dict_get_filter (dataset_dict (ds));
389   if (retain_unselected)
390     dict_set_filter (dataset_dict (ds), NULL);
391
392   casereader_transfer (proc_open (ds), output);
393   ok = casewriter_destroy (output);
394   ok = proc_commit (ds) && ok;
395
396   dict_set_filter (dataset_dict (ds), saved_filter_variable);
397
398   return ok ? CMD_SUCCESS : CMD_CASCADING_FAILURE;
399 }
400
401 int
402 cmd_save (struct lexer *lexer, struct dataset *ds)
403 {
404   return parse_output_proc (lexer, ds, SYSFILE_WRITER);
405 }
406
407 int
408 cmd_export (struct lexer *lexer, struct dataset *ds)
409 {
410   return parse_output_proc (lexer, ds, PORFILE_WRITER);
411 }
412 \f
413 /* XSAVE and XEXPORT. */
414
415 /* Transformation. */
416 struct output_trns
417   {
418     struct casewriter *writer;          /* Writer. */
419   };
420
421 static trns_proc_func output_trns_proc;
422 static trns_free_func output_trns_free;
423
424 /* Parses the XSAVE or XEXPORT transformation command. */
425 static int
426 parse_output_trns (struct lexer *lexer, struct dataset *ds, enum writer_type writer_type)
427 {
428   struct output_trns *t = xmalloc (sizeof *t);
429   t->writer = parse_write_command (lexer, ds, writer_type, XFORM_CMD, NULL);
430   if (t->writer == NULL)
431     {
432       free (t);
433       return CMD_CASCADING_FAILURE;
434     }
435
436   add_transformation (ds, output_trns_proc, output_trns_free, t);
437   return CMD_SUCCESS;
438 }
439
440 /* Writes case C to the system file specified on XSAVE or XEXPORT. */
441 static int
442 output_trns_proc (void *trns_, struct ccase *c, casenumber case_num UNUSED)
443 {
444   struct output_trns *t = trns_;
445   struct ccase tmp;
446   case_clone (&tmp, c);
447   casewriter_write (t->writer, &tmp);
448   return TRNS_CONTINUE;
449 }
450
451 /* Frees an XSAVE or XEXPORT transformation.
452    Returns true if successful, false if an I/O error occurred. */
453 static bool
454 output_trns_free (void *trns_)
455 {
456   struct output_trns *t = trns_;
457   bool ok = casewriter_destroy (t->writer);
458   free (t);
459   return ok;
460 }
461
462 /* XSAVE command. */
463 int
464 cmd_xsave (struct lexer *lexer, struct dataset *ds)
465 {
466   return parse_output_trns (lexer, ds, SYSFILE_WRITER);
467 }
468
469 /* XEXPORT command. */
470 int
471 cmd_xexport (struct lexer *lexer, struct dataset *ds)
472 {
473   return parse_output_trns (lexer, ds, PORFILE_WRITER);
474 }
475 \f
476 static bool rename_variables (struct lexer *lexer, struct dictionary *dict);
477 static bool drop_variables (struct lexer *, struct dictionary *dict);
478 static bool keep_variables (struct lexer *, struct dictionary *dict);
479
480 /* Commands that read and write system files share a great deal
481    of common syntactic structure for rearranging and dropping
482    variables.  This function parses this syntax and modifies DICT
483    appropriately.  Returns true on success, false on failure. */
484 static bool
485 parse_dict_trim (struct lexer *lexer, struct dictionary *dict)
486 {
487   if (lex_match_id (lexer, "MAP"))
488     {
489       /* FIXME. */
490       return true;
491     }
492   else if (lex_match_id (lexer, "DROP"))
493     return drop_variables (lexer, dict);
494   else if (lex_match_id (lexer, "KEEP"))
495     return keep_variables (lexer, dict);
496   else if (lex_match_id (lexer, "RENAME"))
497     return rename_variables (lexer, dict);
498   else
499     {
500       lex_error (lexer, _("expecting a valid subcommand"));
501       return false;
502     }
503 }
504
505 /* Parses and performs the RENAME subcommand of GET and SAVE. */
506 static bool
507 rename_variables (struct lexer *lexer, struct dictionary *dict)
508 {
509   size_t i;
510
511   int success = 0;
512
513   struct variable **v;
514   char **new_names;
515   size_t nv, nn;
516   char *err_name;
517
518   int group;
519
520   lex_match (lexer, '=');
521   if (lex_token (lexer) != '(')
522     {
523       struct variable *v;
524
525       v = parse_variable (lexer, dict);
526       if (v == NULL)
527         return 0;
528       if (!lex_force_match (lexer, '=')
529           || !lex_force_id (lexer))
530         return 0;
531       if (dict_lookup_var (dict, lex_tokid (lexer)) != NULL)
532         {
533           msg (SE, _("Cannot rename %s as %s because there already exists "
534                      "a variable named %s.  To rename variables with "
535                      "overlapping names, use a single RENAME subcommand "
536                      "such as \"/RENAME (A=B)(B=C)(C=A)\", or equivalently, "
537                      "\"/RENAME (A B C=B C A)\"."),
538                var_get_name (v), lex_tokid (lexer), lex_tokid (lexer));
539           return 0;
540         }
541
542       dict_rename_var (dict, v, lex_tokid (lexer));
543       lex_get (lexer);
544       return 1;
545     }
546
547   nv = nn = 0;
548   v = NULL;
549   new_names = 0;
550   group = 1;
551   while (lex_match (lexer, '('))
552     {
553       size_t old_nv = nv;
554
555       if (!parse_variables (lexer, dict, &v, &nv, PV_NO_DUPLICATE | PV_APPEND))
556         goto done;
557       if (!lex_match (lexer, '='))
558         {
559           msg (SE, _("`=' expected after variable list."));
560           goto done;
561         }
562       if (!parse_DATA_LIST_vars (lexer, &new_names, &nn, PV_APPEND | PV_NO_SCRATCH))
563         goto done;
564       if (nn != nv)
565         {
566           msg (SE, _("Number of variables on left side of `=' (%d) does not "
567                      "match number of variables on right side (%d), in "
568                      "parenthesized group %d of RENAME subcommand."),
569                (unsigned) (nv - old_nv), (unsigned) (nn - old_nv), group);
570           goto done;
571         }
572       if (!lex_force_match (lexer, ')'))
573         goto done;
574       group++;
575     }
576
577   if (!dict_rename_vars (dict, v, new_names, nv, &err_name))
578     {
579       msg (SE, _("Requested renaming duplicates variable name %s."), err_name);
580       goto done;
581     }
582   success = 1;
583
584  done:
585   for (i = 0; i < nn; i++)
586     free (new_names[i]);
587   free (new_names);
588   free (v);
589
590   return success;
591 }
592
593 /* Parses and performs the DROP subcommand of GET and SAVE.
594    Returns true if successful, false on failure.*/
595 static bool
596 drop_variables (struct lexer *lexer, struct dictionary *dict)
597 {
598   struct variable **v;
599   size_t nv;
600
601   lex_match (lexer, '=');
602   if (!parse_variables (lexer, dict, &v, &nv, PV_NONE))
603     return false;
604   dict_delete_vars (dict, v, nv);
605   free (v);
606
607   if (dict_get_var_cnt (dict) == 0)
608     {
609       msg (SE, _("Cannot DROP all variables from dictionary."));
610       return false;
611     }
612   return true;
613 }
614
615 /* Parses and performs the KEEP subcommand of GET and SAVE.
616    Returns true if successful, false on failure.*/
617 static bool
618 keep_variables (struct lexer *lexer, struct dictionary *dict)
619 {
620   struct variable **v;
621   size_t nv;
622   size_t i;
623
624   lex_match (lexer, '=');
625   if (!parse_variables (lexer, dict, &v, &nv, PV_NONE))
626     return false;
627
628   /* Move the specified variables to the beginning. */
629   dict_reorder_vars (dict, v, nv);
630
631   /* Delete the remaining variables. */
632   v = xnrealloc (v, dict_get_var_cnt (dict) - nv, sizeof *v);
633   for (i = nv; i < dict_get_var_cnt (dict); i++)
634     v[i - nv] = dict_get_var (dict, i);
635   dict_delete_vars (dict, v, dict_get_var_cnt (dict) - nv);
636   free (v);
637
638   return true;
639 }
640 \f
641 /* MATCH FILES. */
642
643 /* File types. */
644 enum mtf_type
645   {
646     MTF_FILE,                   /* Specified on FILE= subcommand. */
647     MTF_TABLE                   /* Specified on TABLE= subcommand. */
648   };
649
650 /* One of the FILEs or TABLEs on MATCH FILES. */
651 struct mtf_file
652   {
653     struct ll ll;               /* In list of all files and tables. */
654
655     enum mtf_type type;
656     int sequence;
657
658     const struct variable **by; /* List of BY variables for this file. */
659     struct mtf_variable *vars;  /* Variables to copy to output. */
660     size_t var_cnt;             /* Number of other variables. */
661
662     struct file_handle *handle; /* Input file handle. */
663     struct dictionary *dict;    /* Input file dictionary. */
664     struct casereader *reader;  /* Input reader. */
665     struct ccase input;         /* Input record (null at end of file). */
666
667     /* IN subcommand. */
668     char *in_name;              /* Variable name. */
669     struct variable *in_var;    /* Variable (in master dictionary). */
670   };
671
672 struct mtf_variable
673   {
674     struct variable *in_var;
675     struct variable *out_var;
676   };
677
678 /* MATCH FILES procedure. */
679 struct mtf_proc
680   {
681     struct ll_list files;       /* List of "struct mtf_file"s. */
682     int nonempty_files;         /* FILEs that are not at end-of-file. */
683
684     bool ok;                    /* False if I/O error occurs. */
685
686     struct dictionary *dict;    /* Dictionary of output file. */
687     struct casewriter *output;  /* MATCH FILES output. */
688
689     size_t by_cnt;              /* Number of variables on BY subcommand. */
690
691     /* FIRST, LAST.
692        Only if "first" or "last" is nonnull are the remaining
693        members used. */
694     struct variable *first;     /* Variable specified on FIRST (if any). */
695     struct variable *last;      /* Variable specified on LAST (if any). */
696     struct ccase buffered_case; /* Case ready for output except that we don't
697                                    know the value for the LAST variable yet. */
698     struct ccase prev_BY_case;  /* Case with values of last set of BY vars. */
699     const struct variable **prev_BY;  /* Last set of BY variables. */
700   };
701
702 static void mtf_free (struct mtf_proc *);
703
704 static bool mtf_close_all_files (struct mtf_proc *);
705 static bool mtf_merge_dictionary (struct dictionary *const, struct mtf_file *);
706 static bool mtf_read_record (struct mtf_proc *mtf, struct mtf_file *);
707
708 static void mtf_process_case (struct mtf_proc *);
709
710 static bool create_flag_var (const char *subcommand_name, const char *var_name,
711                              struct dictionary *, struct variable **);
712 static char *var_type_description (struct variable *);
713
714 /* Parse and execute the MATCH FILES command. */
715 int
716 cmd_match_files (struct lexer *lexer, struct dataset *ds)
717 {
718   struct mtf_proc mtf;
719   struct ll *first_table;
720   struct mtf_file *file, *next;
721
722   bool saw_in = false;
723   struct casereader *active_file = NULL;
724
725   char first_name[LONG_NAME_LEN + 1] = "";
726   char last_name[LONG_NAME_LEN + 1] = "";
727
728   struct taint *taint = NULL;
729
730   size_t i;
731
732   ll_init (&mtf.files);
733   mtf.nonempty_files = 0;
734   first_table = ll_null (&mtf.files);
735   mtf.dict = dict_create ();
736   mtf.output = NULL;
737   mtf.by_cnt = 0;
738   mtf.first = mtf.last = NULL;
739   case_nullify (&mtf.buffered_case);
740   case_nullify (&mtf.prev_BY_case);
741   mtf.prev_BY = NULL;
742
743   dict_set_case_limit (mtf.dict, dict_get_case_limit (dataset_dict (ds)));
744
745   lex_match (lexer, '/');
746   while (lex_token (lexer) == T_ID
747          && (lex_id_match (ss_cstr ("FILE"), ss_cstr (lex_tokid (lexer)))
748              || lex_id_match (ss_cstr ("TABLE"), ss_cstr (lex_tokid (lexer)))))
749     {
750       struct mtf_file *file = xmalloc (sizeof *file);
751       file->by = NULL;
752       file->handle = NULL;
753       file->reader = NULL;
754       file->dict = NULL;
755       file->in_name = NULL;
756       file->in_var = NULL;
757       file->var_cnt = 0;
758       file->vars = NULL;
759       case_nullify (&file->input);
760
761       if (lex_match_id (lexer, "FILE"))
762         {
763           file->type = MTF_FILE;
764           ll_insert (first_table, &file->ll);
765           mtf.nonempty_files++;
766         }
767       else if (lex_match_id (lexer, "TABLE"))
768         {
769           file->type = MTF_TABLE;
770           ll_push_tail (&mtf.files, &file->ll);
771           if (first_table == ll_null (&mtf.files))
772             first_table = &file->ll;
773         }
774       else
775         NOT_REACHED ();
776       lex_match (lexer, '=');
777
778       if (lex_match (lexer, '*'))
779         {
780           if (!proc_has_active_file (ds))
781             {
782               msg (SE, _("Cannot specify the active file since no active "
783                          "file has been defined."));
784               goto error;
785             }
786
787           if (proc_make_temporary_transformations_permanent (ds))
788             msg (SE,
789                  _("MATCH FILES may not be used after TEMPORARY when "
790                    "the active file is an input source.  "
791                    "Temporary transformations will be made permanent."));
792
793           file->dict = dict_clone (dataset_dict (ds));
794         }
795       else
796         {
797           file->handle = fh_parse (lexer, FH_REF_FILE | FH_REF_SCRATCH);
798           if (file->handle == NULL)
799             goto error;
800
801           file->reader = any_reader_open (file->handle, &file->dict);
802           if (file->reader == NULL)
803             goto error;
804         }
805
806       while (lex_match (lexer, '/'))
807         if (lex_match_id (lexer, "RENAME"))
808           {
809             if (!rename_variables (lexer, file->dict))
810               goto error;
811           }
812         else if (lex_match_id (lexer, "IN"))
813           {
814             lex_match (lexer, '=');
815             if (lex_token (lexer) != T_ID)
816               {
817                 lex_error (lexer, NULL);
818                 goto error;
819               }
820
821             if (file->in_name != NULL)
822               {
823                 msg (SE, _("Multiple IN subcommands for a single FILE or "
824                            "TABLE."));
825                 goto error;
826               }
827             file->in_name = xstrdup (lex_tokid (lexer));
828             lex_get (lexer);
829             saw_in = true;
830           }
831
832       mtf_merge_dictionary (mtf.dict, file);
833     }
834
835   while (lex_token (lexer) != '.')
836     {
837       if (lex_match (lexer, T_BY))
838         {
839           struct mtf_file *file;
840           struct variable **by;
841           bool ok;
842
843           if (mtf.by_cnt)
844             {
845               lex_sbc_only_once ("BY");
846               goto error;
847             }
848
849           lex_match (lexer, '=');
850           if (!parse_variables (lexer, mtf.dict, &by, &mtf.by_cnt,
851                                 PV_NO_DUPLICATE | PV_NO_SCRATCH))
852             goto error;
853
854           ok = true;
855           ll_for_each (file, struct mtf_file, ll, &mtf.files)
856             {
857               size_t i;
858
859               file->by = xnmalloc (mtf.by_cnt, sizeof *file->by);
860               for (i = 0; i < mtf.by_cnt; i++)
861                 {
862                   const char *var_name = var_get_name (by[i]);
863                   file->by[i] = dict_lookup_var (file->dict, var_name);
864                   if (file->by[i] == NULL)
865                     {
866                       if (file->handle != NULL)
867                         msg (SE, _("File %s lacks BY variable %s."),
868                              fh_get_name (file->handle), var_name);
869                       else
870                         msg (SE, _("Active file lacks BY variable %s."),
871                              var_name);
872                       ok = false;
873                     }
874                 }
875             }
876           free (by);
877
878           if (!ok)
879             goto error;
880         }
881       else if (lex_match_id (lexer, "FIRST"))
882         {
883           if (first_name[0] != '\0')
884             {
885               lex_sbc_only_once ("FIRST");
886               goto error;
887             }
888
889           lex_match (lexer, '=');
890           if (!lex_force_id (lexer))
891             goto error;
892           strcpy (first_name, lex_tokid (lexer));
893           lex_get (lexer);
894         }
895       else if (lex_match_id (lexer, "LAST"))
896         {
897           if (last_name[0] != '\0')
898             {
899               lex_sbc_only_once ("LAST");
900               goto error;
901             }
902
903           lex_match (lexer, '=');
904           if (!lex_force_id (lexer))
905             goto error;
906           strcpy (last_name, lex_tokid (lexer));
907           lex_get (lexer);
908         }
909       else if (lex_match_id (lexer, "MAP"))
910         {
911           /* FIXME. */
912         }
913       else if (lex_match_id (lexer, "DROP"))
914         {
915           if (!drop_variables (lexer, mtf.dict))
916             goto error;
917         }
918       else if (lex_match_id (lexer, "KEEP"))
919         {
920           if (!keep_variables (lexer, mtf.dict))
921             goto error;
922         }
923       else
924         {
925           lex_error (lexer, NULL);
926           goto error;
927         }
928
929       if (!lex_match (lexer, '/') && lex_token (lexer) != '.')
930         {
931           lex_end_of_command (lexer);
932           goto error;
933         }
934     }
935
936   if (mtf.by_cnt == 0)
937     {
938       if (first_table != ll_null (&mtf.files))
939         {
940           msg (SE, _("BY is required when TABLE is specified."));
941           goto error;
942         }
943       if (saw_in)
944         {
945           msg (SE, _("BY is required when IN is specified."));
946           goto error;
947         }
948     }
949
950   /* Set up mapping from each file's variables to master
951      variables. */
952   ll_for_each (file, struct mtf_file, ll, &mtf.files)
953     {
954       size_t in_var_cnt = dict_get_var_cnt (file->dict);
955
956       file->vars = xnmalloc (in_var_cnt, sizeof *file->vars);
957       file->var_cnt = 0;
958       for (i = 0; i < in_var_cnt; i++)
959         {
960           struct variable *in_var = dict_get_var (file->dict, i);
961           struct variable *out_var = dict_lookup_var (mtf.dict,
962                                                       var_get_name (in_var));
963
964           if (out_var != NULL)
965             {
966               struct mtf_variable *mv = &file->vars[file->var_cnt++];
967               mv->in_var = in_var;
968               mv->out_var = out_var;
969             }
970         }
971     }
972
973   /* Add IN, FIRST, and LAST variables to master dictionary. */
974   ll_for_each (file, struct mtf_file, ll, &mtf.files)
975     if (!create_flag_var ("IN", file->in_name, mtf.dict, &file->in_var))
976       goto error;
977   if (!create_flag_var ("FIRST", first_name, mtf.dict, &mtf.first)
978       || !create_flag_var ("LAST", last_name, mtf.dict, &mtf.last))
979     goto error;
980
981   dict_delete_scratch_vars (mtf.dict);
982   dict_compact_values (mtf.dict);
983   mtf.output = autopaging_writer_create (dict_get_next_value_idx (mtf.dict));
984   taint = taint_clone (casewriter_get_taint (mtf.output));
985
986   ll_for_each (file, struct mtf_file, ll, &mtf.files)
987     {
988       if (file->reader == NULL)
989         {
990           if (active_file == NULL)
991             {
992               proc_discard_output (ds);
993               file->reader = active_file = proc_open (ds);
994             }
995           else
996             file->reader = casereader_clone (active_file);
997         }
998       taint_propagate (casereader_get_taint (file->reader), taint);
999     }
1000
1001   ll_for_each_safe (file, next, struct mtf_file, ll, &mtf.files)
1002     mtf_read_record (&mtf, file);
1003   while (mtf.nonempty_files > 0)
1004     mtf_process_case (&mtf);
1005   if ((mtf.first != NULL || mtf.last != NULL) && mtf.prev_BY != NULL)
1006     {
1007       if (mtf.last != NULL)
1008         case_data_rw (&mtf.buffered_case, mtf.last)->f = 1.0;
1009       casewriter_write (mtf.output, &mtf.buffered_case);
1010       case_nullify (&mtf.buffered_case);
1011     }
1012   mtf_close_all_files (&mtf);
1013   if (active_file != NULL)
1014     proc_commit (ds);
1015
1016   proc_set_active_file (ds, casewriter_make_reader (mtf.output), mtf.dict);
1017   mtf.dict = NULL;
1018   mtf.output = NULL;
1019
1020   mtf_free (&mtf);
1021
1022   return taint_destroy (taint) ? CMD_SUCCESS : CMD_CASCADING_FAILURE;
1023
1024  error:
1025   if (active_file != NULL)
1026     proc_commit (ds);
1027   mtf_free (&mtf);
1028   taint_destroy (taint);
1029   return CMD_CASCADING_FAILURE;
1030 }
1031
1032 /* If VAR_NAME is a nonnull pointer to a non-empty string,
1033    attempts to create a variable named VAR_NAME, with format
1034    F1.0, in DICT, and stores a pointer to the variable in *VAR.
1035    Returns true if successful, false if the variable name is a
1036    duplicate (in which case a message saying that the variable
1037    specified on the given SUBCOMMAND is a duplicate is emitted).
1038    Also returns true, without doing anything, if VAR_NAME is null
1039    or empty. */
1040 static bool
1041 create_flag_var (const char *subcommand, const char *var_name,
1042                  struct dictionary *dict, struct variable **var)
1043 {
1044   if (var_name != NULL && var_name[0] != '\0')
1045     {
1046       struct fmt_spec format = fmt_for_output (FMT_F, 1, 0);
1047       *var = dict_create_var (dict, var_name, 0);
1048       if (*var == NULL)
1049         {
1050           msg (SE, _("Variable name %s specified on %s subcommand "
1051                      "duplicates an existing variable name."),
1052                subcommand, var_name);
1053           return false;
1054         }
1055       var_set_both_formats (*var, &format);
1056     }
1057   else
1058     *var = NULL;
1059   return true;
1060 }
1061
1062 /* Return a string in an allocated buffer describing V's variable
1063    type and width. */
1064 static char *
1065 var_type_description (struct variable *v)
1066 {
1067   if (var_is_numeric (v))
1068     return xstrdup ("numeric");
1069   else
1070     return xasprintf ("string with width %d", var_get_width (v));
1071 }
1072
1073 /* Closes all the files in MTF and frees their associated data.
1074    Returns true if successful, false if an I/O error occurred on
1075    any of the files. */
1076 static bool
1077 mtf_close_all_files (struct mtf_proc *mtf)
1078 {
1079   struct mtf_file *file;
1080   bool ok = true;
1081
1082   ll_for_each_preremove (file, struct mtf_file, ll, &mtf->files)
1083     {
1084       casereader_destroy (file->reader);
1085       free (file->by);
1086       dict_destroy (file->dict);
1087       free (file->in_name);
1088       case_destroy (&file->input);
1089       free (file->vars);
1090       free (file);
1091     }
1092
1093   return ok;
1094 }
1095
1096 /* Frees all the data for the MATCH FILES procedure. */
1097 static void
1098 mtf_free (struct mtf_proc *mtf)
1099 {
1100   mtf_close_all_files (mtf);
1101   dict_destroy (mtf->dict);
1102   casewriter_destroy (mtf->output);
1103   case_destroy (&mtf->buffered_case);
1104   case_destroy (&mtf->prev_BY_case);
1105 }
1106
1107 /* Reads the next record into FILE, if possible, and update MTF's
1108    nonempty_files count if not. */
1109 static bool
1110 mtf_read_record (struct mtf_proc *mtf, struct mtf_file *file)
1111 {
1112   case_destroy (&file->input);
1113   if (!casereader_read (file->reader, &file->input))
1114     {
1115       mtf->nonempty_files--;
1116       return false;
1117     }
1118   else
1119     return true;
1120 }
1121
1122 /* Compare the BY variables for files A and B; return -1 if A <
1123    B, 0 if A == B, 1 if A > B.  (If there are no BY variables,
1124    then all records are equal.) */
1125 static inline int
1126 mtf_compare_BY_values (struct mtf_proc *mtf,
1127                        struct mtf_file *a, struct mtf_file *b)
1128 {
1129   return case_compare_2dict (&a->input, &b->input, a->by, b->by, mtf->by_cnt);
1130 }
1131
1132 /* Processes input files and write one case to the output file. */
1133 static void
1134 mtf_process_case (struct mtf_proc *mtf)
1135 {
1136   struct ccase c;
1137   struct mtf_file *min;
1138   struct mtf_file *file;
1139   int min_sequence;
1140   size_t i;
1141
1142   /* Find the set of one or more FILEs whose BY values are
1143      minimal, as well as the set of zero or more TABLEs whose BY
1144      values equal those of the minimum FILEs.
1145
1146      After each iteration of the loop, this invariant holds: the
1147      FILEs with minimum BY values thus far have "sequence"
1148      members equal to min_sequence, and "min" points to one of
1149      the mtf_files whose case has those minimum BY values, and
1150      similarly for TABLEs. */
1151   min_sequence = 0;
1152   min = NULL;
1153   ll_for_each (file, struct mtf_file, ll, &mtf->files)
1154     if (case_is_null (&file->input))
1155       file->sequence = -1;
1156     else if (file->type == MTF_FILE)
1157       {
1158         int cmp = min != NULL ? mtf_compare_BY_values (mtf, min, file) : 1;
1159         if (cmp <= 0)
1160           file->sequence = cmp < 0 ? -1 : min_sequence;
1161         else
1162           {
1163             file->sequence = ++min_sequence;
1164             min = file;
1165           }
1166       }
1167     else
1168       {
1169         int cmp;
1170         assert (min != NULL);
1171         do
1172           {
1173             cmp = mtf_compare_BY_values (mtf, min, file);
1174           }
1175         while (cmp > 0 && mtf_read_record (mtf, file));
1176         file->sequence = cmp == 0 ? min_sequence : -1;
1177       }
1178
1179   /* Form the output case from the input cases. */
1180   case_create (&c, dict_get_next_value_idx (mtf->dict));
1181   for (i = 0; i < dict_get_var_cnt (mtf->dict); i++)
1182     {
1183       struct variable *v = dict_get_var (mtf->dict, i);
1184       value_set_missing (case_data_rw (&c, v), var_get_width (v));
1185     }
1186   ll_for_each_reverse (file, struct mtf_file, ll, &mtf->files)
1187     {
1188       bool include_file = file->sequence == min_sequence;
1189       if (include_file)
1190         for (i = 0; i < file->var_cnt; i++)
1191           {
1192             const struct mtf_variable *mv = &file->vars[i];
1193             const union value *in = case_data (&file->input, mv->in_var);
1194             union value *out = case_data_rw (&c, mv->out_var);
1195             value_copy (out, in, var_get_width (mv->in_var));
1196           }
1197       if (file->in_var != NULL)
1198         case_data_rw (&c, file->in_var)->f = include_file;
1199     }
1200
1201   /* Write the output case. */
1202   if (mtf->first == NULL && mtf->last == NULL)
1203     {
1204       /* With no FIRST or LAST variables, it's trivial. */
1205       casewriter_write (mtf->output, &c);
1206     }
1207   else
1208     {
1209       /* It's harder with LAST, because we can't know whether
1210          this case is the last in a group until we've prepared
1211          the *next* case also.  Thus, we buffer the previous
1212          output case until the next one is ready.
1213
1214          We also have to save a copy of one of the previous input
1215          cases, so that we can compare the BY variables.  We
1216          can't compare the BY variables between the current
1217          output case and the saved one because the BY variables
1218          might not be in the output (the user is allowed to drop
1219          them). */
1220       bool new_BY;
1221       if (mtf->prev_BY != NULL)
1222         {
1223           new_BY = case_compare_2dict (&min->input, &mtf->prev_BY_case,
1224                                        min->by, mtf->prev_BY,
1225                                        mtf->by_cnt);
1226           if (mtf->last != NULL)
1227             case_data_rw (&mtf->buffered_case, mtf->last)->f = new_BY;
1228           casewriter_write (mtf->output, &mtf->buffered_case);
1229         }
1230       else
1231         new_BY = true;
1232
1233       case_move (&mtf->buffered_case, &c);
1234       if (mtf->first != NULL)
1235         case_data_rw (&mtf->buffered_case, mtf->first)->f = new_BY;
1236
1237       if (new_BY)
1238         {
1239           mtf->prev_BY = min->by;
1240           case_destroy (&mtf->prev_BY_case);
1241           case_clone (&mtf->prev_BY_case, &min->input);
1242         }
1243     }
1244
1245   /* Read another record from each input file FILE with minimum
1246      values. */
1247   ll_for_each (file, struct mtf_file, ll, &mtf->files)
1248     if (file->type == MTF_FILE)
1249       {
1250         if (file->sequence == min_sequence)
1251           mtf_read_record (mtf, file);
1252       }
1253     else
1254       break;
1255 }
1256
1257 /* Merge the dictionary for file F into master dictionary M. */
1258 static bool
1259 mtf_merge_dictionary (struct dictionary *const m, struct mtf_file *f)
1260 {
1261   struct dictionary *d = f->dict;
1262   const char *d_docs, *m_docs;
1263   int i;
1264
1265   if (dict_get_label (m) == NULL)
1266     dict_set_label (m, dict_get_label (d));
1267
1268   d_docs = dict_get_documents (d);
1269   m_docs = dict_get_documents (m);
1270   if (d_docs != NULL)
1271     {
1272       if (m_docs == NULL)
1273         dict_set_documents (m, d_docs);
1274       else
1275         {
1276           char *new_docs = xasprintf ("%s%s", m_docs, d_docs);
1277           dict_set_documents (m, new_docs);
1278           free (new_docs);
1279         }
1280     }
1281
1282   for (i = 0; i < dict_get_var_cnt (d); i++)
1283     {
1284       struct variable *dv = dict_get_var (d, i);
1285       struct variable *mv = dict_lookup_var (m, var_get_name (dv));
1286
1287       if (dict_class_from_id (var_get_name (dv)) == DC_SCRATCH)
1288         continue;
1289
1290       if (mv != NULL)
1291         {
1292           if (var_get_width (mv) != var_get_width (dv))
1293             {
1294               char *dv_description = var_type_description (dv);
1295               char *mv_description = var_type_description (mv);
1296               msg (SE, _("Variable %s in file %s (%s) has different "
1297                          "type or width from the same variable in "
1298                          "earlier file (%s)."),
1299                    var_get_name (dv), fh_get_name (f->handle),
1300                    dv_description, mv_description);
1301               free (dv_description);
1302               free (mv_description);
1303               return false;
1304             }
1305
1306           if (var_get_width (dv) == var_get_width (mv))
1307             {
1308               if (var_has_value_labels (dv) && !var_has_value_labels (mv))
1309                 var_set_value_labels (mv, var_get_value_labels (dv));
1310               if (var_has_missing_values (dv) && !var_has_missing_values (mv))
1311                 var_set_missing_values (mv, var_get_missing_values (dv));
1312             }
1313
1314           if (var_get_label (dv) && !var_get_label (mv))
1315             var_set_label (mv, var_get_label (dv));
1316         }
1317       else
1318         mv = dict_clone_var_assert (m, dv, var_get_name (dv));
1319     }
1320
1321   return true;
1322 }