src/language/data-io/combine-files.c

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 1997-9, 2000, 2006, 2007, 2008, 2009 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/case-matcher.h>
  23 #include <data/case.h>
  24 #include <data/casereader.h>
  25 #include <data/casewriter.h>
  26 #include <data/dictionary.h>
  27 #include <data/format.h>
  28 #include <data/procedure.h>
  29 #include <data/subcase.h>
  30 #include <data/variable.h>
  31 #include <language/command.h>
  32 #include <language/data-io/file-handle.h>
  33 #include <language/data-io/trim.h>
  34 #include <language/lexer/lexer.h>
  35 #include <language/lexer/variable-parser.h>
  36 #include <language/stats/sort-criteria.h>
  37 #include <libpspp/assertion.h>
  38 #include <libpspp/message.h>
  39 #include <libpspp/taint.h>
  40 #include <math/sort.h>
  41
  42 #include "xalloc.h"
  43
  44 #include "gettext.h"
  45 #define _(msgid) gettext (msgid)
  46
  47 enum comb_command_type
  48   {
  49     COMB_ADD,
  50     COMB_MATCH,
  51     COMB_UPDATE
  52   };
  53
  54 /* File types. */
  55 enum comb_file_type
  56   {
  57     COMB_FILE,                  /* Specified on FILE= subcommand. */
  58     COMB_TABLE                  /* Specified on TABLE= subcommand. */
  59   };
  60
  61 /* One FILE or TABLE subcommand. */
  62 struct comb_file
  63   {
  64     /* Basics. */
  65     enum comb_file_type type;   /* COMB_FILE or COMB_TABLE. */
  66
  67     /* Variables. */
  68     struct subcase by_vars;     /* BY variables in this input file. */
  69     struct subcase src, dst;    /* Data to copy to output; where to put it. */
  70
  71     /* Input files. */
  72     struct file_handle *handle; /* Input file handle. */
  73     struct dictionary *dict;    /* Input file dictionary. */
  74     struct casereader *reader;  /* Input data source. */
  75     struct ccase *data;         /* The current input case. */
  76     bool is_minimal;            /* Does 'data' have minimum BY values across
  77                                    all input files? */
  78     bool is_sorted;             /* Is file presorted on the BY variables? */
  79
  80     /* IN subcommand. */
  81     char in_name[VAR_NAME_LEN + 1];
  82     struct variable *in_var;
  83   };
  84
  85 struct comb_proc
  86   {
  87     struct comb_file *files;    /* All the files being merged. */
  88     size_t n_files;             /* Number of files. */
  89
  90     struct dictionary *dict;    /* Dictionary of output file. */
  91     struct subcase by_vars;     /* BY variables in the output. */
  92     struct casewriter *output;  /* Destination for output. */
  93
  94     struct case_matcher *matcher;
  95
  96     /* FIRST, LAST.
  97        Only if "first" or "last" is nonnull are the remaining
  98        members used. */
  99     struct variable *first;     /* Variable specified on FIRST (if any). */
 100     struct variable *last;      /* Variable specified on LAST (if any). */
 101     struct ccase *buffered_case; /* Case ready for output except that we don't
 102                                     know the value for the LAST var yet. */
 103     union value *prev_BY;       /* Values of BY vars in buffered_case. */
 104   };
 105
 106 static int combine_files (enum comb_command_type, struct lexer *,
 107                           struct dataset *);
 108 static void free_comb_proc (struct comb_proc *);
 109
 110 static void close_all_comb_files (struct comb_proc *);
 111 static bool merge_dictionary (struct dictionary *const, struct comb_file *);
 112
 113 static void execute_update (struct comb_proc *);
 114 static void execute_match_files (struct comb_proc *);
 115 static void execute_add_files (struct comb_proc *);
 116
 117 static bool create_flag_var (const char *subcommand_name, const char *var_name,
 118                              struct dictionary *, struct variable **);
 119 static void output_case (struct comb_proc *, struct ccase *, union value *by);
 120 static void output_buffered_case (struct comb_proc *);
 121
 122 int
 123 cmd_add_files (struct lexer *lexer, struct dataset *ds)
 124 {
 125   return combine_files (COMB_ADD, lexer, ds);
 126 }
 127
 128 int
 129 cmd_match_files (struct lexer *lexer, struct dataset *ds)
 130 {
 131   return combine_files (COMB_MATCH, lexer, ds);
 132 }
 133
 134 int
 135 cmd_update (struct lexer *lexer, struct dataset *ds)
 136 {
 137   return combine_files (COMB_UPDATE, lexer, ds);
 138 }
 139
 140 static int
 141 combine_files (enum comb_command_type command,
 142                struct lexer *lexer, struct dataset *ds)
 143 {
 144   struct comb_proc proc;
 145
 146   bool saw_by = false;
 147   bool saw_sort = false;
 148   struct casereader *active_file = NULL;
 149
 150   char first_name[VAR_NAME_LEN + 1] = "";
 151   char last_name[VAR_NAME_LEN + 1] = "";
 152
 153   struct taint *taint = NULL;
 154
 155   size_t n_tables = 0;
 156   size_t allocated_files = 0;
 157
 158   size_t i;
 159
 160   proc.files = NULL;
 161   proc.n_files = 0;
 162   proc.dict = dict_create ();
 163   proc.output = NULL;
 164   proc.matcher = NULL;
 165   subcase_init_empty (&proc.by_vars);
 166   proc.first = NULL;
 167   proc.last = NULL;
 168   proc.buffered_case = NULL;
 169   proc.prev_BY = NULL;
 170
 171   dict_set_case_limit (proc.dict, dict_get_case_limit (dataset_dict (ds)));
 172
 173   lex_match (lexer, '/');
 174   for (;;)
 175     {
 176       struct comb_file *file;
 177       enum comb_file_type type;
 178
 179       if (lex_match_id (lexer, "FILE"))
 180         type = COMB_FILE;
 181       else if (command == COMB_MATCH && lex_match_id (lexer, "TABLE"))
 182         {
 183           type = COMB_TABLE;
 184           n_tables++;
 185         }
 186       else
 187         break;
 188       lex_match (lexer, '=');
 189
 190       if (proc.n_files >= allocated_files)
 191         proc.files = x2nrealloc (proc.files, &allocated_files,
 192                                 sizeof *proc.files);
 193       file = &proc.files[proc.n_files++];
 194       file->type = type;
 195       subcase_init_empty (&file->by_vars);
 196       subcase_init_empty (&file->src);
 197       subcase_init_empty (&file->dst);
 198       file->handle = NULL;
 199       file->dict = NULL;
 200       file->reader = NULL;
 201       file->data = NULL;
 202       file->is_sorted = true;
 203       file->in_name[0] = '\0';
 204       file->in_var = NULL;
 205
 206       if (lex_match (lexer, '*'))
 207         {
 208           if (!proc_has_active_file (ds))
 209             {
 210               msg (SE, _("Cannot specify the active file since no active "
 211                          "file has been defined."));
 212               goto error;
 213             }
 214
 215           if (proc_make_temporary_transformations_permanent (ds))
 216             msg (SE, _("This command may not be used after TEMPORARY when "
 217                        "the active file is an input source.  "
 218                        "Temporary transformations will be made permanent."));
 219
 220           file->dict = dict_clone (dataset_dict (ds));
 221         }
 222       else
 223         {
 224           file->handle = fh_parse (lexer, FH_REF_FILE | FH_REF_SCRATCH);
 225           if (file->handle == NULL)
 226             goto error;
 227
 228           file->reader = any_reader_open (file->handle, &file->dict);
 229           if (file->reader == NULL)
 230             goto error;
 231         }
 232
 233       while (lex_match (lexer, '/'))
 234         if (lex_match_id (lexer, "RENAME"))
 235           {
 236             if (!parse_dict_rename (lexer, file->dict))
 237               goto error;
 238           }
 239         else if (lex_match_id (lexer, "IN"))
 240           {
 241             lex_match (lexer, '=');
 242             if (lex_token (lexer) != T_ID)
 243               {
 244                 lex_error (lexer, NULL);
 245                 goto error;
 246               }
 247
 248             if (file->in_name[0])
 249               {
 250                 msg (SE, _("Multiple IN subcommands for a single FILE or "
 251                            "TABLE."));
 252                 goto error;
 253               }
 254             strcpy (file->in_name, lex_tokid (lexer));
 255             lex_get (lexer);
 256           }
 257         else if (lex_match_id (lexer, "SORT"))
 258           {
 259             file->is_sorted = false;
 260             saw_sort = true;
 261           }
 262
 263       merge_dictionary (proc.dict, file);
 264     }
 265
 266   while (lex_token (lexer) != '.')
 267     {
 268       if (lex_match (lexer, T_BY))
 269         {
 270           const struct variable **by_vars;
 271           size_t i;
 272           bool ok;
 273
 274           if (saw_by)
 275             {
 276               lex_sbc_only_once ("BY");
 277               goto error;
 278             }
 279           saw_by = true;
 280
 281           lex_match (lexer, '=');
 282           if (!parse_sort_criteria (lexer, proc.dict, &proc.by_vars,
 283                                     &by_vars, NULL))
 284             goto error;
 285
 286           ok = true;
 287           for (i = 0; i < proc.n_files; i++)
 288             {
 289               struct comb_file *file = &proc.files[i];
 290               size_t j;
 291
 292               for (j = 0; j < subcase_get_n_values (&proc.by_vars); j++)
 293                 {
 294                   const char *name = var_get_name (by_vars[j]);
 295                   struct variable *var = dict_lookup_var (file->dict, name);
 296                   if (var != NULL)
 297                     subcase_add_var (&file->by_vars, var,
 298                                      subcase_get_direction (&proc.by_vars, j));
 299                   else
 300                     {
 301                       if (file->handle != NULL)
 302                         msg (SE, _("File %s lacks BY variable %s."),
 303                              fh_get_name (file->handle), name);
 304                       else
 305                         msg (SE, _("Active file lacks BY variable %s."), name);
 306                       ok = false;
 307                     }
 308                 }
 309               assert (!ok || subcase_conformable (&file->by_vars,
 310                                                   &proc.files[0].by_vars));
 311             }
 312           free (by_vars);
 313
 314           if (!ok)
 315             goto error;
 316         }
 317       else if (command != COMB_UPDATE && lex_match_id (lexer, "FIRST"))
 318         {
 319           if (first_name[0] != '\0')
 320             {
 321               lex_sbc_only_once ("FIRST");
 322               goto error;
 323             }
 324
 325           lex_match (lexer, '=');
 326           if (!lex_force_id (lexer))
 327             goto error;
 328           strcpy (first_name, lex_tokid (lexer));
 329           lex_get (lexer);
 330         }
 331       else if (command != COMB_UPDATE && lex_match_id (lexer, "LAST"))
 332         {
 333           if (last_name[0] != '\0')
 334             {
 335               lex_sbc_only_once ("LAST");
 336               goto error;
 337             }
 338
 339           lex_match (lexer, '=');
 340           if (!lex_force_id (lexer))
 341             goto error;
 342           strcpy (last_name, lex_tokid (lexer));
 343           lex_get (lexer);
 344         }
 345       else if (lex_match_id (lexer, "MAP"))
 346         {
 347           /* FIXME. */
 348         }
 349       else if (lex_match_id (lexer, "DROP"))
 350         {
 351           if (!parse_dict_drop (lexer, proc.dict))
 352             goto error;
 353         }
 354       else if (lex_match_id (lexer, "KEEP"))
 355         {
 356           if (!parse_dict_keep (lexer, proc.dict))
 357             goto error;
 358         }
 359       else
 360         {
 361           lex_error (lexer, NULL);
 362           goto error;
 363         }
 364
 365       if (!lex_match (lexer, '/') && lex_token (lexer) != '.')
 366         {
 367           lex_end_of_command (lexer);
 368           goto error;
 369         }
 370     }
 371
 372   if (!saw_by)
 373     {
 374       if (command == COMB_UPDATE)
 375         {
 376           msg (SE, _("The BY subcommand is required."));
 377           goto error;
 378         }
 379       if (n_tables)
 380         {
 381           msg (SE, _("BY is required when TABLE is specified."));
 382           goto error;
 383         }
 384       if (saw_sort)
 385         {
 386           msg (SE, _("BY is required when SORT is specified."));
 387           goto error;
 388         }
 389     }
 390
 391   /* Add IN, FIRST, and LAST variables to master dictionary. */
 392   for (i = 0; i < proc.n_files; i++)
 393     {
 394       struct comb_file *file = &proc.files[i];
 395       if (!create_flag_var ("IN", file->in_name, proc.dict, &file->in_var))
 396         goto error;
 397     }
 398   if (!create_flag_var ("FIRST", first_name, proc.dict, &proc.first)
 399       || !create_flag_var ("LAST", last_name, proc.dict, &proc.last))
 400     goto error;
 401
 402   dict_delete_scratch_vars (proc.dict);
 403   dict_compact_values (proc.dict);
 404
 405   /* Set up mapping from each file's variables to master
 406      variables. */
 407   for (i = 0; i < proc.n_files; i++)
 408     {
 409       struct comb_file *file = &proc.files[i];
 410       size_t src_var_cnt = dict_get_var_cnt (file->dict);
 411       size_t j;
 412
 413       for (j = 0; j < src_var_cnt; j++)
 414         {
 415           struct variable *src_var = dict_get_var (file->dict, j);
 416           struct variable *dst_var = dict_lookup_var (proc.dict,
 417                                                       var_get_name (src_var));
 418           if (dst_var != NULL)
 419             {
 420               subcase_add_var (&file->src, src_var, SC_ASCEND);
 421               subcase_add_var (&file->dst, dst_var, SC_ASCEND);
 422             }
 423         }
 424     }
 425
 426   proc.output = autopaging_writer_create (dict_get_next_value_idx (proc.dict));
 427   taint = taint_clone (casewriter_get_taint (proc.output));
 428
 429   /* Set up case matcher. */
 430   proc.matcher = case_matcher_create ();
 431   for (i = 0; i < proc.n_files; i++)
 432     {
 433       struct comb_file *file = &proc.files[i];
 434       if (file->reader == NULL)
 435         {
 436           if (active_file == NULL)
 437             {
 438               proc_discard_output (ds);
 439               file->reader = active_file = proc_open (ds);
 440             }
 441           else
 442             file->reader = casereader_clone (active_file);
 443         }
 444       if (!file->is_sorted)
 445         file->reader = sort_execute (file->reader, &file->by_vars);
 446       taint_propagate (casereader_get_taint (file->reader), taint);
 447       file->data = casereader_read (file->reader);
 448       if (file->type == COMB_FILE)
 449         case_matcher_add_input (proc.matcher, &file->by_vars,
 450                                 &file->data, &file->is_minimal);
 451     }
 452
 453   if (command == COMB_ADD)
 454     execute_add_files (&proc);
 455   else if (command == COMB_MATCH)
 456     execute_match_files (&proc);
 457   else if (command == COMB_UPDATE)
 458     execute_update (&proc);
 459   else
 460     NOT_REACHED ();
 461
 462   case_matcher_destroy (proc.matcher);
 463   proc.matcher = NULL;
 464   close_all_comb_files (&proc);
 465   if (active_file != NULL)
 466     proc_commit (ds);
 467
 468   proc_set_active_file (ds, casewriter_make_reader (proc.output), proc.dict);
 469   proc.dict = NULL;
 470   proc.output = NULL;
 471
 472   free_comb_proc (&proc);
 473
 474   return taint_destroy (taint) ? CMD_SUCCESS : CMD_CASCADING_FAILURE;
 475
 476  error:
 477   if (active_file != NULL)
 478     proc_commit (ds);
 479   free_comb_proc (&proc);
 480   taint_destroy (taint);
 481   return CMD_CASCADING_FAILURE;
 482 }
 483
 484 /* Merge the dictionary for file F into master dictionary M. */
 485 static bool
 486 merge_dictionary (struct dictionary *const m, struct comb_file *f)
 487 {
 488   struct dictionary *d = f->dict;
 489   const char *d_docs, *m_docs;
 490   int i;
 491
 492   if (dict_get_label (m) == NULL)
 493     dict_set_label (m, dict_get_label (d));
 494
 495   d_docs = dict_get_documents (d);
 496   m_docs = dict_get_documents (m);
 497   if (d_docs != NULL)
 498     {
 499       if (m_docs == NULL)
 500         dict_set_documents (m, d_docs);
 501       else
 502         {
 503           char *new_docs = xasprintf ("%s%s", m_docs, d_docs);
 504           dict_set_documents (m, new_docs);
 505           free (new_docs);
 506         }
 507     }
 508
 509   for (i = 0; i < dict_get_var_cnt (d); i++)
 510     {
 511       struct variable *dv = dict_get_var (d, i);
 512       struct variable *mv = dict_lookup_var (m, var_get_name (dv));
 513
 514       if (dict_class_from_id (var_get_name (dv)) == DC_SCRATCH)
 515         continue;
 516
 517       if (mv != NULL)
 518         {
 519           if (var_get_width (mv) != var_get_width (dv))
 520             {
 521               const char *var_name = var_get_name (dv);
 522               const char *file_name = fh_get_name (f->handle);
 523               struct string s = DS_EMPTY_INITIALIZER;
 524               ds_put_format (&s,
 525                              _("Variable %s in file %s has different "
 526                                "type or width from the same variable in "
 527                                "earlier file."),
 528                              var_name, file_name);
 529               ds_put_cstr (&s, "  ");
 530               if (var_is_numeric (dv))
 531                 ds_put_format (&s, _("In file %s, %s is numeric."),
 532                                file_name, var_name);
 533               else
 534                 ds_put_format (&s, _("In file %s, %s is a string variable "
 535                                      "with width %d."),
 536                                file_name, var_name, var_get_width (dv));
 537               ds_put_cstr (&s, "  ");
 538               if (var_is_numeric (mv))
 539                 ds_put_format (&s, _("In an earlier file, %s was numeric."),
 540                                var_name);
 541               else
 542                 ds_put_format (&s, _("In an earlier file, %s was a string "
 543                                      "variable with width %d."),
 544                                var_name, var_get_width (mv));
 545               msg (SE, ds_cstr (&s));
 546               ds_destroy (&s);
 547               return false;
 548             }
 549
 550           if (var_has_value_labels (dv) && !var_has_value_labels (mv))
 551             var_set_value_labels (mv, var_get_value_labels (dv));
 552           if (var_has_missing_values (dv) && !var_has_missing_values (mv))
 553             var_set_missing_values (mv, var_get_missing_values (dv));
 554           if (var_get_label (dv) && !var_get_label (mv))
 555             var_set_label (mv, var_get_label (dv));
 556         }
 557       else
 558         mv = dict_clone_var_assert (m, dv, var_get_name (dv));
 559     }
 560
 561   return true;
 562 }
 563
 564 /* If VAR_NAME is a non-empty string, attempts to create a
 565    variable named VAR_NAME, with format F1.0, in DICT, and stores
 566    a pointer to the variable in *VAR.  Returns true if
 567    successful, false if the variable name is a duplicate (in
 568    which case a message saying that the variable specified on the
 569    given SUBCOMMAND is a duplicate is emitted).  Also returns
 570    true, without doing anything, if VAR_NAME is null or empty. */
 571 static bool
 572 create_flag_var (const char *subcommand, const char *var_name,
 573                  struct dictionary *dict, struct variable **var)
 574 {
 575   if (var_name[0] != '\0')
 576     {
 577       struct fmt_spec format = fmt_for_output (FMT_F, 1, 0);
 578       *var = dict_create_var (dict, var_name, 0);
 579       if (*var == NULL)
 580         {
 581           msg (SE, _("Variable name %s specified on %s subcommand "
 582                      "duplicates an existing variable name."),
 583                subcommand, var_name);
 584           return false;
 585         }
 586       var_set_both_formats (*var, &format);
 587     }
 588   else
 589     *var = NULL;
 590   return true;
 591 }
 592
 593 /* Closes all the files in PROC and frees their associated data. */
 594 static void
 595 close_all_comb_files (struct comb_proc *proc)
 596 {
 597   size_t i;
 598
 599   for (i = 0; i < proc->n_files; i++)
 600     {
 601       struct comb_file *file = &proc->files[i];
 602       subcase_destroy (&file->by_vars);
 603       subcase_destroy (&file->src);
 604       subcase_destroy (&file->dst);
 605       fh_unref (file->handle);
 606       dict_destroy (file->dict);
 607       casereader_destroy (file->reader);
 608       case_unref (file->data);
 609     }
 610   free (proc->files);
 611   proc->files = NULL;
 612   proc->n_files = 0;
 613 }
 614
 615 /* Frees all the data for the procedure. */
 616 static void
 617 free_comb_proc (struct comb_proc *proc)
 618 {
 619   close_all_comb_files (proc);
 620   dict_destroy (proc->dict);
 621   casewriter_destroy (proc->output);
 622   case_matcher_destroy (proc->matcher);
 623   subcase_destroy (&proc->by_vars);
 624   case_unref (proc->buffered_case);
 625   free (proc->prev_BY);
 626 }
 627 \f
 628 static bool scan_table (struct comb_file *, union value by[]);
 629 static struct ccase *create_output_case (const struct comb_proc *);
 630 static void apply_case (const struct comb_file *, struct ccase *);
 631 static void apply_file_case_and_advance (struct comb_file *, struct ccase *,
 632                                          union value by[]);
 633 static void output_case (struct comb_proc *, struct ccase *, union value by[]);
 634 static void output_buffered_case (struct comb_proc *);
 635
 636 /* Executes the ADD FILES command. */
 637 static void
 638 execute_add_files (struct comb_proc *proc)
 639 {
 640   union value *by;
 641
 642   while (case_matcher_match (proc->matcher, &by))
 643     {
 644       size_t i;
 645
 646       for (i = 0; i < proc->n_files; i++)
 647         {
 648           struct comb_file *file = &proc->files[i];
 649           while (file->is_minimal)
 650             {
 651               struct ccase *output = create_output_case (proc);
 652               apply_file_case_and_advance (file, output, by);
 653               output_case (proc, output, by);
 654             }
 655         }
 656     }
 657   output_buffered_case (proc);
 658 }
 659
 660 /* Executes the MATCH FILES command. */
 661 static void
 662 execute_match_files (struct comb_proc *proc)
 663 {
 664   union value *by;
 665
 666   while (case_matcher_match (proc->matcher, &by))
 667     {
 668       struct ccase *output;
 669       size_t i;
 670
 671       output = create_output_case (proc);
 672       for (i = proc->n_files; i-- > 0; )
 673         {
 674           struct comb_file *file = &proc->files[i];
 675           if (file->type == COMB_FILE)
 676             {
 677               if (file->is_minimal)
 678                 apply_file_case_and_advance (file, output, NULL);
 679             }
 680           else
 681             {
 682               if (scan_table (file, by))
 683                 apply_case (file, output);
 684             }
 685         }
 686       output_case (proc, output, by);
 687     }
 688   output_buffered_case (proc);
 689 }
 690
 691 /* Executes the UPDATE command. */
 692 static void
 693 execute_update (struct comb_proc *proc)
 694 {
 695   union value *by;
 696   size_t n_duplicates = 0;
 697
 698   while (case_matcher_match (proc->matcher, &by))
 699     {
 700       struct comb_file *first, *file;
 701       struct ccase *output;
 702
 703       /* Find first nonnull case in array and make an output case
 704          from it. */
 705       output = create_output_case (proc);
 706       for (first = &proc->files[0]; ; first++)
 707         if (first->is_minimal)
 708           break;
 709       apply_file_case_and_advance (first, output, by);
 710
 711       /* Read additional cases and update the output case from
 712          them.  (Don't update the output case from any duplicate
 713          cases in the master file.) */
 714       for (file = first + (first == proc->files);
 715            file < &proc->files[proc->n_files]; file++)
 716         {
 717           while (file->is_minimal)
 718             apply_file_case_and_advance (file, output, by);
 719         }
 720       casewriter_write (proc->output, output);
 721
 722       /* Write duplicate cases in the master file directly to the
 723          output.  */
 724       if (first == proc->files && first->is_minimal)
 725         {
 726           n_duplicates++;
 727           while (first->is_minimal)
 728             {
 729               output = create_output_case (proc);
 730               apply_file_case_and_advance (first, output, by);
 731               casewriter_write (proc->output, output);
 732             }
 733         }
 734     }
 735
 736   if (n_duplicates)
 737     msg (SW, _("Encountered %zu sets of duplicate cases in the master file."),
 738          n_duplicates);
 739 }
 740
 741 /* Reads FILE, which must be of type COMB_TABLE, until it
 742    encounters a case with BY or greater for its BY variables.
 743    Returns true if a case with exactly BY for its BY variables
 744    was found, otherwise false. */
 745 static bool
 746 scan_table (struct comb_file *file, union value by[])
 747 {
 748   while (file->data != NULL)
 749     {
 750       int cmp = subcase_compare_3way_xc (&file->by_vars, by, file->data);
 751       if (cmp > 0)
 752         {
 753           case_unref (file->data);
 754           file->data = casereader_read (file->reader);
 755         }
 756       else
 757         return cmp == 0;
 758     }
 759   return false;
 760 }
 761
 762 /* Creates and returns an output case for PROC, initializing each
 763    of its values to system-missing or blanks, except that the
 764    values of IN variables are set to 0. */
 765 static struct ccase *
 766 create_output_case (const struct comb_proc *proc)
 767 {
 768   size_t n_vars = dict_get_var_cnt (proc->dict);
 769   struct ccase *output;
 770   size_t i;
 771
 772   output = case_create (dict_get_next_value_idx (proc->dict));
 773   for (i = 0; i < n_vars; i++)
 774     {
 775       struct variable *v = dict_get_var (proc->dict, i);
 776       value_set_missing (case_data_rw (output, v), var_get_width (v));
 777     }
 778   for (i = 0; i < proc->n_files; i++)
 779     {
 780       struct comb_file *file = &proc->files[i];
 781       if (file->in_var != NULL)
 782         case_data_rw (output, file->in_var)->f = false;
 783     }
 784   return output;
 785 }
 786
 787 /* Copies the data from FILE's case into output case OUTPUT.
 788    If FILE has an IN variable, then it is set to 1 in OUTPUT. */
 789 static void
 790 apply_case (const struct comb_file *file, struct ccase *output)
 791 {
 792   subcase_copy (&file->src, file->data, &file->dst, output);
 793   if (file->in_var != NULL)
 794     case_data_rw (output, file->in_var)->f = true;
 795 }
 796
 797 /* Like apply_case() above, but also advances FILE to its next
 798    case.  Also, if BY is nonnull, then FILE's is_minimal member
 799    is updated based on whether the new case's BY values still
 800    match those in BY. */
 801 static void
 802 apply_file_case_and_advance (struct comb_file *file, struct ccase *output,
 803                              union value by[])
 804 {
 805   apply_case (file, output);
 806   case_unref (file->data);
 807   file->data = casereader_read (file->reader);
 808   if (by)
 809     file->is_minimal = (file->data != NULL
 810                         && subcase_equal_cx (&file->by_vars, file->data, by));
 811 }
 812
 813 /* Writes OUTPUT, whose BY values has been extracted into BY, to
 814    PROC's output file, first initializing any FIRST or LAST
 815    variables in OUTPUT to the correct values. */
 816 static void
 817 output_case (struct comb_proc *proc, struct ccase *output, union value by[])
 818 {
 819   if (proc->first == NULL && proc->last == NULL)
 820     casewriter_write (proc->output, output);
 821   else
 822     {
 823       /* It's harder with LAST, because we can't know whether
 824          this case is the last in a group until we've prepared
 825          the *next* case also.  Thus, we buffer the previous
 826          output case until the next one is ready. */
 827       bool new_BY;
 828       if (proc->prev_BY != NULL)
 829         {
 830           new_BY = !subcase_equal_xx (&proc->by_vars, proc->prev_BY, by);
 831           if (proc->last != NULL)
 832             case_data_rw (proc->buffered_case, proc->last)->f = new_BY;
 833           casewriter_write (proc->output, proc->buffered_case);
 834         }
 835       else
 836         new_BY = true;
 837
 838       proc->buffered_case = output;
 839       if (proc->first != NULL)
 840         case_data_rw (proc->buffered_case, proc->first)->f = new_BY;
 841
 842       if (new_BY)
 843         {
 844           size_t n = (subcase_get_n_values (&proc->by_vars)
 845                       * sizeof (union value));
 846           if (proc->prev_BY == NULL)
 847             proc->prev_BY = xmalloc (n);
 848           memcpy (proc->prev_BY, by, n);
 849         }
 850     }
 851 }
 852
 853 /* Writes a trailing buffered case to the output, if FIRST or
 854    LAST is in use. */
 855 static void
 856 output_buffered_case (struct comb_proc *proc)
 857 {
 858   if (proc->prev_BY != NULL)
 859     {
 860       if (proc->last != NULL)
 861         case_data_rw (proc->buffered_case, proc->last)->f = 1.0;
 862       casewriter_write (proc->output, proc->buffered_case);
 863       proc->buffered_case = NULL;
 864     }
 865 }