pintos-os.org Git - pspp/blob - src/language/data-io/get-data.c

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