X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fget.c;h=aa3a4e4929bc0324685442c5f9408d6357471cd8;hb=bc2466a1677cc97a837a75439b3d4c3b49a8125a;hp=2a848d5440f3dfba7e29f4cf49606339fc447bc6;hpb=312ad23d59e643e0c72e7ad684b00f3432461dee;p=pspp-builds.git

diff --git a/src/get.c b/src/get.c
index 2a848d54..aa3a4e49 100644
--- a/src/get.c
+++ b/src/get.c
@@ -18,7 +18,7 @@
    02111-1307, USA. */
 
 #include <config.h>
-#include <assert.h>
+#include "error.h"
 #include <stdlib.h>
 #include "alloc.h"
 #include "command.h"
@@ -38,6 +38,13 @@
 
 #include "debug-print.h"
 
+/* GET or IMPORT input program. */
+struct get_pgm 
+  {
+    struct file_handle *handle; /* File to GET or IMPORT from. */
+    size_t case_size;           /* Case size in bytes. */
+  };
+
 /* XSAVE transformation (and related SAVE, EXPORT procedures). */
 struct save_trns
   {
@@ -54,16 +61,10 @@ struct save_trns
 #define GTSV_OPT_MATCH_FILES	004	/* The MATCH FILES procedure. */
 #define GTSV_OPT_NONE		0
 
-/* The file being read by the input program. */
-static struct file_handle *get_file;
-
-/* The transformation being used by the SAVE procedure. */
-static struct save_trns *trns;
-
 static int trim_dictionary (struct dictionary * dict, int *options);
 static int save_write_case_func (struct ccase *, void *);
-static int save_trns_proc (struct trns_header *, struct ccase *);
-static void save_trns_free (struct trns_header *);
+static trns_proc_func save_trns_proc;
+static trns_free_func save_trns_free;
 
 #if DEBUGGING
 void dump_dict_variables (struct dictionary *);
@@ -75,9 +76,9 @@ cmd_get (void)
 {
   struct file_handle *handle;
   struct dictionary *dict;
+  struct get_pgm *pgm;
   int options = GTSV_OPT_NONE;
 
-  lex_match_id ("GET");
   discard_variables ();
 
   lex_match ('/');
@@ -120,16 +121,24 @@ cmd_get (void)
   dict_destroy (default_dict);
   default_dict = dict;
 
-  vfm_source = &get_source;
-  get_file = handle;
+  pgm = xmalloc (sizeof *pgm);
+  pgm->handle = handle;
+  pgm->case_size = dict_get_case_size (default_dict);
+  vfm_source = create_case_source (&get_source_class, default_dict, pgm);
 
   return CMD_SUCCESS;
 }
 
-/* Parses the SAVE (for XSAVE==0) and XSAVE (for XSAVE==1)
-   commands.  */
+/* SAVE or XSAVE command? */
+enum save_cmd 
+  {
+    CMD_SAVE,
+    CMD_XSAVE
+  };
+
+/* Parses the SAVE and XSAVE commands.  */
 static int
-cmd_save_internal (int xsave)
+cmd_save_internal (enum save_cmd save_cmd)
 {
   struct file_handle *handle;
   struct dictionary *dict;
@@ -140,8 +149,6 @@ cmd_save_internal (int xsave)
 
   int i;
 
-  lex_match_id ("SAVE");
-
   lex_match ('/');
   if (lex_match_id ("OUTFILE"))
     lex_match ('=');
@@ -178,7 +185,7 @@ cmd_save_internal (int xsave)
     }
 
   /* Fill in transformation structure. */
-  t = trns = xmalloc (sizeof *t);
+  t = xmalloc (sizeof *t);
   t->h.proc = save_trns_proc;
   t->h.free = save_trns_free;
   t->f = handle;
@@ -189,15 +196,16 @@ cmd_save_internal (int xsave)
   t->case_buf = xmalloc (sizeof *t->case_buf * inf.case_size);
   dict_destroy (dict);
 
-  if (xsave == 0)
-    /* SAVE. */
+  if (save_cmd == CMD_SAVE)
     {
-      procedure (NULL, save_write_case_func, NULL, NULL);
+      procedure (save_write_case_func, t);
       save_trns_free (&t->h);
     }
-  else
-    /* XSAVE. */
-    add_transformation (&t->h);
+  else 
+    {
+      assert (save_cmd == CMD_XSAVE);
+      add_transformation (&t->h); 
+    }
 
   return CMD_SUCCESS;
 }
@@ -206,32 +214,26 @@ cmd_save_internal (int xsave)
 int
 cmd_save (void)
 {
-  return cmd_save_internal (0);
+  return cmd_save_internal (CMD_SAVE);
 }
 
 /* Parses the XSAVE transformation command. */
 int
 cmd_xsave (void)
 {
-  return cmd_save_internal (1);
+  return cmd_save_internal (CMD_XSAVE);
 }
 
-static int
-save_write_case_func (struct ccase * c, void *aux UNUSED)
-{
-  save_trns_proc (&trns->h, c);
-  return 1;
-}
-
-static int
-save_trns_proc (struct trns_header * t UNUSED, struct ccase * c)
+/* Writes the given C to the file specified by T. */
+static void
+do_write_case (struct save_trns *t, struct ccase *c) 
 {
-  flt64 *p = trns->case_buf;
+  flt64 *p = t->case_buf;
   int i;
 
-  for (i = 0; i < trns->nvar; i++)
+  for (i = 0; i < t->nvar; i++)
     {
-      struct variable *v = trns->var[i];
+      struct variable *v = t->var[i];
       if (v->type == NUMERIC)
 	{
 	  double src = c->data[v->fv].f;
@@ -249,10 +251,27 @@ save_trns_proc (struct trns_header * t UNUSED, struct ccase * c)
 	}
     }
 
-  sfm_write_case (trns->f, trns->case_buf, p - trns->case_buf);
+  sfm_write_case (t->f, t->case_buf, p - t->case_buf);
+}
+
+/* Writes case C to the system file specified on SAVE. */
+static int
+save_write_case_func (struct ccase *c, void *aux UNUSED)
+{
+  do_write_case (aux, c);
+  return 1;
+}
+
+/* Writes case C to the system file specified on XSAVE. */
+static int
+save_trns_proc (struct trns_header *h, struct ccase *c, int case_num UNUSED)
+{
+  struct save_trns *t = (struct save_trns *) h;
+  do_write_case (t, c);
   return -1;
 }
 
+/* Frees a SAVE transformation. */
 static void
 save_trns_free (struct trns_header *pt)
 {
@@ -277,7 +296,7 @@ static int rename_variables (struct dictionary * dict);
 static int
 trim_dictionary (struct dictionary *dict, int *options)
 {
-  if (set_scompression)
+  if (get_scompression())
     *options |= GTSV_OPT_COMPRESSED;
 
   if (*options & GTSV_OPT_SAVE)
@@ -290,7 +309,7 @@ trim_dictionary (struct dictionary *dict, int *options)
       v = xmalloc (sizeof *v * dict_get_var_cnt (dict));
       nv = 0;
       for (i = 0; i < dict_get_var_cnt (dict); i++) 
-        if (dict_get_var (dict, i)->name[0] == '#')
+        if (dict_class_from_id (dict_get_var (dict, i)->name) == DC_SCRATCH)
           v[nv++] = dict_get_var (dict, i);
       dict_delete_vars (dict, v, nv);
       free (v);
@@ -467,33 +486,36 @@ dump_dict_variables (struct dictionary * dict)
 
 /* Clears internal state related to GET input procedure. */
 static void
-get_source_destroy_source (void)
+get_source_destroy (struct case_source *source)
 {
+  struct get_pgm *pgm = source->aux;
+
   /* It is not necessary to destroy the dictionary because if we get
      to this point then the dictionary is default_dict. */
-  fh_close_handle (get_file);
+  fh_close_handle (pgm->handle);
+  free (pgm);
 }
 
-/* Reads all the cases from the data file and passes them to
-   write_case(). */
+/* Reads all the cases from the data file into C and passes them
+   to WRITE_CASE one by one, passing WC_DATA. */
 static void
-get_source_read (write_case_func *write_case, write_case_data wc_data)
+get_source_read (struct case_source *source,
+                 struct ccase *c,
+                 write_case_func *write_case, write_case_data wc_data)
 {
-  while (sfm_read_case (get_file, temp_case->data, default_dict)
+  struct get_pgm *pgm = source->aux;
+
+  while (sfm_read_case (pgm->handle, c->data, default_dict)
 	 && write_case (wc_data))
     ;
-  get_source_destroy_source ();
 }
 
-struct case_stream get_source =
+const struct case_source_class get_source_class =
   {
+    "GET",
     NULL,
     get_source_read,
-    NULL,
-    NULL,
-    get_source_destroy_source,
-    NULL,
-    "GET",
+    get_source_destroy,
   };
 
 
@@ -524,27 +546,27 @@ struct mtf_file
     union value *input;		/* Input record. */
   };
 
-/* All the files mentioned on FILE or TABLE. */
-static struct mtf_file *mtf_head, *mtf_tail;
-
-/* Variables on the BY subcommand. */
-static struct variable **mtf_by;
-static int mtf_n_by;
-
-/* Master dictionary. */
-static struct dictionary *mtf_master;
+/* MATCH FILES procedure. */
+struct mtf_proc 
+  {
+    struct mtf_file *head;      /* First file mentioned on FILE or TABLE. */
+    struct mtf_file *tail;      /* Last file mentioned on FILE or TABLE. */
+    
+    struct variable **by;       /* Variables on the BY subcommand. */
+    size_t by_cnt;              /* Number of variables on BY subcommand. */
 
-/* Used to determine whether we've already initialized this
-   variable. */
-static unsigned mtf_seq_num;
+    struct dictionary *dict;    /* Dictionary of output file. */
+    struct case_sink *sink;     /* Sink to receive output. */
+    struct ccase *mtf_case;     /* Case used for output. */
 
-/* Sequence numbers for each variable in mtf_master. */
-static unsigned *mtf_seq_nums;
+    unsigned seq_num;           /* Have we initialized this variable? */
+    unsigned *seq_nums;         /* Sequence numbers for each var in dict. */
+  };
 
-static void mtf_free (void);
-static void mtf_free_file (struct mtf_file *file);
-static int mtf_merge_dictionary (struct mtf_file *f);
-static void mtf_delete_file_in_place (struct mtf_file **file);
+static void mtf_free (struct mtf_proc *);
+static void mtf_free_file (struct mtf_file *);
+static int mtf_merge_dictionary (struct dictionary *const, struct mtf_file *);
+static void mtf_delete_file_in_place (struct mtf_proc *, struct mtf_file **);
 
 static void mtf_read_nonactive_records (void *);
 static void mtf_processing_finish (void *);
@@ -556,20 +578,20 @@ static char *var_type_description (struct variable *);
 int
 cmd_match_files (void)
 {
+  struct mtf_proc mtf;
   struct mtf_file *first_table = NULL;
   
   int seen = 0;
   
-  lex_match_id ("MATCH");
-  lex_match_id ("FILES");
-
-  mtf_head = mtf_tail = NULL;
-  mtf_by = NULL;
-  mtf_n_by = 0;
-  mtf_master = dict_create ();
-  mtf_seq_num = 0;
-  mtf_seq_nums = NULL;
-  dict_set_case_limit (mtf_master, dict_get_case_limit (default_dict));
+  mtf.head = mtf.tail = NULL;
+  mtf.by = NULL;
+  mtf.by_cnt = 0;
+  mtf.dict = dict_create ();
+  mtf.sink = NULL;
+  mtf.mtf_case = NULL;
+  mtf.seq_num = 0;
+  mtf.seq_nums = NULL;
+  dict_set_case_limit (mtf.dict, dict_get_case_limit (default_dict));
   
   do
     {
@@ -585,7 +607,7 @@ cmd_match_files (void)
 	  seen |= 1;
 	      
 	  lex_match ('=');
-	  if (!parse_variables (mtf_master, &mtf_by, &mtf_n_by,
+	  if (!parse_variables (mtf.dict, &mtf.by, &mtf.by_cnt,
 				PV_NO_DUPLICATE | PV_NO_SCRATCH))
 	    goto lossage;
 	}
@@ -617,12 +639,12 @@ cmd_match_files (void)
 	  if (file->type == MTF_TABLE || first_table == NULL)
 	    {
 	      file->next = NULL;
-	      file->prev = mtf_tail;
-	      if (mtf_tail)
-		mtf_tail->next = file;
-	      mtf_tail = file;
-	      if (mtf_head == NULL)
-		mtf_head = file;
+	      file->prev = mtf.tail;
+	      if (mtf.tail)
+		mtf.tail->next = file;
+	      mtf.tail = file;
+	      if (mtf.head == NULL)
+		mtf.head = file;
 	      if (file->type == MTF_TABLE && first_table == NULL)
 		first_table = file;
 	    }
@@ -634,7 +656,7 @@ cmd_match_files (void)
 	      if (first_table->prev)
 		first_table->prev->next = file;
 	      else
-		mtf_head = file;
+		mtf.head = file;
 	      first_table->prev = file;
 	    }
 	  
@@ -659,6 +681,15 @@ cmd_match_files (void)
 			     "file has been defined."));
 		  goto lossage;
 		}
+
+              if (temporary != 0)
+                {
+                  msg (SE,
+                       _("MATCH FILES may not be used after TEMPORARY when "
+                         "the active file is an input source.  "
+                         "Temporary transformations will be made permanent."));
+                  cancel_temporary (); 
+                }
 	    }
 	  else
 	    {
@@ -675,7 +706,7 @@ cmd_match_files (void)
 	    }
 	  else
 	    file->dict = default_dict;
-	  if (!mtf_merge_dictionary (file))
+	  if (!mtf_merge_dictionary (mtf.dict, file))
 	    goto lossage;
 	}
       else if (lex_id_match ("IN", tokid)
@@ -685,7 +716,7 @@ cmd_match_files (void)
 	  const char *sbc;
 	  char *name;
 	  
-	  if (mtf_tail == NULL)
+	  if (mtf.tail == NULL)
 	    {
 	      msg (SE, _("IN, FIRST, and LAST subcommands may not occur "
 			 "before the first FILE or TABLE."));
@@ -694,21 +725,24 @@ cmd_match_files (void)
 
 	  if (lex_match_id ("IN"))
 	    {
-	      name = mtf_tail->in;
+	      name = mtf.tail->in;
 	      sbc = "IN";
 	    }
 	  else if (lex_match_id ("FIRST"))
 	    {
-	      name = mtf_tail->first;
+	      name = mtf.tail->first;
 	      sbc = "FIRST";
 	    }
 	  else if (lex_match_id ("LAST"))
 	    {
-	      name = mtf_tail->last;
+	      name = mtf.tail->last;
 	      sbc = "LAST";
 	    }
-	  else
-	    assert (0);
+	  else 
+            {
+              assert (0);
+              abort ();
+            }
 
 	  lex_match ('=');
 	  if (token != T_ID)
@@ -727,7 +761,7 @@ cmd_match_files (void)
 	  strcpy (name, tokid);
 	  lex_get ();
 
-	  if (!dict_create_var (mtf_master, name, 0))
+	  if (!dict_create_var (mtf.dict, name, 0))
 	    {
 	      msg (SE, _("Duplicate variable name %s while creating %s "
 			 "variable."),
@@ -741,14 +775,14 @@ cmd_match_files (void)
 	{
 	  int options = GTSV_OPT_MATCH_FILES;
 	  
-	  if (mtf_tail == NULL)
+	  if (mtf.tail == NULL)
 	    {
 	      msg (SE, _("RENAME, KEEP, and DROP subcommands may not occur "
 			 "before the first FILE or TABLE."));
 	      goto lossage;
 	    }
 
-	  if (!trim_dictionary (mtf_tail->dict, &options))
+	  if (!trim_dictionary (mtf.tail->dict, &options))
 	    goto lossage;
 	}
       else if (lex_match_id ("MAP"))
@@ -777,20 +811,20 @@ cmd_match_files (void)
     {
       struct mtf_file *iter;
 
-      for (iter = mtf_head; iter; iter = iter->next)
+      for (iter = mtf.head; iter; iter = iter->next)
 	{
 	  int i;
 	  
-	  iter->by = xmalloc (sizeof *iter->by * mtf_n_by);
+	  iter->by = xmalloc (sizeof *iter->by * mtf.by_cnt);
 
-	  for (i = 0; i < mtf_n_by; i++)
+	  for (i = 0; i < mtf.by_cnt; i++)
 	    {
-	      iter->by[i] = dict_lookup_var (iter->dict, mtf_by[i]->name);
+	      iter->by[i] = dict_lookup_var (iter->dict, mtf.by[i]->name);
 	      if (iter->by[i] == NULL)
 		{
 		  msg (SE, _("File %s lacks BY variable %s."),
-		       iter->handle ? fh_handle_name (iter->handle) : "*",
-		       mtf_by[i]->name);
+		       iter->handle ? handle_get_name (iter->handle) : "*",
+		       mtf.by[i]->name);
 		  goto lossage;
 		}
 	    }
@@ -802,7 +836,7 @@ cmd_match_files (void)
     /* From sfm-read.c. */
     extern void dump_dictionary (struct dictionary *);
 
-    dump_dictionary (mtf_master);
+    dump_dictionary (mtf.dict);
   }
 #endif
 
@@ -839,53 +873,55 @@ cmd_match_files (void)
 
      FIXME: For merging large numbers of files (more than 10?) a
      better algorithm would use a heap for finding minimum
-     values, or replacement selection, as described by Knuth in
-     _Art of Computer Programming, Vol. 3_.  The SORT CASES
-     procedure does this, and perhaps some of its code could be
-     adapted. */
+     values. */
 
   if (!(seen & 2))
     discard_variables ();
 
-  temporary = 2;
-  temp_dict = mtf_master;
-  temp_trns = n_trns;
+  mtf.sink = create_case_sink (&storage_sink_class, mtf.dict, NULL);
+
+  mtf.seq_nums = xmalloc (dict_get_var_cnt (mtf.dict)
+                          * sizeof *mtf.seq_nums);
+  memset (mtf.seq_nums, 0,
+          dict_get_var_cnt (mtf.dict) * sizeof *mtf.seq_nums);
+  mtf.mtf_case = xmalloc (dict_get_case_size (mtf.dict));
 
-  mtf_seq_nums = xmalloc (dict_get_var_cnt (mtf_master)
-                          * sizeof *mtf_seq_nums);
-  memset (mtf_seq_nums, 0,
-          dict_get_var_cnt (mtf_master) * sizeof *mtf_seq_nums);
+  mtf_read_nonactive_records (NULL);
+  if (seen & 2)
+    procedure (mtf_processing, NULL);
+  mtf_processing_finish (NULL);
 
-  process_active_file (mtf_read_nonactive_records, mtf_processing,
-		       mtf_processing_finish, NULL);
-  mtf_master = NULL;
+  dict_destroy (default_dict);
+  default_dict = mtf.dict;
+  mtf.dict = NULL;
+  vfm_source = mtf.sink->class->make_source (mtf.sink);
+  free_case_sink (mtf.sink);
   
-  mtf_free ();
+  mtf_free (&mtf);
   return CMD_SUCCESS;
   
 lossage:
-  mtf_free ();
+  mtf_free (&mtf);
   return CMD_FAILURE;
 }
 
 /* Repeats 2...8 an arbitrary number of times. */
 static void
-mtf_processing_finish (void *aux UNUSED)
+mtf_processing_finish (void *mtf_)
 {
+  struct mtf_proc *mtf = mtf_;
+  struct mtf_file *iter;
+
   /* Find the active file and delete it. */
-  {
-    struct mtf_file *iter;
-    
-    for (iter = mtf_head; iter; iter = iter->next)
-      if (iter->handle == NULL)
-	{
-	  mtf_delete_file_in_place (&iter);
-	  break;
-	}
-  }
+  for (iter = mtf->head; iter; iter = iter->next)
+    if (iter->handle == NULL)
+      {
+        mtf_delete_file_in_place (mtf, &iter);
+        break;
+      }
   
-  while (mtf_head && mtf_head->type == MTF_FILE)
-    if (!mtf_processing (temp_case, NULL))
+  while (mtf->head && mtf->head->type == MTF_FILE)
+    if (!mtf_processing (NULL, mtf))
       break;
 }
 
@@ -926,27 +962,27 @@ mtf_free_file (struct mtf_file *file)
 
 /* Free all the data for the MATCH FILES procedure. */
 static void
-mtf_free (void)
+mtf_free (struct mtf_proc *mtf)
 {
   struct mtf_file *iter, *next;
 
-  for (iter = mtf_head; iter; iter = next)
+  for (iter = mtf->head; iter; iter = next)
     {
       next = iter->next;
 
       mtf_free_file (iter);
     }
   
-  free (mtf_by);
-  if (mtf_master)
-    dict_destroy (mtf_master);
-  free (mtf_seq_nums);
+  free (mtf->by);
+  if (mtf->dict)
+    dict_destroy (mtf->dict);
+  free (mtf->seq_nums);
 }
 
 /* Remove *FILE from the mtf_file chain.  Make *FILE point to the next
    file in the chain, or to NULL if was the last in the chain. */
 static void
-mtf_delete_file_in_place (struct mtf_file **file)
+mtf_delete_file_in_place (struct mtf_proc *mtf, struct mtf_file **file)
 {
   struct mtf_file *f = *file;
 
@@ -954,10 +990,10 @@ mtf_delete_file_in_place (struct mtf_file **file)
     f->prev->next = f->next;
   if (f->next)
     f->next->prev = f->prev;
-  if (f == mtf_head)
-    mtf_head = f->next;
-  if (f == mtf_tail)
-    mtf_tail = f->prev;
+  if (f == mtf->head)
+    mtf->head = f->next;
+  if (f == mtf->tail)
+    mtf->tail = f->prev;
   *file = f->next;
 
   {
@@ -968,23 +1004,23 @@ mtf_delete_file_in_place (struct mtf_file **file)
 	struct variable *v = dict_get_var (f->dict, i);
 	  
 	if (v->type == NUMERIC)
-	  compaction_case->data[v->p.mtf.master->fv].f = SYSMIS;
+	  mtf->mtf_case->data[v->p.mtf.master->fv].f = SYSMIS;
 	else
-	  memset (compaction_case->data[v->p.mtf.master->fv].s, ' ',
-		  v->width);
+	  memset (mtf->mtf_case->data[v->p.mtf.master->fv].s, ' ', v->width);
       }
   }
-  
+
   mtf_free_file (f);
 }
 
 /* Read a record from every input file except the active file. */
 static void
-mtf_read_nonactive_records (void *aux UNUSED)
+mtf_read_nonactive_records (void *mtf_ UNUSED)
 {
+  struct mtf_proc *mtf = mtf_;
   struct mtf_file *iter;
 
-  for (iter = mtf_head; iter; )
+  for (iter = mtf->head; iter; )
     {
       if (iter->handle)
 	{
@@ -992,34 +1028,37 @@ mtf_read_nonactive_records (void *aux UNUSED)
 	  iter->input = xmalloc (dict_get_case_size (iter->dict));
 	  
 	  if (!sfm_read_case (iter->handle, iter->input, iter->dict))
-	    mtf_delete_file_in_place (&iter);
+	    mtf_delete_file_in_place (mtf, &iter);
 	  else
 	    iter = iter->next;
 	}
       else
-	{
-	  iter->input = temp_case->data;
-	  iter = iter->next;
-	}
+        iter = iter->next;
     }
 }
 
 /* Compare the BY variables for files A and B; return -1 if A < B, 0
    if A == B, 1 if A > B. */
 static inline int
-mtf_compare_BY_values (struct mtf_file *a, struct mtf_file *b)
+mtf_compare_BY_values (struct mtf_proc *mtf,
+                       struct mtf_file *a, struct mtf_file *b,
+                       struct ccase *c)
 {
+  union value *a_input, *b_input;
   int i;
-  
-  for (i = 0; i < mtf_n_by; i++)
+
+  assert ((a == NULL) + (b == NULL) + (c == NULL) <= 1);
+  a_input = a->input != NULL ? a->input : c->data;
+  b_input = b->input != NULL ? b->input : c->data;
+  for (i = 0; i < mtf->by_cnt; i++)
     {
       assert (a->by[i]->type == b->by[i]->type);
       assert (a->by[i]->width == b->by[i]->width);
       
       if (a->by[i]->type == NUMERIC)
 	{
-	  double af = a->input[a->by[i]->fv].f;
-	  double bf = b->input[b->by[i]->fv].f;
+	  double af = a_input[a->by[i]->fv].f;
+	  double bf = b_input[b->by[i]->fv].f;
 
 	  if (af < bf)
 	    return -1;
@@ -1031,8 +1070,8 @@ mtf_compare_BY_values (struct mtf_file *a, struct mtf_file *b)
 	  int result;
 	  
 	  assert (a->by[i]->type == ALPHA);
-	  result = memcmp (a->input[a->by[i]->fv].s,
-			   b->input[b->by[i]->fv].s,
+	  result = memcmp (a_input[a->by[i]->fv].s,
+			   b_input[b->by[i]->fv].s,
 			   a->by[i]->width);
 	  if (result < 0)
 	    return -1;
@@ -1045,16 +1084,12 @@ mtf_compare_BY_values (struct mtf_file *a, struct mtf_file *b)
 
 /* Perform one iteration of steps 3...7 above. */
 static int
-mtf_processing (struct ccase *c UNUSED, void *aux UNUSED)
+mtf_processing (struct ccase *c, void *mtf_ UNUSED)
 {
-  /* List of files with minimum BY values. */
-  struct mtf_file *min_head, *min_tail;
-
-  /* List of files with non-minimum BY values. */
-  struct mtf_file *max_head, *max_tail;
-
-  /* Iterator. */
-  struct mtf_file *iter;
+  struct mtf_proc *mtf = mtf_;
+  struct mtf_file *min_head, *min_tail; /* Files with minimum BY values. */
+  struct mtf_file *max_head, *max_tail; /* Files with non-minimum BY values. */
+  struct mtf_file *iter;                /* Iterator. */
 
   for (;;)
     {
@@ -1062,7 +1097,7 @@ mtf_processing (struct ccase *c UNUSED, void *aux UNUSED)
 	 return because that would cause a record to be skipped. */
       int advance = 1;
 
-      if (mtf_head->type == MTF_TABLE)
+      if (mtf->head->type == MTF_TABLE)
 	return 0;
       
       /* 3. Find the FILE input record with minimum BY values.  Store
@@ -1071,11 +1106,11 @@ mtf_processing (struct ccase *c UNUSED, void *aux UNUSED)
 	 4. Find all the FILE input records with BY values identical
 	 to the minimums.  Store all the values from these input
 	 records into the output record. */
-      min_head = min_tail = mtf_head;
+      min_head = min_tail = mtf->head;
       max_head = max_tail = NULL;
-      for (iter = mtf_head->next; iter && iter->type == MTF_FILE;
+      for (iter = mtf->head->next; iter && iter->type == MTF_FILE;
 	   iter = iter->next)
-	switch (mtf_compare_BY_values (min_head, iter))
+	switch (mtf_compare_BY_values (mtf, min_head, iter, c))
 	  {
 	  case -1:
 	    if (max_head)
@@ -1120,7 +1155,7 @@ mtf_processing (struct ccase *c UNUSED, void *aux UNUSED)
 	    advance = 0;
 
 	again:
-	  switch (mtf_compare_BY_values (min_head, iter))
+	  switch (mtf_compare_BY_values (mtf, min_head, iter, c))
 	    {
 	    case -1:
 	      if (max_head)
@@ -1138,7 +1173,7 @@ mtf_processing (struct ccase *c UNUSED, void *aux UNUSED)
 		return 1;
 	      if (sfm_read_case (iter->handle, iter->input, iter->dict))
 		goto again;
-	      mtf_delete_file_in_place (&iter);
+	      mtf_delete_file_in_place (mtf, &iter);
 	      break;
 
 	    default:
@@ -1149,7 +1184,7 @@ mtf_processing (struct ccase *c UNUSED, void *aux UNUSED)
 	}
 
       /* Next sequence number. */
-      mtf_seq_num++;
+      mtf->seq_num++;
   
       /* Store data to all the records we are using. */
       if (min_tail)
@@ -1161,26 +1196,20 @@ mtf_processing (struct ccase *c UNUSED, void *aux UNUSED)
 	  for (i = 0; i < dict_get_var_cnt (iter->dict); i++)
 	    {
 	      struct variable *v = dict_get_var (iter->dict, i);
+              union value *record;
 	  
-	      if (mtf_seq_nums[v->p.mtf.master->index] == mtf_seq_num)
+	      if (mtf->seq_nums[v->p.mtf.master->index] == mtf->seq_num)
 		continue;
-              mtf_seq_nums[v->p.mtf.master->index] = mtf_seq_num;
+              mtf->seq_nums[v->p.mtf.master->index] = mtf->seq_num;
 
-#if 0
-	      printf ("%s/%s: dest-fv=%d, src-fv=%d\n",
-		      fh_handle_name (iter->handle),
-		      v->name,
-		      v->p.mtf.master->fv, v->fv);
-#endif
+              record = iter->input != NULL ? iter->input : c->data;
+
+              assert (v->type == NUMERIC || v->type == ALPHA);
 	      if (v->type == NUMERIC)
-		compaction_case->data[v->p.mtf.master->fv].f
-		  = iter->input[v->fv].f;
+		mtf->mtf_case->data[v->p.mtf.master->fv].f = record[v->fv].f;
 	      else
-		{
-		  assert (v->type == ALPHA);
-		  memcpy (compaction_case->data[v->p.mtf.master->fv].s,
-			  iter->input[v->fv].s, v->width);
-		}
+                memcpy (mtf->mtf_case->data[v->p.mtf.master->fv].s,
+                        record[v->fv].s, v->width);
 	    }
 	}
 
@@ -1195,9 +1224,9 @@ mtf_processing (struct ccase *c UNUSED, void *aux UNUSED)
 	    {
 	      struct variable *v = dict_get_var (iter->dict, i);
 	  
-	      if (mtf_seq_nums[v->p.mtf.master->index] == mtf_seq_num)
+	      if (mtf->seq_nums[v->p.mtf.master->index] == mtf->seq_num)
 		continue;
-              mtf_seq_nums[v->p.mtf.master->index] = mtf_seq_num;
+              mtf->seq_nums[v->p.mtf.master->index] = mtf->seq_num;
 
 #if 0
 	      printf ("%s/%s: dest-fv=%d\n",
@@ -1206,9 +1235,9 @@ mtf_processing (struct ccase *c UNUSED, void *aux UNUSED)
 		      v->p.mtf.master->fv);
 #endif
 	      if (v->type == NUMERIC)
-		compaction_case->data[v->p.mtf.master->fv].f = SYSMIS;
+		mtf->mtf_case->data[v->p.mtf.master->fv].f = SYSMIS;
 	      else
-                memset (compaction_case->data[v->p.mtf.master->fv].s, ' ',
+                memset (mtf->mtf_case->data[v->p.mtf.master->fv].s, ' ',
                         v->width);
 	    }
 
@@ -1217,7 +1246,7 @@ mtf_processing (struct ccase *c UNUSED, void *aux UNUSED)
 	}
 
       /* 6. Write the output record. */
-      process_active_file_output_case ();
+      mtf->sink->class->write (mtf->sink, mtf->mtf_case);
 
       /* 7. Read another record from each input file FILE and TABLE
 	 that we stored values from above.  If we come to the end of
@@ -1232,7 +1261,7 @@ mtf_processing (struct ccase *c UNUSED, void *aux UNUSED)
 	      assert (iter->input != NULL);
 
 	      if (!sfm_read_case (iter->handle, iter->input, iter->dict))
-		mtf_delete_file_in_place (&iter);
+		mtf_delete_file_in_place (mtf, &iter);
 	    }
 
 	  iter = next;
@@ -1242,15 +1271,14 @@ mtf_processing (struct ccase *c UNUSED, void *aux UNUSED)
 	break;
     }
 
-  return (mtf_head && mtf_head->type != MTF_TABLE);
+  return (mtf->head && mtf->head->type != MTF_TABLE);
 }
 
 /* Merge the dictionary for file F into the master dictionary
-   mtf_master. */
+   mtf_dict. */
 static int
-mtf_merge_dictionary (struct mtf_file *f)
+mtf_merge_dictionary (struct dictionary *const m, struct mtf_file *f)
 {
-  struct dictionary *const m = mtf_master;
   struct dictionary *d = f->dict;
   const char *d_docs, *m_docs;
 
@@ -1310,7 +1338,7 @@ mtf_merge_dictionary (struct mtf_file *f)
 	    msg (SE, _("Variable %s in file %s (%s) has different "
 		       "type or width from the same variable in "
 		       "earlier file (%s)."),
-		 dv->name, fh_handle_name (f->handle),
+		 dv->name, handle_get_name (f->handle),
 		 var_type_description (dv), var_type_description (mv));
 	    return 0;
 	  }
@@ -1329,11 +1357,10 @@ cmd_import (void)
 {
   struct file_handle *handle = NULL;
   struct dictionary *dict;
+  struct get_pgm *pgm;
   int options = GTSV_OPT_NONE;
   int type;
 
-  lex_match_id ("IMPORT");
-
   for (;;)
     {
       lex_match ('/');
@@ -1402,8 +1429,10 @@ cmd_import (void)
   dict_destroy (default_dict);
   default_dict = dict;
 
-  vfm_source = &import_source;
-  get_file = handle;
+  pgm = xmalloc (sizeof *pgm);
+  pgm->handle = handle;
+  pgm->case_size = dict_get_case_size (default_dict);
+  vfm_source = create_case_source (&import_source_class, default_dict, pgm);
 
   return CMD_SUCCESS;
 }
@@ -1411,23 +1440,23 @@ cmd_import (void)
 /* Reads all the cases from the data file and passes them to
    write_case(). */
 static void
-import_source_read (write_case_func *write_case, write_case_data wc_data)
+import_source_read (struct case_source *source,
+                    struct ccase *c,
+                    write_case_func *write_case, write_case_data wc_data)
 {
-  while (pfm_read_case (get_file, temp_case->data, default_dict)
-	 && write_case (wc_data))
-    ;
-  get_source_destroy_source ();
+  struct get_pgm *pgm = source->aux;
+  
+  while (pfm_read_case (pgm->handle, c->data, default_dict))
+    if (!write_case (wc_data))
+      break;
 }
 
-struct case_stream import_source =
+const struct case_source_class import_source_class =
   {
+    "IMPORT",
     NULL,
     import_source_read,
-    NULL,
-    NULL,
-    get_source_destroy_source,
-    NULL,
-    "IMPORT",
+    get_source_destroy,
   };
 
 static int export_write_case_func (struct ccase *c, void *);
@@ -1445,8 +1474,6 @@ cmd_export (void)
 
   int i;
 
-  lex_match_id ("EXPORT");
-
   lex_match ('/');
   if (lex_match_id ("OUTFILE"))
     lex_match ('=');
@@ -1480,7 +1507,7 @@ cmd_export (void)
     }
 
   /* Fill in transformation structure. */
-  t = trns = xmalloc (sizeof *t);
+  t = xmalloc (sizeof *t);
   t->h.proc = save_trns_proc;
   t->h.free = save_trns_free;
   t->f = handle;
@@ -1491,21 +1518,23 @@ cmd_export (void)
   t->case_buf = xmalloc (sizeof *t->case_buf * t->nvar);
   dict_destroy (dict);
 
-  procedure (NULL, export_write_case_func, NULL, NULL);
+  procedure (export_write_case_func, t);
   save_trns_free (&t->h);
 
   return CMD_SUCCESS;
 }
 
+/* Writes case C to the EXPORT file. */
 static int
-export_write_case_func (struct ccase *c, void *aux UNUSED)
+export_write_case_func (struct ccase *c, void *aux)
 {
-  union value *p = (union value *) trns->case_buf;
+  struct save_trns *t = aux;
+  union value *p = (union value *) t->case_buf;
   int i;
 
-  for (i = 0; i < trns->nvar; i++)
+  for (i = 0; i < t->nvar; i++)
     {
-      struct variable *v = trns->var[i];
+      struct variable *v = t->var[i];
 
       if (v->type == NUMERIC)
 	*p++ = c->data[v->fv];
@@ -1513,6 +1542,6 @@ export_write_case_func (struct ccase *c, void *aux UNUSED)
 	(*p++).c = c->data[v->fv].s;
     }
 
-  pfm_write_case (trns->f, (union value *) trns->case_buf);
+  pfm_write_case (t->f, (union value *) t->case_buf);
   return 1;
 }