src/get.c

   1 /* PSPP - computes sample statistics.
   2    Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
   3    Written by Ben Pfaff <blp@gnu.org>.
   4
   5    This program is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU General Public License as
   7    published by the Free Software Foundation; either version 2 of the
   8    License, or (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful, but
  11    WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software
  17    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  18    02110-1301, USA. */
  19
  20 #include <config.h>
  21 #include "error.h"
  22 #include <stdlib.h>
  23 #include "alloc.h"
  24 #include "case.h"
  25 #include "command.h"
  26 #include "dictionary.h"
  27 #include "error.h"
  28 #include "file-handle.h"
  29 #include "hash.h"
  30 #include "lexer.h"
  31 #include "misc.h"
  32 #include "pfm-read.h"
  33 #include "pfm-write.h"
  34 #include "settings.h"
  35 #include "sfm-read.h"
  36 #include "sfm-write.h"
  37 #include "str.h"
  38 #include "value-labels.h"
  39 #include "var.h"
  40 #include "vfm.h"
  41 #include "vfmP.h"
  42
  43 #include "debug-print.h"
  44
  45 /* Rearranging and reducing a dictionary. */
  46 static void start_case_map (struct dictionary *);
  47 static struct case_map *finish_case_map (struct dictionary *);
  48 static void map_case (const struct case_map *,
  49                       const struct ccase *, struct ccase *);
  50 static void destroy_case_map (struct case_map *);
  51
  52 /* Operation type. */
  53 enum operation
  54   {
  55     OP_READ,    /* GET or IMPORT. */
  56     OP_SAVE,    /* SAVE or XSAVE. */
  57     OP_EXPORT   /* EXPORT. */
  58   };
  59
  60 static bool trim_dictionary (struct dictionary *,
  61                              enum operation, int *compress);
  62 \f
  63 /* GET input program. */
  64 struct get_pgm
  65   {
  66     struct sfm_reader *reader;  /* System file reader. */
  67     struct case_map *map;       /* Map from system file to active file dict. */
  68     struct ccase bounce;        /* Bounce buffer. */
  69   };
  70
  71 static void get_pgm_free (struct get_pgm *);
  72
  73 /* Parses the GET command. */
  74 int
  75 cmd_get (void)
  76 {
  77   struct get_pgm *pgm = NULL;
  78   struct file_handle *fh;
  79   struct dictionary *dict = NULL;
  80
  81   pgm = xmalloc (sizeof *pgm);
  82   pgm->reader = NULL;
  83   pgm->map = NULL;
  84   case_nullify (&pgm->bounce);
  85
  86   discard_variables ();
  87
  88   lex_match ('/');
  89   if (lex_match_id ("FILE"))
  90     lex_match ('=');
  91   fh = fh_parse ();
  92   if (fh == NULL)
  93     goto error;
  94
  95   pgm->reader = sfm_open_reader (fh, &dict, NULL);
  96   if (pgm->reader == NULL)
  97     goto error;
  98   case_create (&pgm->bounce, dict_get_next_value_idx (dict));
  99
 100   start_case_map (dict);
 101   if (!trim_dictionary (dict, OP_READ, NULL))
 102     goto error;
 103   pgm->map = finish_case_map (dict);
 104
 105   dict_destroy (default_dict);
 106   default_dict = dict;
 107
 108   vfm_source = create_case_source (&get_source_class, pgm);
 109
 110   return CMD_SUCCESS;
 111
 112  error:
 113   get_pgm_free (pgm);
 114   if (dict != NULL)
 115     dict_destroy (dict);
 116   return CMD_FAILURE;
 117 }
 118
 119 /* Frees a struct get_pgm. */
 120 static void
 121 get_pgm_free (struct get_pgm *pgm)
 122 {
 123   if (pgm != NULL)
 124     {
 125       sfm_close_reader (pgm->reader);
 126       destroy_case_map (pgm->map);
 127       case_destroy (&pgm->bounce);
 128       free (pgm);
 129     }
 130 }
 131
 132 /* Clears internal state related to GET input procedure. */
 133 static void
 134 get_source_destroy (struct case_source *source)
 135 {
 136   struct get_pgm *pgm = source->aux;
 137   get_pgm_free (pgm);
 138 }
 139
 140 /* Reads all the cases from the data file into C and passes them
 141    to WRITE_CASE one by one, passing WC_DATA. */
 142 static void
 143 get_source_read (struct case_source *source,
 144                  struct ccase *c,
 145                  write_case_func *write_case, write_case_data wc_data)
 146 {
 147   struct get_pgm *pgm = source->aux;
 148   int ok;
 149
 150   do
 151     {
 152       if (pgm->map == NULL)
 153         ok = sfm_read_case (pgm->reader, c);
 154       else
 155         {
 156           ok = sfm_read_case (pgm->reader, &pgm->bounce);
 157           if (ok)
 158             map_case (pgm->map, &pgm->bounce, c);
 159         }
 160
 161       if (ok)
 162         ok = write_case (wc_data);
 163     }
 164   while (ok);
 165 }
 166
 167 const struct case_source_class get_source_class =
 168   {
 169     "GET",
 170     NULL,
 171     get_source_read,
 172     get_source_destroy,
 173   };
 174 \f
 175 /* XSAVE transformation and SAVE procedure. */
 176 struct save_trns
 177   {
 178     struct trns_header h;
 179     struct sfm_writer *writer;  /* System file writer. */
 180     struct case_map *map;       /* Map from active file to system file dict. */
 181     struct ccase bounce;        /* Bounce buffer. */
 182   };
 183
 184 static int save_write_case_func (struct ccase *, void *);
 185 static trns_proc_func save_trns_proc;
 186 static trns_free_func save_trns_free;
 187
 188 /* Parses the SAVE or XSAVE command
 189    and returns the parsed transformation. */
 190 static struct save_trns *
 191 cmd_save_internal (void)
 192 {
 193   struct file_handle *fh = NULL;
 194   struct dictionary *dict = NULL;
 195   struct save_trns *t = NULL;
 196   int compress = get_scompression ();
 197   const int default_version = 3;
 198   int version = default_version;
 199   short no_name_table = 0;
 200
 201   t = xmalloc (sizeof *t);
 202   t->h.proc = save_trns_proc;
 203   t->h.free = save_trns_free;
 204   t->writer = NULL;
 205   t->map = NULL;
 206   case_nullify (&t->bounce);
 207
 208
 209   /* Read most of the subcommands. */
 210   for (;;)
 211     {
 212       if (lex_match_id ("VERSION"))
 213         {
 214           lex_match ('=');
 215           if (lex_force_int ())
 216             {
 217               version = lex_integer ();
 218               lex_get ();
 219
 220               if (lex_match_id ("X"))
 221                 no_name_table = 1;
 222             }
 223         }
 224       else if (lex_match_id ("OUTFILE"))
 225         {
 226           lex_match ('=');
 227
 228           fh = fh_parse ();
 229           if (fh == NULL)
 230             goto error;
 231
 232         }
 233       if ( ! lex_match('/')  )
 234         break;
 235
 236     }
 237
 238   if (token != '.')
 239     {
 240       lex_error (_("expecting end of command"));
 241       goto error;
 242     }
 243
 244   if ( fh == NULL )
 245     {
 246       msg ( ME, _("The required %s subcommand was not present"), "OUTFILE");
 247       goto error;
 248     }
 249
 250   if ( version != default_version )
 251     {
 252       msg (MW, _("Unsupported sysfile version: %d. Using version %d instead."),
 253            version, default_version);
 254
 255       version = default_version;
 256     }
 257
 258   dict = dict_clone (default_dict);
 259   start_case_map (dict);
 260   if (!trim_dictionary (dict, OP_SAVE, &compress))
 261     goto error;
 262   t->map = finish_case_map (dict);
 263   if (t->map != NULL)
 264     case_create (&t->bounce, dict_get_next_value_idx (dict));
 265
 266   t->writer = sfm_open_writer (fh, dict, compress, no_name_table);
 267   if (t->writer == NULL)
 268     goto error;
 269
 270   dict_destroy (dict);
 271
 272   return t;
 273
 274  error:
 275   assert (t != NULL);
 276   dict_destroy (dict);
 277   save_trns_free (&t->h);
 278   return NULL;
 279 }
 280
 281 /* Parses and performs the SAVE procedure. */
 282 int
 283 cmd_save (void)
 284 {
 285   struct save_trns *t = cmd_save_internal ();
 286   if (t != NULL)
 287     {
 288       procedure (save_write_case_func, t);
 289       save_trns_free (&t->h);
 290       free(t);
 291       return CMD_SUCCESS;
 292     }
 293   else
 294     return CMD_FAILURE;
 295 }
 296
 297 /* Parses the XSAVE transformation command. */
 298 int
 299 cmd_xsave (void)
 300 {
 301   struct save_trns *t = cmd_save_internal ();
 302   if (t != NULL)
 303     {
 304       add_transformation (&t->h);
 305       return CMD_SUCCESS;
 306     }
 307   else
 308     return CMD_FAILURE;
 309 }
 310
 311 /* Writes the given C to the file specified by T. */
 312 static void
 313 do_write_case (struct save_trns *t, struct ccase *c)
 314 {
 315   if (t->map == NULL)
 316     sfm_write_case (t->writer, c);
 317   else
 318     {
 319       map_case (t->map, c, &t->bounce);
 320       sfm_write_case (t->writer, &t->bounce);
 321     }
 322 }
 323
 324 /* Writes case C to the system file specified on SAVE. */
 325 static int
 326 save_write_case_func (struct ccase *c, void *aux UNUSED)
 327 {
 328   do_write_case (aux, c);
 329   return 1;
 330 }
 331
 332 /* Writes case C to the system file specified on XSAVE. */
 333 static int
 334 save_trns_proc (struct trns_header *h, struct ccase *c, int case_num UNUSED)
 335 {
 336   struct save_trns *t = (struct save_trns *) h;
 337   do_write_case (t, c);
 338   return -1;
 339 }
 340
 341 /* Frees a SAVE transformation. */
 342 static void
 343 save_trns_free (struct trns_header *t_)
 344 {
 345   struct save_trns *t = (struct save_trns *) t_;
 346
 347   if (t != NULL)
 348     {
 349       sfm_close_writer (t->writer);
 350       destroy_case_map (t->map);
 351       case_destroy (&t->bounce);
 352     }
 353 }
 354
 355 static bool rename_variables (struct dictionary *dict);
 356 static bool drop_variables (struct dictionary *dict);
 357 static bool keep_variables (struct dictionary *dict);
 358
 359 /* Commands that read and write system files share a great deal
 360    of common syntactic structure for rearranging and dropping
 361    variables.  This function parses this syntax and modifies DICT
 362    appropriately.
 363
 364    OP is the operation being performed.  For operations that
 365    write a system file, *COMPRESS is set to 1 if the system file
 366    should be compressed, 0 otherwise.
 367
 368    Returns true on success, false on failure. */
 369 static bool
 370 trim_dictionary (struct dictionary *dict, enum operation op, int *compress)
 371 {
 372   assert ((compress != NULL) == (op == OP_SAVE));
 373   if (get_scompression())
 374     *compress = 1;
 375
 376   if (op == OP_SAVE || op == OP_EXPORT)
 377     {
 378       /* Delete all the scratch variables. */
 379       struct variable **v;
 380       size_t nv;
 381       size_t i;
 382
 383       v = xmalloc (sizeof *v * dict_get_var_cnt (dict));
 384       nv = 0;
 385       for (i = 0; i < dict_get_var_cnt (dict); i++)
 386         if (dict_class_from_id (dict_get_var (dict, i)->name) == DC_SCRATCH)
 387           v[nv++] = dict_get_var (dict, i);
 388       dict_delete_vars (dict, v, nv);
 389       free (v);
 390     }
 391
 392   while (lex_match ('/'))
 393     {
 394       bool ok = true;
 395
 396       if (op == OP_SAVE && lex_match_id ("COMPRESSED"))
 397         *compress = 1;
 398       else if (op == OP_SAVE && lex_match_id ("UNCOMPRESSED"))
 399         *compress = 0;
 400       else if (lex_match_id ("DROP"))
 401         ok = drop_variables (dict);
 402       else if (lex_match_id ("KEEP"))
 403         ok = keep_variables (dict);
 404       else if (lex_match_id ("RENAME"))
 405         ok = rename_variables (dict);
 406       else
 407         {
 408           lex_error (_("expecting a valid subcommand"));
 409           ok = false;
 410         }
 411
 412       if (!ok)
 413         return false;
 414     }
 415
 416   if (!lex_end_of_command ())
 417     return false;
 418
 419   dict_compact_values (dict);
 420   return true;
 421 }
 422
 423 /* Parses and performs the RENAME subcommand of GET and SAVE. */
 424 static bool
 425 rename_variables (struct dictionary *dict)
 426 {
 427   int i;
 428
 429   int success = 0;
 430
 431   struct variable **v;
 432   char **new_names;
 433   int nv, nn;
 434   char *err_name;
 435
 436   int group;
 437
 438   lex_match ('=');
 439   if (token != '(')
 440     {
 441       struct variable *v;
 442
 443       v = parse_dict_variable (dict);
 444       if (v == NULL)
 445         return 0;
 446       if (!lex_force_match ('=')
 447           || !lex_force_id ())
 448         return 0;
 449       if (dict_lookup_var (dict, tokid) != NULL)
 450         {
 451           msg (SE, _("Cannot rename %s as %s because there already exists "
 452                      "a variable named %s.  To rename variables with "
 453                      "overlapping names, use a single RENAME subcommand "
 454                      "such as \"/RENAME (A=B)(B=C)(C=A)\", or equivalently, "
 455                      "\"/RENAME (A B C=B C A)\"."), v->name, tokid, tokid);
 456           return 0;
 457         }
 458
 459       dict_rename_var (dict, v, tokid);
 460       lex_get ();
 461       return 1;
 462     }
 463
 464   nv = nn = 0;
 465   v = NULL;
 466   new_names = 0;
 467   group = 1;
 468   while (lex_match ('('))
 469     {
 470       int old_nv = nv;
 471
 472       if (!parse_variables (dict, &v, &nv, PV_NO_DUPLICATE | PV_APPEND))
 473         goto done;
 474       if (!lex_match ('='))
 475         {
 476           msg (SE, _("`=' expected after variable list."));
 477           goto done;
 478         }
 479       if (!parse_DATA_LIST_vars (&new_names, &nn, PV_APPEND | PV_NO_SCRATCH))
 480         goto done;
 481       if (nn != nv)
 482         {
 483           msg (SE, _("Number of variables on left side of `=' (%d) does not "
 484                "match number of variables on right side (%d), in "
 485                "parenthesized group %d of RENAME subcommand."),
 486                nv - old_nv, nn - old_nv, group);
 487           goto done;
 488         }
 489       if (!lex_force_match (')'))
 490         goto done;
 491       group++;
 492     }
 493
 494   if (!dict_rename_vars (dict, v, new_names, nv, &err_name))
 495     {
 496       msg (SE, _("Requested renaming duplicates variable name %s."), err_name);
 497       goto done;
 498     }
 499   success = 1;
 500
 501 done:
 502   for (i = 0; i < nn; i++)
 503     free (new_names[i]);
 504   free (new_names);
 505   free (v);
 506
 507   return success;
 508 }
 509
 510 /* Parses and performs the DROP subcommand of GET and SAVE.
 511    Returns true if successful, false on failure.*/
 512 static bool
 513 drop_variables (struct dictionary *dict)
 514 {
 515   struct variable **v;
 516   int nv;
 517
 518   lex_match ('=');
 519   if (!parse_variables (dict, &v, &nv, PV_NONE))
 520     return false;
 521   dict_delete_vars (dict, v, nv);
 522   free (v);
 523
 524   if (dict_get_var_cnt (dict) == 0)
 525     {
 526       msg (SE, _("Cannot DROP all variables from dictionary."));
 527       return false;
 528     }
 529   return true;
 530 }
 531
 532 /* Parses and performs the KEEP subcommand of GET and SAVE.
 533    Returns true if successful, false on failure.*/
 534 static bool
 535 keep_variables (struct dictionary *dict)
 536 {
 537   struct variable **v;
 538   int nv;
 539   int i;
 540
 541   lex_match ('=');
 542   if (!parse_variables (dict, &v, &nv, PV_NONE))
 543     return false;
 544
 545   /* Move the specified variables to the beginning. */
 546   dict_reorder_vars (dict, v, nv);
 547
 548   /* Delete the remaining variables. */
 549   v = xrealloc (v, (dict_get_var_cnt (dict) - nv) * sizeof *v);
 550   for (i = nv; i < dict_get_var_cnt (dict); i++)
 551     v[i - nv] = dict_get_var (dict, i);
 552   dict_delete_vars (dict, v, dict_get_var_cnt (dict) - nv);
 553   free (v);
 554
 555   return true;
 556 }
 557 \f
 558 /* EXPORT procedure. */
 559 struct export_proc
 560   {
 561     struct pfm_writer *writer;  /* System file writer. */
 562     struct case_map *map;       /* Map from active file to system file dict. */
 563     struct ccase bounce;        /* Bounce buffer. */
 564   };
 565
 566 static int export_write_case_func (struct ccase *, void *);
 567 static void export_proc_free (struct export_proc *);
 568
 569 /* Parses the EXPORT command.  */
 570 /* FIXME: same as cmd_save_internal(). */
 571 int
 572 cmd_export (void)
 573 {
 574   struct file_handle *fh;
 575   struct dictionary *dict;
 576   struct export_proc *proc;
 577
 578   proc = xmalloc (sizeof *proc);
 579   proc->writer = NULL;
 580   proc->map = NULL;
 581   case_nullify (&proc->bounce);
 582
 583   lex_match ('/');
 584   if (lex_match_id ("OUTFILE"))
 585     lex_match ('=');
 586   fh = fh_parse ();
 587   if (fh == NULL)
 588     return CMD_FAILURE;
 589
 590   dict = dict_clone (default_dict);
 591   start_case_map (dict);
 592   if (!trim_dictionary (dict, OP_EXPORT, NULL))
 593     goto error;
 594   proc->map = finish_case_map (dict);
 595   if (proc->map != NULL)
 596     case_create (&proc->bounce, dict_get_next_value_idx (dict));
 597
 598   proc->writer = pfm_open_writer (fh, dict);
 599   if (proc->writer == NULL)
 600     goto error;
 601
 602   dict_destroy (dict);
 603
 604   procedure (export_write_case_func, proc);
 605   export_proc_free (proc);
 606   free (proc);
 607
 608   return CMD_SUCCESS;
 609
 610  error:
 611   dict_destroy (dict);
 612   export_proc_free (proc);
 613   free (proc);
 614   return CMD_FAILURE;
 615 }
 616
 617 /* Writes case C to the EXPORT file. */
 618 static int
 619 export_write_case_func (struct ccase *c, void *aux)
 620 {
 621   struct export_proc *proc = aux;
 622   if (proc->map == NULL)
 623     pfm_write_case (proc->writer, c);
 624   else
 625     {
 626       map_case (proc->map, c, &proc->bounce);
 627       pfm_write_case (proc->writer, &proc->bounce);
 628     }
 629   return 1;
 630 }
 631
 632 static void
 633 export_proc_free (struct export_proc *proc)
 634 {
 635   if (proc != NULL)
 636     {
 637       pfm_close_writer (proc->writer);
 638       destroy_case_map (proc->map);
 639       case_destroy (&proc->bounce);
 640     }
 641 }
 642 \f
 643 /* MATCH FILES. */
 644
 645 #include "debug-print.h"
 646
 647 /* File types. */
 648 enum
 649   {
 650     MTF_FILE,                   /* Specified on FILE= subcommand. */
 651     MTF_TABLE                   /* Specified on TABLE= subcommand. */
 652   };
 653
 654 /* One of the files on MATCH FILES. */
 655 struct mtf_file
 656   {
 657     struct mtf_file *next, *prev;
 658                                 /* Next, previous in the list of files. */
 659     struct mtf_file *next_min;  /* Next in the chain of minimums. */
 660
 661     int type;                   /* One of MTF_*. */
 662     struct variable **by;       /* List of BY variables for this file. */
 663     struct file_handle *handle; /* File handle. */
 664     struct sfm_reader *reader;  /* System file reader. */
 665     struct dictionary *dict;    /* Dictionary from system file. */
 666
 667     /* IN subcommand. */
 668     char *in_name;              /* Variable name. */
 669     struct variable *in_var;    /* Variable (in master dictionary). */
 670
 671     struct ccase input;         /* Input record. */
 672   };
 673
 674 /* MATCH FILES procedure. */
 675 struct mtf_proc
 676   {
 677     struct mtf_file *head;      /* First file mentioned on FILE or TABLE. */
 678     struct mtf_file *tail;      /* Last file mentioned on FILE or TABLE. */
 679
 680     size_t by_cnt;              /* Number of variables on BY subcommand. */
 681
 682     /* Names of FIRST, LAST variables. */
 683     char first[LONG_NAME_LEN + 1], last[LONG_NAME_LEN + 1];
 684
 685     struct dictionary *dict;    /* Dictionary of output file. */
 686     struct case_sink *sink;     /* Sink to receive output. */
 687     struct ccase mtf_case;      /* Case used for output. */
 688
 689     unsigned seq_num;           /* Have we initialized this variable? */
 690     unsigned *seq_nums;         /* Sequence numbers for each var in dict. */
 691   };
 692
 693 static void mtf_free (struct mtf_proc *);
 694 static void mtf_free_file (struct mtf_file *);
 695 static int mtf_merge_dictionary (struct dictionary *const, struct mtf_file *);
 696 static void mtf_delete_file_in_place (struct mtf_proc *, struct mtf_file **);
 697
 698 static void mtf_read_nonactive_records (void *);
 699 static void mtf_processing_finish (void *);
 700 static int mtf_processing (struct ccase *, void *);
 701
 702 static char *var_type_description (struct variable *);
 703
 704 static void set_master (struct variable *, struct variable *master);
 705 static struct variable *get_master (struct variable *);
 706
 707 /* Parse and execute the MATCH FILES command. */
 708 int
 709 cmd_match_files (void)
 710 {
 711   struct mtf_proc mtf;
 712   struct mtf_file *first_table = NULL;
 713   struct mtf_file *iter;
 714
 715   bool used_active_file = false;
 716   bool saw_table = false;
 717   bool saw_in = false;
 718
 719   mtf.head = mtf.tail = NULL;
 720   mtf.by_cnt = 0;
 721   mtf.first[0] = '\0';
 722   mtf.last[0] = '\0';
 723   mtf.dict = dict_create ();
 724   mtf.sink = NULL;
 725   case_nullify (&mtf.mtf_case);
 726   mtf.seq_num = 0;
 727   mtf.seq_nums = NULL;
 728   dict_set_case_limit (mtf.dict, dict_get_case_limit (default_dict));
 729
 730   lex_match ('/');
 731   while (token == T_ID
 732          && (lex_id_match ("FILE", tokid) || lex_id_match ("TABLE", tokid)))
 733     {
 734       struct mtf_file *file = xmalloc (sizeof *file);
 735
 736       if (lex_match_id ("FILE"))
 737         file->type = MTF_FILE;
 738       else if (lex_match_id ("TABLE"))
 739         {
 740           file->type = MTF_TABLE;
 741           saw_table = true;
 742         }
 743       else
 744         assert (0);
 745       lex_match ('=');
 746
 747       file->by = NULL;
 748       file->handle = NULL;
 749       file->reader = NULL;
 750       file->dict = NULL;
 751       file->in_name = NULL;
 752       file->in_var = NULL;
 753       case_nullify (&file->input);
 754
 755       /* FILEs go first, then TABLEs. */
 756       if (file->type == MTF_TABLE || first_table == NULL)
 757         {
 758           file->next = NULL;
 759           file->prev = mtf.tail;
 760           if (mtf.tail)
 761             mtf.tail->next = file;
 762           mtf.tail = file;
 763           if (mtf.head == NULL)
 764             mtf.head = file;
 765           if (file->type == MTF_TABLE && first_table == NULL)
 766             first_table = file;
 767         }
 768       else
 769         {
 770           assert (file->type == MTF_FILE);
 771           file->next = first_table;
 772           file->prev = first_table->prev;
 773           if (first_table->prev)
 774             first_table->prev->next = file;
 775           else
 776             mtf.head = file;
 777           first_table->prev = file;
 778         }
 779
 780       if (lex_match ('*'))
 781         {
 782           file->handle = NULL;
 783           file->reader = NULL;
 784
 785           if (used_active_file)
 786             {
 787               msg (SE, _("The active file may not be specified more "
 788                          "than once."));
 789               goto error;
 790             }
 791           used_active_file = true;
 792
 793           assert (pgm_state != STATE_INPUT);
 794           if (pgm_state == STATE_INIT)
 795             {
 796               msg (SE, _("Cannot specify the active file since no active "
 797                          "file has been defined."));
 798               goto error;
 799             }
 800
 801           if (temporary != 0)
 802             {
 803               msg (SE,
 804                    _("MATCH FILES may not be used after TEMPORARY when "
 805                      "the active file is an input source.  "
 806                      "Temporary transformations will be made permanent."));
 807               cancel_temporary ();
 808             }
 809
 810           file->dict = default_dict;
 811         }
 812       else
 813         {
 814           file->handle = fh_parse ();
 815           if (file->handle == NULL)
 816             goto error;
 817
 818           file->reader = sfm_open_reader (file->handle, &file->dict, NULL);
 819           if (file->reader == NULL)
 820             goto error;
 821
 822           case_create (&file->input, dict_get_next_value_idx (file->dict));
 823         }
 824
 825       while (lex_match ('/'))
 826         if (lex_match_id ("RENAME"))
 827           {
 828             if (!rename_variables (file->dict))
 829               goto error;
 830           }
 831         else if (lex_match_id ("IN"))
 832           {
 833             lex_match ('=');
 834             if (token != T_ID)
 835               {
 836                 lex_error (NULL);
 837                 goto error;
 838               }
 839
 840             if (file->in_name != NULL)
 841               {
 842                 msg (SE, _("Multiple IN subcommands for a single FILE or "
 843                            "TABLE."));
 844                 goto error;
 845               }
 846             file->in_name = xstrdup (tokid);
 847             lex_get ();
 848             saw_in = true;
 849           }
 850
 851       mtf_merge_dictionary (mtf.dict, file);
 852     }
 853
 854   while (token != '.')
 855     {
 856       if (lex_match (T_BY))
 857         {
 858           struct variable **by;
 859
 860           if (mtf.by_cnt)
 861             {
 862               msg (SE, _("BY may appear at most once."));
 863               goto error;
 864             }
 865
 866           lex_match ('=');
 867           if (!parse_variables (mtf.dict, &by, &mtf.by_cnt,
 868                                 PV_NO_DUPLICATE | PV_NO_SCRATCH))
 869             goto error;
 870
 871           for (iter = mtf.head; iter != NULL; iter = iter->next)
 872             {
 873               int i;
 874
 875               iter->by = xmalloc (sizeof *iter->by * mtf.by_cnt);
 876
 877               for (i = 0; i < mtf.by_cnt; i++)
 878                 {
 879                   iter->by[i] = dict_lookup_var (iter->dict, by[i]->name);
 880                   if (iter->by[i] == NULL)
 881                     {
 882                       msg (SE, _("File %s lacks BY variable %s."),
 883                            iter->handle ? handle_get_name (iter->handle) : "*",
 884                            by[i]->name);
 885                       free (by);
 886                       goto error;
 887                     }
 888                 }
 889             }
 890         }
 891       else if (lex_match_id ("FIRST"))
 892         {
 893           if (mtf.first[0] != '\0')
 894             {
 895               msg (SE, _("FIRST may appear at most once."));
 896               goto error;
 897             }
 898
 899           lex_match ('=');
 900           if (!lex_force_id ())
 901             goto error;
 902           strcpy (mtf.first, tokid);
 903           lex_get ();
 904         }
 905       else if (lex_match_id ("LAST"))
 906         {
 907           if (mtf.last[0] != '\0')
 908             {
 909               msg (SE, _("LAST may appear at most once."));
 910               goto error;
 911             }
 912
 913           lex_match ('=');
 914           if (!lex_force_id ())
 915             goto error;
 916           strcpy (mtf.last, tokid);
 917           lex_get ();
 918         }
 919       else if (lex_match_id ("MAP"))
 920         {
 921           /* FIXME. */
 922         }
 923       else if (lex_match_id ("DROP"))
 924         {
 925           if (!drop_variables (mtf.dict))
 926             goto error;
 927         }
 928       else if (lex_match_id ("KEEP"))
 929         {
 930           if (!keep_variables (mtf.dict))
 931             goto error;
 932         }
 933       else
 934         {
 935           lex_error (NULL);
 936           goto error;
 937         }
 938
 939       if (!lex_match ('/') && token != '.')
 940         {
 941           lex_end_of_command ();
 942           goto error;
 943         }
 944     }
 945
 946   if (mtf.by_cnt == 0)
 947     {
 948       if (saw_table)
 949         {
 950           msg (SE, _("BY is required when TABLE is specified."));
 951           goto error;
 952         }
 953       if (saw_in)
 954         {
 955           msg (SE, _("BY is required when IN is specified."));
 956           goto error;
 957         }
 958     }
 959
 960   /* Set up mapping from each file's variables to master
 961      variables. */
 962   for (iter = mtf.head; iter != NULL; iter = iter->next)
 963     {
 964       struct dictionary *d = iter->dict;
 965       int i;
 966
 967       for (i = 0; i < dict_get_var_cnt (d); i++)
 968         {
 969           struct variable *v = dict_get_var (d, i);
 970           struct variable *mv = dict_lookup_var (mtf.dict, v->name);
 971           if (mv != NULL)
 972             set_master (v, mv);
 973         }
 974     }
 975
 976   /* Add IN variables to master dictionary. */
 977   for (iter = mtf.head; iter != NULL; iter = iter->next)
 978     if (iter->in_name != NULL)
 979       {
 980         static const struct fmt_spec f1_0 = {FMT_F, 1, 0};
 981
 982         iter->in_var = dict_create_var (mtf.dict, iter->in_name, 0);
 983         if (iter->in_var == NULL)
 984           {
 985             msg (SE, _("IN variable name %s duplicates an "
 986                        "existing variable name."),
 987                  iter->in_var);
 988             goto error;
 989           }
 990         iter->in_var->print = iter->in_var->write = f1_0;
 991       }
 992
 993   /* MATCH FILES performs an n-way merge on all its input files.
 994      Abstract algorithm:
 995
 996      1. Read one input record from every input FILE.
 997
 998      2. If no FILEs are left, stop.  Otherwise, proceed to step 3.
 999
1000      3. Find the FILE input record(s) that have minimum BY
1001      values.  Store all the values from these input records into
1002      the output record.
1003
1004      4. For every TABLE, read another record as long as the BY values
1005      on the TABLE's input record are less than the FILEs' BY values.
1006      If an exact match is found, store all the values from the TABLE
1007      input record into the output record.
1008
1009      5. Write the output record.
1010
1011      6. Read another record from each input file FILE and TABLE that
1012      we stored values from above.  If we come to the end of one of the
1013      input files, remove it from the list of input files.
1014
1015      7. Repeat from step 2.
1016
1017      Unfortunately, this algorithm can't be implemented in a
1018      straightforward way because there's no function to read a
1019      record from the active file.  Instead, it has to be written
1020      as a state machine.
1021
1022      FIXME: For merging large numbers of files (more than 10?) a
1023      better algorithm would use a heap for finding minimum
1024      values. */
1025
1026   if (!used_active_file)
1027     discard_variables ();
1028
1029   dict_compact_values (mtf.dict);
1030   mtf.sink = create_case_sink (&storage_sink_class, mtf.dict, NULL);
1031   if (mtf.sink->class->open != NULL)
1032     mtf.sink->class->open (mtf.sink);
1033
1034   mtf.seq_nums = xcalloc (dict_get_var_cnt (mtf.dict) * sizeof *mtf.seq_nums);
1035   case_create (&mtf.mtf_case, dict_get_next_value_idx (mtf.dict));
1036
1037   mtf_read_nonactive_records (&mtf);
1038   if (used_active_file)
1039     procedure (mtf_processing, &mtf);
1040   mtf_processing_finish (&mtf);
1041
1042   dict_destroy (default_dict);
1043   default_dict = mtf.dict;
1044   mtf.dict = NULL;
1045   vfm_source = mtf.sink->class->make_source (mtf.sink);
1046   free_case_sink (mtf.sink);
1047
1048   mtf_free (&mtf);
1049   return CMD_SUCCESS;
1050
1051 error:
1052   mtf_free (&mtf);
1053   return CMD_FAILURE;
1054 }
1055
1056 /* Repeats 2...7 an arbitrary number of times. */
1057 static void
1058 mtf_processing_finish (void *mtf_)
1059 {
1060   struct mtf_proc *mtf = mtf_;
1061   struct mtf_file *iter;
1062
1063   /* Find the active file and delete it. */
1064   for (iter = mtf->head; iter; iter = iter->next)
1065     if (iter->handle == NULL)
1066       {
1067         mtf_delete_file_in_place (mtf, &iter);
1068         break;
1069       }
1070
1071   while (mtf->head && mtf->head->type == MTF_FILE)
1072     if (!mtf_processing (NULL, mtf))
1073       break;
1074 }
1075
1076 /* Return a string in a static buffer describing V's variable type and
1077    width. */
1078 static char *
1079 var_type_description (struct variable *v)
1080 {
1081   static char buf[2][32];
1082   static int x = 0;
1083   char *s;
1084
1085   x ^= 1;
1086   s = buf[x];
1087
1088   if (v->type == NUMERIC)
1089     strcpy (s, "numeric");
1090   else
1091     {
1092       assert (v->type == ALPHA);
1093       sprintf (s, "string with width %d", v->width);
1094     }
1095   return s;
1096 }
1097
1098 /* Free FILE and associated data. */
1099 static void
1100 mtf_free_file (struct mtf_file *file)
1101 {
1102   free (file->by);
1103   sfm_close_reader (file->reader);
1104   if (file->dict != default_dict)
1105     dict_destroy (file->dict);
1106   case_destroy (&file->input);
1107   free (file->in_name);
1108   free (file);
1109 }
1110
1111 /* Free all the data for the MATCH FILES procedure. */
1112 static void
1113 mtf_free (struct mtf_proc *mtf)
1114 {
1115   struct mtf_file *iter, *next;
1116
1117   for (iter = mtf->head; iter; iter = next)
1118     {
1119       next = iter->next;
1120       mtf_free_file (iter);
1121     }
1122
1123   if (mtf->dict)
1124     dict_destroy (mtf->dict);
1125   case_destroy (&mtf->mtf_case);
1126   free (mtf->seq_nums);
1127 }
1128
1129 /* Remove *FILE from the mtf_file chain.  Make *FILE point to the next
1130    file in the chain, or to NULL if was the last in the chain. */
1131 static void
1132 mtf_delete_file_in_place (struct mtf_proc *mtf, struct mtf_file **file)
1133 {
1134   struct mtf_file *f = *file;
1135   int i;
1136
1137   if (f->prev)
1138     f->prev->next = f->next;
1139   if (f->next)
1140     f->next->prev = f->prev;
1141   if (f == mtf->head)
1142     mtf->head = f->next;
1143   if (f == mtf->tail)
1144     mtf->tail = f->prev;
1145   *file = f->next;
1146
1147   if (f->in_var != NULL)
1148     case_data_rw (&mtf->mtf_case, f->in_var->fv)->f = 0.;
1149   for (i = 0; i < dict_get_var_cnt (f->dict); i++)
1150     {
1151       struct variable *v = dict_get_var (f->dict, i);
1152       struct variable *mv = get_master (v);
1153       if (mv != NULL)
1154         {
1155           union value *out = case_data_rw (&mtf->mtf_case, mv->fv);
1156
1157           if (v->type == NUMERIC)
1158             out->f = SYSMIS;
1159           else
1160             memset (out->s, ' ', v->width);
1161         }
1162     }
1163
1164   mtf_free_file (f);
1165 }
1166
1167 /* Read a record from every input file except the active file. */
1168 static void
1169 mtf_read_nonactive_records (void *mtf_)
1170 {
1171   struct mtf_proc *mtf = mtf_;
1172   struct mtf_file *iter, *next;
1173
1174   for (iter = mtf->head; iter != NULL; iter = next)
1175     {
1176       next = iter->next;
1177       if (iter->handle && !sfm_read_case (iter->reader, &iter->input))
1178         mtf_delete_file_in_place (mtf, &iter);
1179     }
1180 }
1181
1182 /* Compare the BY variables for files A and B; return -1 if A < B, 0
1183    if A == B, 1 if A > B. */
1184 static inline int
1185 mtf_compare_BY_values (struct mtf_proc *mtf,
1186                        struct mtf_file *a, struct mtf_file *b,
1187                        struct ccase *c)
1188 {
1189   struct ccase *ca = case_is_null (&a->input) ? c : &a->input;
1190   struct ccase *cb = case_is_null (&b->input) ? c : &b->input;
1191   assert ((a == NULL) + (b == NULL) + (c == NULL) <= 1);
1192   return case_compare_2dict (ca, cb, a->by, b->by, mtf->by_cnt);
1193 }
1194
1195 /* Perform one iteration of steps 3...7 above. */
1196 static int
1197 mtf_processing (struct ccase *c, void *mtf_)
1198 {
1199   struct mtf_proc *mtf = mtf_;
1200
1201   /* Do we need another record from the active file? */
1202   bool read_active_file;
1203
1204   assert (mtf->head != NULL);
1205   assert (mtf->head->type == MTF_FILE);
1206   do
1207     {
1208       struct mtf_file *min_head, *min_tail; /* Files with minimum BY values. */
1209       struct mtf_file *max_head, *max_tail; /* Files with non-minimum BYs. */
1210       struct mtf_file *iter, *next;
1211
1212       read_active_file = false;
1213
1214       /* 3. Find the FILE input record(s) that have minimum BY
1215          values.  Store all the values from these input records into
1216          the output record. */
1217       min_head = min_tail = mtf->head;
1218       max_head = max_tail = NULL;
1219       for (iter = mtf->head->next; iter && iter->type == MTF_FILE;
1220            iter = iter->next)
1221         switch (mtf_compare_BY_values (mtf, min_head, iter, c))
1222           {
1223           case -1:
1224             if (max_head)
1225               max_tail = max_tail->next_min = iter;
1226             else
1227               max_head = max_tail = iter;
1228             break;
1229
1230           case 0:
1231             min_tail = min_tail->next_min = iter;
1232             break;
1233
1234           case 1:
1235             if (max_head)
1236               {
1237                 max_tail->next_min = min_head;
1238                 max_tail = min_tail;
1239               }
1240             else
1241               {
1242                 max_head = min_head;
1243                 max_tail = min_tail;
1244               }
1245             min_head = min_tail = iter;
1246             break;
1247
1248           default:
1249             assert (0);
1250           }
1251
1252       /* 4. For every TABLE, read another record as long as the BY
1253          values on the TABLE's input record are less than the FILEs'
1254          BY values.  If an exact match is found, store all the values
1255          from the TABLE input record into the output record. */
1256       for (; iter != NULL; iter = next)
1257         {
1258           assert (iter->type == MTF_TABLE);
1259
1260           next = iter->next;
1261
1262         again:
1263           switch (mtf_compare_BY_values (mtf, min_head, iter, c))
1264             {
1265             case -1:
1266               if (max_head)
1267                 max_tail = max_tail->next_min = iter;
1268               else
1269                 max_head = max_tail = iter;
1270               break;
1271
1272             case 0:
1273               min_tail = min_tail->next_min = iter;
1274               break;
1275
1276             case 1:
1277               if (iter->handle == NULL)
1278                 return 1;
1279               if (sfm_read_case (iter->reader, &iter->input))
1280                 goto again;
1281               mtf_delete_file_in_place (mtf, &iter);
1282               break;
1283
1284             default:
1285               assert (0);
1286             }
1287         }
1288
1289       /* Next sequence number. */
1290       mtf->seq_num++;
1291
1292       /* Store data to all the records we are using. */
1293       if (min_tail)
1294         min_tail->next_min = NULL;
1295       for (iter = min_head; iter; iter = iter->next_min)
1296         {
1297           int i;
1298
1299           for (i = 0; i < dict_get_var_cnt (iter->dict); i++)
1300             {
1301               struct variable *v = dict_get_var (iter->dict, i);
1302               struct variable *mv = get_master (v);
1303
1304               if (mv != NULL && mtf->seq_nums[mv->index] != mtf->seq_num)
1305                 {
1306                   struct ccase *record
1307                     = case_is_null (&iter->input) ? c : &iter->input;
1308                   union value *out = case_data_rw (&mtf->mtf_case, mv->fv);
1309
1310                   mtf->seq_nums[mv->index] = mtf->seq_num;
1311                   if (v->type == NUMERIC)
1312                     out->f = case_num (record, v->fv);
1313                   else
1314                     memcpy (out->s, case_str (record, v->fv), v->width);
1315                 }
1316             }
1317           if (iter->in_var != NULL)
1318             case_data_rw (&mtf->mtf_case, iter->in_var->fv)->f = 1.;
1319
1320           if (iter->type == MTF_FILE && iter->handle == NULL)
1321             read_active_file = true;
1322         }
1323
1324       /* Store missing values to all the records we're not
1325          using. */
1326       if (max_tail)
1327         max_tail->next_min = NULL;
1328       for (iter = max_head; iter; iter = iter->next_min)
1329         {
1330           int i;
1331
1332           for (i = 0; i < dict_get_var_cnt (iter->dict); i++)
1333             {
1334               struct variable *v = dict_get_var (iter->dict, i);
1335               struct variable *mv = get_master (v);
1336
1337               if (mv != NULL && mtf->seq_nums[mv->index] != mtf->seq_num)
1338                 {
1339                   union value *out = case_data_rw (&mtf->mtf_case, mv->fv);
1340                   mtf->seq_nums[mv->index] = mtf->seq_num;
1341
1342                   if (v->type == NUMERIC)
1343                     out->f = SYSMIS;
1344                   else
1345                     memset (out->s, ' ', v->width);
1346                 }
1347             }
1348           if (iter->in_var != NULL)
1349             case_data_rw (&mtf->mtf_case, iter->in_var->fv)->f = 0.;
1350         }
1351
1352       /* 5. Write the output record. */
1353       mtf->sink->class->write (mtf->sink, &mtf->mtf_case);
1354
1355       /* 6. Read another record from each input file FILE and TABLE
1356          that we stored values from above.  If we come to the end of
1357          one of the input files, remove it from the list of input
1358          files. */
1359       for (iter = min_head; iter && iter->type == MTF_FILE; iter = next)
1360         {
1361           next = iter->next_min;
1362           if (iter->reader != NULL
1363               && !sfm_read_case (iter->reader, &iter->input))
1364             mtf_delete_file_in_place (mtf, &iter);
1365         }
1366     }
1367   while (!read_active_file
1368          && mtf->head != NULL && mtf->head->type == MTF_FILE);
1369
1370   return mtf->head != NULL && mtf->head->type == MTF_FILE;
1371 }
1372
1373 /* Merge the dictionary for file F into master dictionary M. */
1374 static int
1375 mtf_merge_dictionary (struct dictionary *const m, struct mtf_file *f)
1376 {
1377   struct dictionary *d = f->dict;
1378   const char *d_docs, *m_docs;
1379   int i;
1380
1381   if (dict_get_label (m) == NULL)
1382     dict_set_label (m, dict_get_label (d));
1383
1384   d_docs = dict_get_documents (d);
1385   m_docs = dict_get_documents (m);
1386   if (d_docs != NULL)
1387     {
1388       if (m_docs == NULL)
1389         dict_set_documents (m, d_docs);
1390       else
1391         {
1392           char *new_docs;
1393           size_t new_len;
1394
1395           new_len = strlen (m_docs) + strlen (d_docs);
1396           new_docs = xmalloc (new_len + 1);
1397           strcpy (new_docs, m_docs);
1398           strcat (new_docs, d_docs);
1399           dict_set_documents (m, new_docs);
1400           free (new_docs);
1401         }
1402     }
1403
1404   for (i = 0; i < dict_get_var_cnt (d); i++)
1405     {
1406       struct variable *dv = dict_get_var (d, i);
1407       struct variable *mv = dict_lookup_var (m, dv->name);
1408
1409       if (dict_class_from_id (dv->name) == DC_SCRATCH)
1410         continue;
1411
1412       if (mv != NULL)
1413         {
1414           if (mv->width != dv->width)
1415             {
1416               msg (SE, _("Variable %s in file %s (%s) has different "
1417                          "type or width from the same variable in "
1418                          "earlier file (%s)."),
1419                    dv->name, handle_get_name (f->handle),
1420                    var_type_description (dv), var_type_description (mv));
1421               return 0;
1422             }
1423
1424           if (dv->width == mv->width)
1425             {
1426               if (val_labs_count (dv->val_labs)
1427                   && !val_labs_count (mv->val_labs))
1428                 mv->val_labs = val_labs_copy (dv->val_labs);
1429               if (dv->miss_type != MISSING_NONE
1430                   && mv->miss_type == MISSING_NONE)
1431                 copy_missing_values (mv, dv);
1432             }
1433
1434           if (dv->label && !mv->label)
1435             mv->label = xstrdup (dv->label);
1436         }
1437       else
1438         mv = dict_clone_var_assert (m, dv, dv->name);
1439     }
1440
1441   return 1;
1442 }
1443
1444 /* Marks V's master variable as MASTER. */
1445 static void
1446 set_master (struct variable *v, struct variable *master)
1447 {
1448   var_attach_aux (v, master, NULL);
1449 }
1450
1451 /* Returns the master variable corresponding to V,
1452    as set with set_master(). */
1453 static struct variable *
1454 get_master (struct variable *v)
1455 {
1456   return v->aux;
1457 }
1458 \f
1459 /* IMPORT command. */
1460
1461 /* IMPORT input program. */
1462 struct import_pgm
1463   {
1464     struct pfm_reader *reader;  /* Portable file reader. */
1465     struct case_map *map;       /* Map from system file to active file dict. */
1466     struct ccase bounce;        /* Bounce buffer. */
1467   };
1468
1469 static void import_pgm_free (struct import_pgm *);
1470
1471 /* Parses the IMPORT command. */
1472 int
1473 cmd_import (void)
1474 {
1475   struct import_pgm *pgm = NULL;
1476   struct file_handle *fh = NULL;
1477   struct dictionary *dict = NULL;
1478   int type;
1479
1480   pgm = xmalloc (sizeof *pgm);
1481   pgm->reader = NULL;
1482   pgm->map = NULL;
1483   case_nullify (&pgm->bounce);
1484
1485   for (;;)
1486     {
1487       lex_match ('/');
1488
1489       if (lex_match_id ("FILE") || token == T_STRING)
1490         {
1491           lex_match ('=');
1492
1493           fh = fh_parse ();
1494           if (fh == NULL)
1495             return CMD_FAILURE;
1496         }
1497       else if (lex_match_id ("TYPE"))
1498         {
1499           lex_match ('=');
1500
1501           if (lex_match_id ("COMM"))
1502             type = PFM_COMM;
1503           else if (lex_match_id ("TAPE"))
1504             type = PFM_TAPE;
1505           else
1506             {
1507               lex_error (_("expecting COMM or TAPE"));
1508               return CMD_FAILURE;
1509             }
1510         }
1511       else break;
1512     }
1513   if (!lex_match ('/') && token != '.')
1514     {
1515       lex_error (NULL);
1516       return CMD_FAILURE;
1517     }
1518
1519   discard_variables ();
1520
1521   pgm->reader = pfm_open_reader (fh, &dict, NULL);
1522   if (pgm->reader == NULL)
1523     return CMD_FAILURE;
1524   case_create (&pgm->bounce, dict_get_next_value_idx (dict));
1525
1526   start_case_map (dict);
1527   if (!trim_dictionary (dict, OP_READ, NULL))
1528     goto error;
1529   pgm->map = finish_case_map (dict);
1530
1531   dict_destroy (default_dict);
1532   default_dict = dict;
1533
1534   vfm_source = create_case_source (&import_source_class, pgm);
1535
1536   return CMD_SUCCESS;
1537
1538  error:
1539   import_pgm_free (pgm);
1540   if (dict != NULL)
1541     dict_destroy (dict);
1542   return CMD_FAILURE;
1543 }
1544
1545 /* Frees a struct import_pgm. */
1546 static void
1547 import_pgm_free (struct import_pgm *pgm)
1548 {
1549   if (pgm != NULL)
1550     {
1551       pfm_close_reader (pgm->reader);
1552       destroy_case_map (pgm->map);
1553       case_destroy (&pgm->bounce);
1554       free (pgm);
1555     }
1556 }
1557
1558 /* Clears internal state related to IMPORT input procedure. */
1559 static void
1560 import_source_destroy (struct case_source *source)
1561 {
1562   struct import_pgm *pgm = source->aux;
1563   import_pgm_free (pgm);
1564 }
1565
1566 /* Reads all the cases from the data file into C and passes them
1567    to WRITE_CASE one by one, passing WC_DATA. */
1568 static void
1569 import_source_read (struct case_source *source,
1570                  struct ccase *c,
1571                  write_case_func *write_case, write_case_data wc_data)
1572 {
1573   struct import_pgm *pgm = source->aux;
1574   int ok;
1575
1576   do
1577     {
1578       if (pgm->map == NULL)
1579         ok = pfm_read_case (pgm->reader, c);
1580       else
1581         {
1582           ok = pfm_read_case (pgm->reader, &pgm->bounce);
1583           if (ok)
1584             map_case (pgm->map, &pgm->bounce, c);
1585         }
1586
1587       if (ok)
1588         ok = write_case (wc_data);
1589     }
1590   while (ok);
1591 }
1592
1593 const struct case_source_class import_source_class =
1594   {
1595     "IMPORT",
1596     NULL,
1597     import_source_read,
1598     import_source_destroy,
1599   };
1600
1601 \f
1602 /* Case map.
1603
1604    A case map copies data from a case that corresponds for one
1605    dictionary to a case that corresponds to a second dictionary
1606    derived from the first by, optionally, deleting, reordering,
1607    or renaming variables.  (No new variables may be created.)
1608    */
1609
1610 /* A case map. */
1611 struct case_map
1612   {
1613     size_t value_cnt;   /* Number of values in map. */
1614     int *map;           /* For each destination index, the
1615                            corresponding source index. */
1616   };
1617
1618 /* Prepares dictionary D for producing a case map.  Afterward,
1619    the caller may delete, reorder, or rename variables within D
1620    at will before using finish_case_map() to produce the case
1621    map.
1622
1623    Uses D's aux members, which may not otherwise be in use. */
1624 static void
1625 start_case_map (struct dictionary *d)
1626 {
1627   size_t var_cnt = dict_get_var_cnt (d);
1628   size_t i;
1629
1630   for (i = 0; i < var_cnt; i++)
1631     {
1632       struct variable *v = dict_get_var (d, i);
1633       int *src_fv = xmalloc (sizeof *src_fv);
1634       *src_fv = v->fv;
1635       var_attach_aux (v, src_fv, var_dtor_free);
1636     }
1637 }
1638
1639 /* Produces a case map from dictionary D, which must have been
1640    previously prepared with start_case_map().
1641
1642    Does not retain any reference to D, and clears the aux members
1643    set up by start_case_map().
1644
1645    Returns the new case map, or a null pointer if no mapping is
1646    required (that is, no data has changed position). */
1647 static struct case_map *
1648 finish_case_map (struct dictionary *d)
1649 {
1650   struct case_map *map;
1651   size_t var_cnt = dict_get_var_cnt (d);
1652   size_t i;
1653   int identity_map;
1654
1655   map = xmalloc (sizeof *map);
1656   map->value_cnt = dict_get_next_value_idx (d);
1657   map->map = xmalloc (sizeof *map->map * map->value_cnt);
1658   for (i = 0; i < map->value_cnt; i++)
1659     map->map[i] = -1;
1660
1661   identity_map = 1;
1662   for (i = 0; i < var_cnt; i++)
1663     {
1664       struct variable *v = dict_get_var (d, i);
1665       int *src_fv = (int *) var_detach_aux (v);
1666       size_t idx;
1667
1668       if (v->fv != *src_fv)
1669         identity_map = 0;
1670
1671       for (idx = 0; idx < v->nv; idx++)
1672         {
1673           int src_idx = *src_fv + idx;
1674           int dst_idx = v->fv + idx;
1675
1676           assert (map->map[dst_idx] == -1);
1677           map->map[dst_idx] = src_idx;
1678         }
1679       free (src_fv);
1680     }
1681
1682   if (identity_map)
1683     {
1684       destroy_case_map (map);
1685       return NULL;
1686     }
1687
1688   while (map->value_cnt > 0 && map->map[map->value_cnt - 1] == -1)
1689     map->value_cnt--;
1690
1691   return map;
1692 }
1693
1694 /* Maps from SRC to DST, applying case map MAP. */
1695 static void
1696 map_case (const struct case_map *map,
1697           const struct ccase *src, struct ccase *dst)
1698 {
1699   size_t dst_idx;
1700
1701   assert (map != NULL);
1702   assert (src != NULL);
1703   assert (dst != NULL);
1704   assert (src != dst);
1705
1706   for (dst_idx = 0; dst_idx < map->value_cnt; dst_idx++)
1707     {
1708       int src_idx = map->map[dst_idx];
1709       if (src_idx != -1)
1710         *case_data_rw (dst, dst_idx) = *case_data (src, src_idx);
1711     }
1712 }
1713
1714 /* Destroys case map MAP. */
1715 static void
1716 destroy_case_map (struct case_map *map)
1717 {
1718   if (map != NULL)
1719     {
1720       free (map->map);
1721       free (map);
1722     }
1723 }