src/language/data-io/save.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-writer.h>
  22 #include <data/case-map.h>
  23 #include <data/case.h>
  24 #include <data/casereader.h>
  25 #include <data/casewriter.h>
  26 #include <data/dictionary.h>
  27 #include <data/por-file-writer.h>
  28 #include <data/procedure.h>
  29 #include <data/sys-file-writer.h>
  30 #include <data/transformations.h>
  31 #include <data/variable.h>
  32 #include <language/command.h>
  33 #include <language/data-io/file-handle.h>
  34 #include <language/data-io/trim.h>
  35 #include <language/lexer/lexer.h>
  36 #include <libpspp/assertion.h>
  37 #include <libpspp/compiler.h>
  38
  39 #include "xalloc.h"
  40
  41 #include "gettext.h"
  42 #define _(msgid) gettext (msgid)
  43
  44 /* Writing system and portable files. */
  45
  46 /* Type of output file. */
  47 enum writer_type
  48   {
  49     SYSFILE_WRITER,     /* System file. */
  50     PORFILE_WRITER      /* Portable file. */
  51   };
  52
  53 /* Type of a command. */
  54 enum command_type
  55   {
  56     XFORM_CMD,          /* Transformation. */
  57     PROC_CMD            /* Procedure. */
  58   };
  59
  60 static int parse_output_proc (struct lexer *, struct dataset *,
  61                               enum writer_type);
  62 static int parse_output_trns (struct lexer *, struct dataset *,
  63                               enum writer_type);
  64
  65 int
  66 cmd_save (struct lexer *lexer, struct dataset *ds)
  67 {
  68   return parse_output_proc (lexer, ds, SYSFILE_WRITER);
  69 }
  70
  71 int
  72 cmd_export (struct lexer *lexer, struct dataset *ds)
  73 {
  74   return parse_output_proc (lexer, ds, PORFILE_WRITER);
  75 }
  76
  77 int
  78 cmd_xsave (struct lexer *lexer, struct dataset *ds)
  79 {
  80   return parse_output_trns (lexer, ds, SYSFILE_WRITER);
  81 }
  82
  83 int
  84 cmd_xexport (struct lexer *lexer, struct dataset *ds)
  85 {
  86   return parse_output_trns (lexer, ds, PORFILE_WRITER);
  87 }
  88 \f
  89 struct output_trns
  90   {
  91     struct casewriter *writer;          /* Writer. */
  92   };
  93
  94 static trns_proc_func output_trns_proc;
  95 static trns_free_func output_trns_free;
  96 static struct casewriter *parse_write_command (struct lexer *,
  97                                                struct dataset *,
  98                                                enum writer_type,
  99                                                enum command_type,
 100                                                bool *retain_unselected);
 101
 102 /* Parses and performs the SAVE or EXPORT procedure. */
 103 static int
 104 parse_output_proc (struct lexer *lexer, struct dataset *ds,
 105                    enum writer_type writer_type)
 106 {
 107   bool retain_unselected;
 108   struct variable *saved_filter_variable;
 109   struct casewriter *output;
 110   bool ok;
 111
 112   output = parse_write_command (lexer, ds, writer_type, PROC_CMD,
 113                                 &retain_unselected);
 114   if (output == NULL)
 115     return CMD_CASCADING_FAILURE;
 116
 117   saved_filter_variable = dict_get_filter (dataset_dict (ds));
 118   if (retain_unselected)
 119     dict_set_filter (dataset_dict (ds), NULL);
 120
 121   casereader_transfer (proc_open (ds), output);
 122   ok = casewriter_destroy (output);
 123   ok = proc_commit (ds) && ok;
 124
 125   dict_set_filter (dataset_dict (ds), saved_filter_variable);
 126
 127   return ok ? CMD_SUCCESS : CMD_CASCADING_FAILURE;
 128 }
 129
 130 /* Parses the XSAVE or XEXPORT transformation command. */
 131 static int
 132 parse_output_trns (struct lexer *lexer, struct dataset *ds, enum writer_type writer_type)
 133 {
 134   struct output_trns *t = xmalloc (sizeof *t);
 135   t->writer = parse_write_command (lexer, ds, writer_type, XFORM_CMD, NULL);
 136   if (t->writer == NULL)
 137     {
 138       free (t);
 139       return CMD_CASCADING_FAILURE;
 140     }
 141
 142   add_transformation (ds, output_trns_proc, output_trns_free, t);
 143   return CMD_SUCCESS;
 144 }
 145
 146 /* Parses SAVE or XSAVE or EXPORT or XEXPORT command.
 147    WRITER_TYPE identifies the type of file to write,
 148    and COMMAND_TYPE identifies the type of command.
 149
 150    On success, returns a writer.
 151    For procedures only, sets *RETAIN_UNSELECTED to true if cases
 152    that would otherwise be excluded by FILTER or USE should be
 153    included.
 154
 155    On failure, returns a null pointer. */
 156 static struct casewriter *
 157 parse_write_command (struct lexer *lexer, struct dataset *ds,
 158                      enum writer_type writer_type,
 159                      enum command_type command_type,
 160                      bool *retain_unselected)
 161 {
 162   /* Common data. */
 163   struct file_handle *handle; /* Output file. */
 164   struct dictionary *dict;    /* Dictionary for output file. */
 165   struct casewriter *writer;  /* Writer. */
 166   struct case_map *map;       /* Map from input data to data for writer. */
 167
 168   /* Common options. */
 169   bool print_map;             /* Print map?  TODO. */
 170   bool print_short_names;     /* Print long-to-short name map.  TODO. */
 171   struct sfm_write_options sysfile_opts;
 172   struct pfm_write_options porfile_opts;
 173
 174   assert (writer_type == SYSFILE_WRITER || writer_type == PORFILE_WRITER);
 175   assert (command_type == XFORM_CMD || command_type == PROC_CMD);
 176   assert ((retain_unselected != NULL) == (command_type == PROC_CMD));
 177
 178   if (command_type == PROC_CMD)
 179     *retain_unselected = true;
 180
 181   handle = NULL;
 182   dict = dict_clone (dataset_dict (ds));
 183   writer = NULL;
 184   map = NULL;
 185   print_map = false;
 186   print_short_names = false;
 187   sysfile_opts = sfm_writer_default_options ();
 188   porfile_opts = pfm_writer_default_options ();
 189
 190   case_map_prepare_dict (dict);
 191   dict_delete_scratch_vars (dict);
 192
 193   lex_match (lexer, '/');
 194   for (;;)
 195     {
 196       if (lex_match_id (lexer, "OUTFILE"))
 197         {
 198           if (handle != NULL)
 199             {
 200               lex_sbc_only_once ("OUTFILE");
 201               goto error;
 202             }
 203
 204           lex_match (lexer, '=');
 205
 206           handle = fh_parse (lexer, FH_REF_FILE | FH_REF_SCRATCH);
 207           if (handle == NULL)
 208             goto error;
 209         }
 210       else if (lex_match_id (lexer, "NAMES"))
 211         print_short_names = true;
 212       else if (lex_match_id (lexer, "PERMISSIONS"))
 213         {
 214           bool cw;
 215
 216           lex_match (lexer, '=');
 217           if (lex_match_id (lexer, "READONLY"))
 218             cw = false;
 219           else if (lex_match_id (lexer, "WRITEABLE"))
 220             cw = true;
 221           else
 222             {
 223               lex_error (lexer, _("expecting %s or %s"),
 224                          "READONLY", "WRITEABLE");
 225               goto error;
 226             }
 227           sysfile_opts.create_writeable = porfile_opts.create_writeable = cw;
 228         }
 229       else if (command_type == PROC_CMD && lex_match_id (lexer, "UNSELECTED"))
 230         {
 231           lex_match (lexer, '=');
 232           if (lex_match_id (lexer, "RETAIN"))
 233             *retain_unselected = true;
 234           else if (lex_match_id (lexer, "DELETE"))
 235             *retain_unselected = false;
 236           else
 237             {
 238               lex_error (lexer, _("expecting %s or %s"), "RETAIN", "DELETE");
 239               goto error;
 240             }
 241         }
 242       else if (writer_type == SYSFILE_WRITER
 243                && lex_match_id (lexer, "COMPRESSED"))
 244         sysfile_opts.compress = true;
 245       else if (writer_type == SYSFILE_WRITER
 246                && lex_match_id (lexer, "UNCOMPRESSED"))
 247         sysfile_opts.compress = false;
 248       else if (writer_type == SYSFILE_WRITER
 249                && lex_match_id (lexer, "VERSION"))
 250         {
 251           lex_match (lexer, '=');
 252           if (!lex_force_int (lexer))
 253             goto error;
 254           sysfile_opts.version = lex_integer (lexer);
 255           lex_get (lexer);
 256         }
 257       else if (writer_type == PORFILE_WRITER && lex_match_id (lexer, "TYPE"))
 258         {
 259           lex_match (lexer, '=');
 260           if (lex_match_id (lexer, "COMMUNICATIONS"))
 261             porfile_opts.type = PFM_COMM;
 262           else if (lex_match_id (lexer, "TAPE"))
 263             porfile_opts.type = PFM_TAPE;
 264           else
 265             {
 266               lex_error (lexer, _("expecting %s or %s"), "COMM", "TAPE");
 267               goto error;
 268             }
 269         }
 270       else if (writer_type == PORFILE_WRITER && lex_match_id (lexer, "DIGITS"))
 271         {
 272           lex_match (lexer, '=');
 273           if (!lex_force_int (lexer))
 274             goto error;
 275           porfile_opts.digits = lex_integer (lexer);
 276           lex_get (lexer);
 277         }
 278       else if (!parse_dict_trim (lexer, dict))
 279         goto error;
 280
 281       if (!lex_match (lexer, '/'))
 282         break;
 283     }
 284   if (lex_end_of_command (lexer) != CMD_SUCCESS)
 285     goto error;
 286
 287   if (handle == NULL)
 288     {
 289       lex_sbc_missing (lexer, "OUTFILE");
 290       goto error;
 291     }
 292
 293   dict_delete_scratch_vars (dict);
 294   dict_compact_values (dict);
 295
 296   if (fh_get_referent (handle) == FH_REF_FILE)
 297     {
 298       switch (writer_type)
 299         {
 300         case SYSFILE_WRITER:
 301           writer = sfm_open_writer (handle, dict, sysfile_opts);
 302           break;
 303         case PORFILE_WRITER:
 304           writer = pfm_open_writer (handle, dict, porfile_opts);
 305           break;
 306         }
 307     }
 308   else
 309     writer = any_writer_open (handle, dict);
 310   if (writer == NULL)
 311     goto error;
 312
 313   map = case_map_from_dict (dict);
 314   if (map != NULL)
 315     writer = case_map_create_output_translator (map, writer);
 316   dict_destroy (dict);
 317
 318   fh_unref (handle);
 319   return writer;
 320
 321  error:
 322   fh_unref (handle);
 323   casewriter_destroy (writer);
 324   dict_destroy (dict);
 325   case_map_destroy (map);
 326   return NULL;
 327 }
 328
 329 /* Writes case *C to the system file specified on XSAVE or XEXPORT. */
 330 static int
 331 output_trns_proc (void *trns_, struct ccase **c, casenumber case_num UNUSED)
 332 {
 333   struct output_trns *t = trns_;
 334   casewriter_write (t->writer, case_ref (*c));
 335   return TRNS_CONTINUE;
 336 }
 337
 338 /* Frees an XSAVE or XEXPORT transformation.
 339    Returns true if successful, false if an I/O error occurred. */
 340 static bool
 341 output_trns_free (void *trns_)
 342 {
 343   struct output_trns *t = trns_;
 344   bool ok = casewriter_destroy (t->writer);
 345   free (t);
 346   return ok;
 347 }