src/language/data-io/get-data.c

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 2007, 2008, 2009, 2010, 2011 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/dictionary.h"
  22 #include "data/format.h"
  23 #include "data/gnumeric-reader.h"
  24 #include "data/procedure.h"
  25 #include "data/psql-reader.h"
  26 #include "data/settings.h"
  27 #include "language/command.h"
  28 #include "language/data-io/data-parser.h"
  29 #include "language/data-io/data-reader.h"
  30 #include "language/data-io/file-handle.h"
  31 #include "language/data-io/placement-parser.h"
  32 #include "language/lexer/format-parser.h"
  33 #include "language/lexer/lexer.h"
  34 #include "libpspp/message.h"
  35
  36 #include "gl/xalloc.h"
  37
  38 #include "gettext.h"
  39 #define _(msgid) gettext (msgid)
  40 #define N_(msgid) (msgid)
  41
  42 static int parse_get_gnm (struct lexer *lexer, struct dataset *);
  43 static int parse_get_txt (struct lexer *lexer, struct dataset *);
  44 static int parse_get_psql (struct lexer *lexer, struct dataset *);
  45
  46 int
  47 cmd_get_data (struct lexer *lexer, struct dataset *ds)
  48 {
  49   lex_force_match (lexer, T_SLASH);
  50
  51   if (!lex_force_match_id (lexer, "TYPE"))
  52     return CMD_FAILURE;
  53
  54   lex_force_match (lexer, T_EQUALS);
  55
  56   if (lex_match_id (lexer, "GNM"))
  57     return parse_get_gnm (lexer, ds);
  58   else if (lex_match_id (lexer, "TXT"))
  59     return parse_get_txt (lexer, ds);
  60   else if (lex_match_id (lexer, "PSQL"))
  61     return parse_get_psql (lexer, ds);
  62
  63   msg (SE, _("Unsupported TYPE %s."), lex_tokcstr (lexer));
  64   return CMD_FAILURE;
  65 }
  66
  67 static int
  68 parse_get_psql (struct lexer *lexer, struct dataset *ds)
  69 {
  70   struct psql_read_info psql;
  71   psql.allow_clear = false;
  72   psql.conninfo = NULL;
  73   psql.str_width = -1;
  74   psql.bsize = -1;
  75   ds_init_empty (&psql.sql);
  76
  77   lex_force_match (lexer, T_SLASH);
  78
  79   if (!lex_force_match_id (lexer, "CONNECT"))
  80     goto error;
  81
  82   lex_force_match (lexer, T_EQUALS);
  83
  84   if (!lex_force_string (lexer))
  85     goto error;
  86
  87   psql.conninfo = ss_xstrdup (lex_tokss (lexer));
  88
  89   lex_get (lexer);
  90
  91   while (lex_match (lexer, T_SLASH) )
  92     {
  93       if ( lex_match_id (lexer, "ASSUMEDSTRWIDTH"))
  94         {
  95           lex_match (lexer, T_EQUALS);
  96           psql.str_width = lex_integer (lexer);
  97           lex_get (lexer);
  98         }
  99       else if ( lex_match_id (lexer, "BSIZE"))
 100         {
 101           lex_match (lexer, T_EQUALS);
 102           psql.bsize = lex_integer (lexer);
 103           lex_get (lexer);
 104         }
 105       else if ( lex_match_id (lexer, "UNENCRYPTED"))
 106         {
 107           psql.allow_clear = true;
 108         }
 109       else if (lex_match_id (lexer, "SQL"))
 110         {
 111           lex_match (lexer, T_EQUALS);
 112           if ( ! lex_force_string (lexer) )
 113             goto error;
 114
 115           ds_put_substring (&psql.sql, lex_tokss (lexer));
 116           lex_get (lexer);
 117         }
 118      }
 119   {
 120     struct dictionary *dict = NULL;
 121     struct casereader *reader = psql_open_reader (&psql, &dict);
 122
 123     if ( reader )
 124       proc_set_active_file (ds, reader, dict);
 125   }
 126
 127   ds_destroy (&psql.sql);
 128   free (psql.conninfo);
 129
 130   return CMD_SUCCESS;
 131
 132  error:
 133
 134   ds_destroy (&psql.sql);
 135   free (psql.conninfo);
 136
 137   return CMD_FAILURE;
 138 }
 139
 140 static int
 141 parse_get_gnm (struct lexer *lexer, struct dataset *ds)
 142 {
 143   struct gnumeric_read_info gri  = {NULL, NULL, NULL, 1, true, -1};
 144
 145   lex_force_match (lexer, T_SLASH);
 146
 147   if (!lex_force_match_id (lexer, "FILE"))
 148     goto error;
 149
 150   lex_force_match (lexer, T_EQUALS);
 151
 152   if (!lex_force_string (lexer))
 153     goto error;
 154
 155   gri.file_name = ss_xstrdup (lex_tokss (lexer));
 156
 157   lex_get (lexer);
 158
 159   while (lex_match (lexer, T_SLASH) )
 160     {
 161       if ( lex_match_id (lexer, "ASSUMEDSTRWIDTH"))
 162         {
 163           lex_match (lexer, T_EQUALS);
 164           gri.asw = lex_integer (lexer);
 165           lex_get (lexer);
 166         }
 167       else if (lex_match_id (lexer, "SHEET"))
 168         {
 169           lex_match (lexer, T_EQUALS);
 170           if (lex_match_id (lexer, "NAME"))
 171             {
 172               if ( ! lex_force_string (lexer) )
 173                 goto error;
 174
 175               gri.sheet_name = ss_xstrdup (lex_tokss (lexer));
 176               gri.sheet_index = -1;
 177
 178               lex_get (lexer);
 179             }
 180           else if (lex_match_id (lexer, "INDEX"))
 181             {
 182               gri.sheet_index = lex_integer (lexer);
 183               lex_get (lexer);
 184             }
 185           else
 186             goto error;
 187         }
 188       else if (lex_match_id (lexer, "CELLRANGE"))
 189         {
 190           lex_match (lexer, T_EQUALS);
 191
 192           if (lex_match_id (lexer, "FULL"))
 193             {
 194               gri.cell_range = NULL;
 195             }
 196           else if (lex_match_id (lexer, "RANGE"))
 197             {
 198               if ( ! lex_force_string (lexer) )
 199                 goto error;
 200
 201               gri.cell_range = ss_xstrdup (lex_tokss (lexer));
 202               lex_get (lexer);
 203             }
 204           else
 205             goto error;
 206         }
 207       else if (lex_match_id (lexer, "READNAMES"))
 208         {
 209           lex_match (lexer, T_EQUALS);
 210
 211           if ( lex_match_id (lexer, "ON"))
 212             {
 213               gri.read_names = true;
 214             }
 215           else if (lex_match_id (lexer, "OFF"))
 216             {
 217               gri.read_names = false;
 218             }
 219           else
 220             goto error;
 221         }
 222       else
 223         {
 224           lex_error (lexer, NULL);
 225           goto error;
 226         }
 227     }
 228
 229   {
 230     struct dictionary *dict = NULL;
 231     struct casereader *reader = gnumeric_open_reader (&gri, &dict);
 232
 233     if ( reader )
 234       proc_set_active_file (ds, reader, dict);
 235   }
 236
 237   free (gri.file_name);
 238   free (gri.sheet_name);
 239   free (gri.cell_range);
 240   return CMD_SUCCESS;
 241
 242  error:
 243
 244   free (gri.file_name);
 245   free (gri.sheet_name);
 246   free (gri.cell_range);
 247   return CMD_FAILURE;
 248 }
 249
 250 static bool
 251 set_type (struct data_parser *parser, const char *subcommand,
 252           enum data_parser_type type, bool *has_type)
 253 {
 254   if (!*has_type)
 255     {
 256       data_parser_set_type (parser, type);
 257       *has_type = true;
 258     }
 259   else if (type != data_parser_get_type (parser))
 260     {
 261       msg (SE, _("%s is allowed only with %s arrangement, but %s arrangement "
 262                  "was stated or implied earlier in this command."),
 263            subcommand,
 264            type == DP_FIXED ? "FIXED" : "DELIMITED",
 265            type == DP_FIXED ? "DELIMITED" : "FIXED");
 266       return false;
 267     }
 268   return true;
 269 }
 270
 271 static int
 272 parse_get_txt (struct lexer *lexer, struct dataset *ds)
 273 {
 274   struct data_parser *parser = NULL;
 275   struct dictionary *dict = dict_create ();
 276   struct file_handle *fh = NULL;
 277   struct dfm_reader *reader = NULL;
 278   char *name = NULL;
 279
 280   int record;
 281   enum data_parser_type type;
 282   bool has_type;
 283
 284   lex_force_match (lexer, T_SLASH);
 285
 286   if (!lex_force_match_id (lexer, "FILE"))
 287     goto error;
 288   lex_force_match (lexer, T_EQUALS);
 289   fh = fh_parse (lexer, FH_REF_FILE | FH_REF_INLINE);
 290   if (fh == NULL)
 291     goto error;
 292
 293   parser = data_parser_create (dict);
 294   has_type = false;
 295   data_parser_set_type (parser, DP_DELIMITED);
 296   data_parser_set_span (parser, false);
 297   data_parser_set_quotes (parser, ss_empty ());
 298   data_parser_set_empty_line_has_field (parser, true);
 299
 300   for (;;)
 301     {
 302       if (!lex_force_match (lexer, T_SLASH))
 303         goto error;
 304
 305       if (lex_match_id (lexer, "ARRANGEMENT"))
 306         {
 307           bool ok;
 308
 309           lex_match (lexer, T_EQUALS);
 310           if (lex_match_id (lexer, "FIXED"))
 311             ok = set_type (parser, "ARRANGEMENT=FIXED", DP_FIXED, &has_type);
 312           else if (lex_match_id (lexer, "DELIMITED"))
 313             ok = set_type (parser, "ARRANGEMENT=DELIMITED",
 314                            DP_DELIMITED, &has_type);
 315           else
 316             {
 317               lex_error (lexer, _("expecting %s or %s"), "FIXED", "DELIMITED");
 318               goto error;
 319             }
 320           if (!ok)
 321             goto error;
 322         }
 323       else if (lex_match_id (lexer, "FIRSTCASE"))
 324         {
 325           lex_match (lexer, T_EQUALS);
 326           if (!lex_force_int (lexer))
 327             goto error;
 328           if (lex_integer (lexer) < 1)
 329             {
 330               msg (SE, _("Value of FIRSTCASE must be 1 or greater."));
 331               goto error;
 332             }
 333           data_parser_set_skip (parser, lex_integer (lexer) - 1);
 334           lex_get (lexer);
 335         }
 336       else if (lex_match_id_n (lexer, "DELCASE", 4))
 337         {
 338           if (!set_type (parser, "DELCASE", DP_DELIMITED, &has_type))
 339             goto error;
 340           lex_match (lexer, T_EQUALS);
 341           if (lex_match_id (lexer, "LINE"))
 342             data_parser_set_span (parser, false);
 343           else if (lex_match_id (lexer, "VARIABLES"))
 344             {
 345               data_parser_set_span (parser, true);
 346
 347               /* VARIABLES takes an integer argument, but for no
 348                  good reason.  We just ignore it. */
 349               if (!lex_force_int (lexer))
 350                 goto error;
 351               lex_get (lexer);
 352             }
 353           else
 354             {
 355               lex_error (lexer, _("expecting %s or %s"), "LINE", "VARIABLES");
 356               goto error;
 357             }
 358         }
 359       else if (lex_match_id (lexer, "FIXCASE"))
 360         {
 361           if (!set_type (parser, "FIXCASE", DP_FIXED, &has_type))
 362             goto error;
 363           lex_match (lexer, T_EQUALS);
 364           if (!lex_force_int (lexer))
 365             goto error;
 366           if (lex_integer (lexer) < 1)
 367             {
 368               msg (SE, _("Value of FIXCASE must be at least 1."));
 369               goto error;
 370             }
 371           data_parser_set_records (parser, lex_integer (lexer));
 372           lex_get (lexer);
 373         }
 374       else if (lex_match_id (lexer, "IMPORTCASES"))
 375         {
 376           lex_match (lexer, T_EQUALS);
 377           if (lex_match (lexer, T_ALL))
 378             {
 379               data_parser_set_case_limit (parser, -1);
 380               data_parser_set_case_percent (parser, 100);
 381             }
 382           else if (lex_match_id (lexer, "FIRST"))
 383             {
 384               if (!lex_force_int (lexer))
 385                 goto error;
 386               if (lex_integer (lexer) < 1)
 387                 {
 388                   msg (SE, _("Value of FIRST must be at least 1."));
 389                   goto error;
 390                 }
 391               data_parser_set_case_limit (parser, lex_integer (lexer));
 392               lex_get (lexer);
 393             }
 394           else if (lex_match_id (lexer, "PERCENT"))
 395             {
 396               if (!lex_force_int (lexer))
 397                 goto error;
 398               if (lex_integer (lexer) < 1 || lex_integer (lexer) > 100)
 399                 {
 400                   msg (SE, _("Value of PERCENT must be between 1 and 100."));
 401                   goto error;
 402                 }
 403               data_parser_set_case_percent (parser, lex_integer (lexer));
 404               lex_get (lexer);
 405             }
 406         }
 407       else if (lex_match_id_n (lexer, "DELIMITERS", 4))
 408         {
 409           struct string hard_seps = DS_EMPTY_INITIALIZER;
 410           const char *soft_seps = "";
 411           struct substring s;
 412           int c;
 413
 414           if (!set_type (parser, "DELIMITERS", DP_DELIMITED, &has_type))
 415             goto error;
 416           lex_match (lexer, T_EQUALS);
 417
 418           if (!lex_force_string (lexer))
 419             goto error;
 420
 421           s = lex_tokss (lexer);
 422           if (ss_match_string (&s, ss_cstr ("\\t")))
 423             ds_put_cstr (&hard_seps, "\t");
 424           if (ss_match_string (&s, ss_cstr ("\\\\")))
 425             ds_put_cstr (&hard_seps, "\\");
 426           while ((c = ss_get_byte (&s)) != EOF)
 427             if (c == ' ')
 428               soft_seps = " ";
 429             else
 430               ds_put_byte (&hard_seps, c);
 431           data_parser_set_soft_delimiters (parser, ss_cstr (soft_seps));
 432           data_parser_set_hard_delimiters (parser, ds_ss (&hard_seps));
 433           ds_destroy (&hard_seps);
 434
 435           lex_get (lexer);
 436         }
 437       else if (lex_match_id (lexer, "QUALIFIERS"))
 438         {
 439           if (!set_type (parser, "QUALIFIERS", DP_DELIMITED, &has_type))
 440             goto error;
 441           lex_match (lexer, T_EQUALS);
 442
 443           if (!lex_force_string (lexer))
 444             goto error;
 445
 446           if (settings_get_syntax () == COMPATIBLE
 447               && ss_length (lex_tokss (lexer)) != 1)
 448             {
 449               msg (SE, _("In compatible syntax mode, the QUALIFIER string "
 450                          "must contain exactly one character."));
 451               goto error;
 452             }
 453
 454           data_parser_set_quotes (parser, lex_tokss (lexer));
 455           lex_get (lexer);
 456         }
 457       else if (settings_get_syntax () == ENHANCED
 458                && lex_match_id (lexer, "ESCAPE"))
 459         data_parser_set_quote_escape (parser, true);
 460       else if (lex_match_id (lexer, "VARIABLES"))
 461         break;
 462       else
 463         {
 464           lex_error (lexer, _("expecting %s"), "VARIABLES");
 465           goto error;
 466         }
 467     }
 468   lex_match (lexer, T_EQUALS);
 469
 470   record = 1;
 471   type = data_parser_get_type (parser);
 472   do
 473     {
 474       struct fmt_spec input, output;
 475       struct variable *v;
 476       int fc, lc;
 477
 478       while (type == DP_FIXED && lex_match (lexer, T_SLASH))
 479         {
 480           if (!lex_force_int (lexer))
 481             goto error;
 482           if (lex_integer (lexer) < record)
 483             {
 484               msg (SE, _("The record number specified, %ld, is at or "
 485                          "before the previous record, %d.  Data "
 486                          "fields must be listed in order of "
 487                          "increasing record number."),
 488                    lex_integer (lexer), record);
 489               goto error;
 490             }
 491           if (lex_integer (lexer) > data_parser_get_records (parser))
 492             {
 493               msg (SE, _("The record number specified, %ld, exceeds "
 494                          "the number of records per case specified "
 495                          "on FIXCASE, %d."),
 496                    lex_integer (lexer), data_parser_get_records (parser));
 497               goto error;
 498             }
 499           record = lex_integer (lexer);
 500           lex_get (lexer);
 501         }
 502
 503       if (!lex_force_id (lexer))
 504         goto error;
 505       name = xstrdup (lex_tokcstr (lexer));
 506       lex_get (lexer);
 507
 508       if (type == DP_DELIMITED)
 509         {
 510           if (!parse_format_specifier (lexer, &input)
 511               || !fmt_check_input (&input))
 512             goto error;
 513         }
 514       else
 515         {
 516           if (!parse_column_range (lexer, 0, &fc, &lc, NULL))
 517             goto error;
 518           if (!parse_format_specifier_name (lexer, &input.type))
 519             goto error;
 520           input.w = lc - fc + 1;
 521           input.d = 0;
 522           if (!fmt_check_input (&input))
 523             goto error;
 524         }
 525       output = fmt_for_output_from_input (&input);
 526
 527       v = dict_create_var (dict, name, fmt_var_width (&input));
 528       if (v == NULL)
 529         {
 530           msg (SE, _("%s is a duplicate variable name."), name);
 531           goto error;
 532         }
 533       var_set_both_formats (v, &output);
 534
 535       if (type == DP_DELIMITED)
 536         data_parser_add_delimited_field (parser, &input,
 537                                          var_get_case_index (v),
 538                                          name);
 539       else
 540         data_parser_add_fixed_field (parser, &input, var_get_case_index (v),
 541                                      name, record, fc);
 542       free (name);
 543       name = NULL;
 544     }
 545   while (lex_token (lexer) != T_ENDCMD);
 546
 547   reader = dfm_open_reader (fh, lexer);
 548   if (reader == NULL)
 549     goto error;
 550
 551   data_parser_make_active_file (parser, ds, reader, dict);
 552   fh_unref (fh);
 553   return CMD_SUCCESS;
 554
 555  error:
 556   data_parser_destroy (parser);
 557   dict_destroy (dict);
 558   fh_unref (fh);
 559   free (name);
 560   return CMD_CASCADING_FAILURE;
 561 }