Avoid crash when importing non-existant spreadsheet file
[pspp] / src / language / data-io / get-data.c
1 /* PSPP - a program for statistical analysis.
2    Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012,
3                  2013 Free Software Foundation, Inc.
4
5    This program is free software: you can redistribute it and/or modify
6    it under the terms of the GNU General Public License as published by
7    the Free Software Foundation, either version 3 of the License, or
8    (at your option) any later version.
9
10    This program is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13    GNU 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, see <http://www.gnu.org/licenses/>. */
17
18 #include <config.h>
19
20 #include <stdlib.h>
21
22 #include <string.h>
23
24 #include "data/dataset.h"
25 #include "data/dictionary.h"
26 #include "data/format.h"
27 #include "data/gnumeric-reader.h"
28 #include "data/ods-reader.h"
29 #include "data/spreadsheet-reader.h"
30 #include "data/psql-reader.h"
31 #include "data/settings.h"
32 #include "language/command.h"
33 #include "language/data-io/data-parser.h"
34 #include "language/data-io/data-reader.h"
35 #include "language/data-io/file-handle.h"
36 #include "language/data-io/placement-parser.h"
37 #include "language/lexer/format-parser.h"
38 #include "language/lexer/lexer.h"
39 #include "libpspp/cast.h"
40 #include "libpspp/i18n.h"
41 #include "libpspp/message.h"
42
43 #include "gl/xalloc.h"
44
45 #include "gettext.h"
46 #define _(msgid) gettext (msgid)
47 #define N_(msgid) (msgid)
48
49 static bool parse_spreadsheet (struct lexer *lexer, char **filename,
50                                struct spreadsheet_read_options *opts);
51
52 static void destroy_spreadsheet_read_info (struct spreadsheet_read_info *, struct spreadsheet_read_options *);
53
54 static int parse_get_txt (struct lexer *lexer, struct dataset *);
55 static int parse_get_psql (struct lexer *lexer, struct dataset *);
56
57 int
58 cmd_get_data (struct lexer *lexer, struct dataset *ds)
59 {
60   char *tok = NULL;
61   lex_force_match (lexer, T_SLASH);
62
63   if (!lex_force_match_id (lexer, "TYPE"))
64     return CMD_FAILURE;
65
66   lex_force_match (lexer, T_EQUALS);
67
68   tok = strdup (lex_tokcstr (lexer));
69   if (lex_match_id (lexer, "TXT"))
70     {
71       free (tok);
72       return parse_get_txt (lexer, ds);
73     }
74   else if (lex_match_id (lexer, "PSQL"))
75     {
76       free (tok);
77       return parse_get_psql (lexer, ds);
78     }
79   else if (lex_match_id (lexer, "GNM") || 
80       lex_match_id (lexer, "ODS"))
81     {
82       char *filename = NULL;
83       struct casereader *reader = NULL;
84       struct dictionary *dict = NULL;
85       struct spreadsheet_read_options opts;
86       if (!parse_spreadsheet (lexer, &filename, &opts))
87         goto error;
88
89       if ( 0 == strncasecmp (tok, "GNM", 3))
90         {
91           struct spreadsheet *spreadsheet = gnumeric_probe (filename, true);
92           if (spreadsheet == NULL)
93             goto error;
94           reader = gnumeric_make_reader (spreadsheet, &opts);
95           dict = spreadsheet->dict;
96         }
97       else if (0 == strncasecmp (tok, "ODS", 3))
98         {
99           struct spreadsheet *spreadsheet = ods_probe (filename, true);
100           if (spreadsheet == NULL)
101             goto error;
102           reader = ods_make_reader (spreadsheet, &opts);
103           dict = spreadsheet->dict;
104         }
105
106       if (reader)
107         {
108           dataset_set_dict (ds, dict);
109           dataset_set_source (ds, reader);
110           free (tok);
111           return CMD_SUCCESS;
112         }
113     }
114   else
115     msg (SE, _("Unsupported TYPE %s."), tok);
116
117  error:
118   free (tok);
119   return CMD_FAILURE;
120 }
121
122 static int
123 parse_get_psql (struct lexer *lexer, struct dataset *ds)
124 {
125   struct psql_read_info psql;
126   psql.allow_clear = false;
127   psql.conninfo = NULL;
128   psql.str_width = -1;
129   psql.bsize = -1;
130   ds_init_empty (&psql.sql);
131
132   lex_force_match (lexer, T_SLASH);
133
134   if (!lex_force_match_id (lexer, "CONNECT"))
135     goto error;
136
137   lex_force_match (lexer, T_EQUALS);
138
139   if (!lex_force_string (lexer))
140     goto error;
141
142   psql.conninfo = ss_xstrdup (lex_tokss (lexer));
143
144   lex_get (lexer);
145
146   while (lex_match (lexer, T_SLASH) )
147     {
148       if ( lex_match_id (lexer, "ASSUMEDSTRWIDTH"))
149         {
150           lex_match (lexer, T_EQUALS);
151           psql.str_width = lex_integer (lexer);
152           lex_get (lexer);
153         }
154       else if ( lex_match_id (lexer, "BSIZE"))
155         {
156           lex_match (lexer, T_EQUALS);
157           psql.bsize = lex_integer (lexer);
158           lex_get (lexer);
159         }
160       else if ( lex_match_id (lexer, "UNENCRYPTED"))
161         {
162           psql.allow_clear = true;
163         }
164       else if (lex_match_id (lexer, "SQL"))
165         {
166           lex_match (lexer, T_EQUALS);
167           if ( ! lex_force_string (lexer) )
168             goto error;
169
170           ds_put_substring (&psql.sql, lex_tokss (lexer));
171           lex_get (lexer);
172         }
173      }
174   {
175     struct dictionary *dict = NULL;
176     struct casereader *reader = psql_open_reader (&psql, &dict);
177
178     if ( reader )
179       {
180         dataset_set_dict (ds, dict);
181         dataset_set_source (ds, reader);
182       }
183   }
184
185   ds_destroy (&psql.sql);
186   free (psql.conninfo);
187
188   return CMD_SUCCESS;
189
190  error:
191
192   ds_destroy (&psql.sql);
193   free (psql.conninfo);
194
195   return CMD_FAILURE;
196 }
197
198 static bool
199 parse_spreadsheet (struct lexer *lexer, char **filename, 
200                    struct spreadsheet_read_options *opts)
201 {
202   opts->sheet_index = 1;
203   opts->sheet_name = NULL;
204   opts->cell_range = NULL;
205   opts->read_names = true;
206   opts->asw = -1;
207
208   lex_force_match (lexer, T_SLASH);
209
210   if (!lex_force_match_id (lexer, "FILE"))
211     goto error;
212
213   lex_force_match (lexer, T_EQUALS);
214
215   if (!lex_force_string (lexer))
216     goto error;
217
218   *filename  = utf8_to_filename (lex_tokcstr (lexer));
219
220   lex_get (lexer);
221
222   while (lex_match (lexer, T_SLASH) )
223     {
224       if ( lex_match_id (lexer, "ASSUMEDSTRWIDTH"))
225         {
226           lex_match (lexer, T_EQUALS);
227           opts->asw = lex_integer (lexer);
228           lex_get (lexer);
229         }
230       else if (lex_match_id (lexer, "SHEET"))
231         {
232           lex_match (lexer, T_EQUALS);
233           if (lex_match_id (lexer, "NAME"))
234             {
235               if ( ! lex_force_string (lexer) )
236                 goto error;
237
238               opts->sheet_name = ss_xstrdup (lex_tokss (lexer));
239               opts->sheet_index = -1;
240
241               lex_get (lexer);
242             }
243           else if (lex_match_id (lexer, "INDEX"))
244             {
245               opts->sheet_index = lex_integer (lexer);
246               if (opts->sheet_index <= 0)
247                 {
248                   msg (SE, _("The sheet index must be greater than or equal to 1"));
249                   goto error;
250                 }
251               lex_get (lexer);
252             }
253           else
254             {
255               msg (SE, _("%s must be followed by either \"%s\" or \"%s\"."),
256                    "/SHEET", "NAME", "INDEX");
257               goto error;
258             }
259         }
260       else if (lex_match_id (lexer, "CELLRANGE"))
261         {
262           lex_match (lexer, T_EQUALS);
263
264           if (lex_match_id (lexer, "FULL"))
265             {
266               opts->cell_range = NULL;
267             }
268           else if (lex_match_id (lexer, "RANGE"))
269             {
270               if ( ! lex_force_string (lexer) )
271                 goto error;
272
273               opts->cell_range = ss_xstrdup (lex_tokss (lexer));
274               lex_get (lexer);
275             }
276           else
277             {
278               msg (SE, _("%s must be followed by either \"%s\" or \"%s\"."),
279                    "/CELLRANGE", "FULL", "RANGE");
280               goto error;
281             }
282         }
283       else if (lex_match_id (lexer, "READNAMES"))
284         {
285           lex_match (lexer, T_EQUALS);
286
287           if ( lex_match_id (lexer, "ON"))
288             {
289               opts->read_names = true;
290             }
291           else if (lex_match_id (lexer, "OFF"))
292             {
293               opts->read_names = false;
294             }
295           else
296             {
297               msg (SE, _("%s must be followed by either \"%s\" or \"%s\"."),
298                    "/READNAMES", "ON", "OFF");
299               goto error;
300             }
301         }
302       else
303         {
304           lex_error (lexer, NULL);
305           goto error;
306         }
307     }
308
309   return true;
310
311  error:
312   return false;
313 }
314
315
316 static bool
317 set_type (struct data_parser *parser, const char *subcommand,
318           enum data_parser_type type, bool *has_type)
319 {
320   if (!*has_type)
321     {
322       data_parser_set_type (parser, type);
323       *has_type = true;
324     }
325   else if (type != data_parser_get_type (parser))
326     {
327       msg (SE, _("%s is allowed only with %s arrangement, but %s arrangement "
328                  "was stated or implied earlier in this command."),
329            subcommand,
330            type == DP_FIXED ? "FIXED" : "DELIMITED",
331            type == DP_FIXED ? "DELIMITED" : "FIXED");
332       return false;
333     }
334   return true;
335 }
336
337 static int
338 parse_get_txt (struct lexer *lexer, struct dataset *ds)
339 {
340   struct data_parser *parser = NULL;
341   struct dictionary *dict = dict_create (get_default_encoding ());
342   struct file_handle *fh = NULL;
343   struct dfm_reader *reader = NULL;
344   char *encoding = NULL;
345   char *name = NULL;
346
347   int record;
348   enum data_parser_type type;
349   bool has_type;
350
351   lex_force_match (lexer, T_SLASH);
352
353   if (!lex_force_match_id (lexer, "FILE"))
354     goto error;
355   lex_force_match (lexer, T_EQUALS);
356   fh = fh_parse (lexer, FH_REF_FILE | FH_REF_INLINE, NULL);
357   if (fh == NULL)
358     goto error;
359
360   parser = data_parser_create (dict);
361   has_type = false;
362   data_parser_set_type (parser, DP_DELIMITED);
363   data_parser_set_span (parser, false);
364   data_parser_set_quotes (parser, ss_empty ());
365   data_parser_set_empty_line_has_field (parser, true);
366
367   for (;;)
368     {
369       if (!lex_force_match (lexer, T_SLASH))
370         goto error;
371
372       if (lex_match_id (lexer, "ENCODING"))
373         {
374           lex_match (lexer, T_EQUALS);
375           if (!lex_force_string (lexer))
376             goto error;
377
378           free (encoding);
379           encoding = ss_xstrdup (lex_tokss (lexer));
380
381           lex_get (lexer);
382         }
383       else if (lex_match_id (lexer, "ARRANGEMENT"))
384         {
385           bool ok;
386
387           lex_match (lexer, T_EQUALS);
388           if (lex_match_id (lexer, "FIXED"))
389             ok = set_type (parser, "ARRANGEMENT=FIXED", DP_FIXED, &has_type);
390           else if (lex_match_id (lexer, "DELIMITED"))
391             ok = set_type (parser, "ARRANGEMENT=DELIMITED",
392                            DP_DELIMITED, &has_type);
393           else
394             {
395               lex_error_expecting (lexer, "FIXED", "DELIMITED", NULL_SENTINEL);
396               goto error;
397             }
398           if (!ok)
399             goto error;
400         }
401       else if (lex_match_id (lexer, "FIRSTCASE"))
402         {
403           lex_match (lexer, T_EQUALS);
404           if (!lex_force_int (lexer))
405             goto error;
406           if (lex_integer (lexer) < 1)
407             {
408               msg (SE, _("Value of FIRSTCASE must be 1 or greater."));
409               goto error;
410             }
411           data_parser_set_skip (parser, lex_integer (lexer) - 1);
412           lex_get (lexer);
413         }
414       else if (lex_match_id_n (lexer, "DELCASE", 4))
415         {
416           if (!set_type (parser, "DELCASE", DP_DELIMITED, &has_type))
417             goto error;
418           lex_match (lexer, T_EQUALS);
419           if (lex_match_id (lexer, "LINE"))
420             data_parser_set_span (parser, false);
421           else if (lex_match_id (lexer, "VARIABLES"))
422             {
423               data_parser_set_span (parser, true);
424
425               /* VARIABLES takes an integer argument, but for no
426                  good reason.  We just ignore it. */
427               if (!lex_force_int (lexer))
428                 goto error;
429               lex_get (lexer);
430             }
431           else
432             {
433               lex_error_expecting (lexer, "LINE", "VARIABLES", NULL_SENTINEL);
434               goto error;
435             }
436         }
437       else if (lex_match_id (lexer, "FIXCASE"))
438         {
439           if (!set_type (parser, "FIXCASE", DP_FIXED, &has_type))
440             goto error;
441           lex_match (lexer, T_EQUALS);
442           if (!lex_force_int (lexer))
443             goto error;
444           if (lex_integer (lexer) < 1)
445             {
446               msg (SE, _("Value of FIXCASE must be at least 1."));
447               goto error;
448             }
449           data_parser_set_records (parser, lex_integer (lexer));
450           lex_get (lexer);
451         }
452       else if (lex_match_id (lexer, "IMPORTCASES"))
453         {
454           lex_match (lexer, T_EQUALS);
455           if (lex_match (lexer, T_ALL))
456             {
457               data_parser_set_case_limit (parser, -1);
458               data_parser_set_case_percent (parser, 100);
459             }
460           else if (lex_match_id (lexer, "FIRST"))
461             {
462               if (!lex_force_int (lexer))
463                 goto error;
464               if (lex_integer (lexer) < 1)
465                 {
466                   msg (SE, _("Value of FIRST must be at least 1."));
467                   goto error;
468                 }
469               data_parser_set_case_limit (parser, lex_integer (lexer));
470               lex_get (lexer);
471             }
472           else if (lex_match_id (lexer, "PERCENT"))
473             {
474               if (!lex_force_int (lexer))
475                 goto error;
476               if (lex_integer (lexer) < 1 || lex_integer (lexer) > 100)
477                 {
478                   msg (SE, _("Value of PERCENT must be between 1 and 100."));
479                   goto error;
480                 }
481               data_parser_set_case_percent (parser, lex_integer (lexer));
482               lex_get (lexer);
483             }
484         }
485       else if (lex_match_id_n (lexer, "DELIMITERS", 4))
486         {
487           struct string hard_seps = DS_EMPTY_INITIALIZER;
488           const char *soft_seps = "";
489           struct substring s;
490           int c;
491
492           if (!set_type (parser, "DELIMITERS", DP_DELIMITED, &has_type))
493             goto error;
494           lex_match (lexer, T_EQUALS);
495
496           if (!lex_force_string (lexer))
497             goto error;
498
499           /* XXX should support multibyte UTF-8 characters */
500           s = lex_tokss (lexer);
501           if (ss_match_string (&s, ss_cstr ("\\t")))
502             ds_put_cstr (&hard_seps, "\t");
503           if (ss_match_string (&s, ss_cstr ("\\\\")))
504             ds_put_cstr (&hard_seps, "\\");
505           while ((c = ss_get_byte (&s)) != EOF)
506             if (c == ' ')
507               soft_seps = " ";
508             else
509               ds_put_byte (&hard_seps, c);
510           data_parser_set_soft_delimiters (parser, ss_cstr (soft_seps));
511           data_parser_set_hard_delimiters (parser, ds_ss (&hard_seps));
512           ds_destroy (&hard_seps);
513
514           lex_get (lexer);
515         }
516       else if (lex_match_id (lexer, "QUALIFIERS"))
517         {
518           if (!set_type (parser, "QUALIFIERS", DP_DELIMITED, &has_type))
519             goto error;
520           lex_match (lexer, T_EQUALS);
521
522           if (!lex_force_string (lexer))
523             goto error;
524
525           /* XXX should support multibyte UTF-8 characters */
526           if (settings_get_syntax () == COMPATIBLE
527               && ss_length (lex_tokss (lexer)) != 1)
528             {
529               msg (SE, _("In compatible syntax mode, the QUALIFIER string "
530                          "must contain exactly one character."));
531               goto error;
532             }
533
534           data_parser_set_quotes (parser, lex_tokss (lexer));
535           lex_get (lexer);
536         }
537       else if (settings_get_syntax () == ENHANCED
538                && lex_match_id (lexer, "ESCAPE"))
539         data_parser_set_quote_escape (parser, true);
540       else if (lex_match_id (lexer, "VARIABLES"))
541         break;
542       else
543         {
544           lex_error_expecting (lexer, "VARIABLES", NULL_SENTINEL);
545           goto error;
546         }
547     }
548   lex_match (lexer, T_EQUALS);
549
550   record = 1;
551   type = data_parser_get_type (parser);
552   do
553     {
554       struct fmt_spec input, output;
555       struct variable *v;
556       int fc, lc;
557
558       while (type == DP_FIXED && lex_match (lexer, T_SLASH))
559         {
560           if (!lex_force_int (lexer))
561             goto error;
562           if (lex_integer (lexer) < record)
563             {
564               msg (SE, _("The record number specified, %ld, is at or "
565                          "before the previous record, %d.  Data "
566                          "fields must be listed in order of "
567                          "increasing record number."),
568                    lex_integer (lexer), record);
569               goto error;
570             }
571           if (lex_integer (lexer) > data_parser_get_records (parser))
572             {
573               msg (SE, _("The record number specified, %ld, exceeds "
574                          "the number of records per case specified "
575                          "on FIXCASE, %d."),
576                    lex_integer (lexer), data_parser_get_records (parser));
577               goto error;
578             }
579           record = lex_integer (lexer);
580           lex_get (lexer);
581         }
582
583       if (!lex_force_id (lexer)
584           || !dict_id_is_valid (dict, lex_tokcstr (lexer), true))
585         goto error;
586       name = xstrdup (lex_tokcstr (lexer));
587       lex_get (lexer);
588
589       if (type == DP_DELIMITED)
590         {
591           if (!parse_format_specifier (lexer, &input)
592               || !fmt_check_input (&input))
593             goto error;
594
595           output = fmt_for_output_from_input (&input);
596         }
597       else
598         {
599           char fmt_type_name[FMT_TYPE_LEN_MAX + 1];
600           enum fmt_type fmt_type;
601           int w, d;
602
603           if (!parse_column_range (lexer, 0, &fc, &lc, NULL))
604             goto error;
605
606           /* Accept a format (e.g. F8.2) or just a type name (e.g. DOLLAR).  */
607           if (!parse_abstract_format_specifier (lexer, fmt_type_name, &w, &d))
608             goto error;
609           if (!fmt_from_name (fmt_type_name, &fmt_type))
610             {
611               msg (SE, _("Unknown format type `%s'."), fmt_type_name);
612               goto error;
613             }
614
615           /* Compose input format. */
616           input.type = fmt_type;
617           input.w = lc - fc + 1;
618           input.d = 0;
619           if (!fmt_check_input (&input))
620             goto error;
621
622           /* Compose output format. */
623           if (w != 0)
624             {
625               output.type = fmt_type;
626               output.w = w;
627               output.d = d;
628               if (!fmt_check_output (&output))
629                 goto error;
630             }
631           else
632             output = fmt_for_output_from_input (&input);
633         }
634
635       v = dict_create_var (dict, name, fmt_var_width (&input));
636       if (v == NULL)
637         {
638           msg (SE, _("%s is a duplicate variable name."), name);
639           goto error;
640         }
641       var_set_both_formats (v, &output);
642
643       if (type == DP_DELIMITED)
644         data_parser_add_delimited_field (parser, &input,
645                                          var_get_case_index (v),
646                                          name);
647       else
648         data_parser_add_fixed_field (parser, &input, var_get_case_index (v),
649                                      name, record, fc);
650       free (name);
651       name = NULL;
652     }
653   while (lex_token (lexer) != T_ENDCMD);
654
655   reader = dfm_open_reader (fh, lexer, encoding);
656   if (reader == NULL)
657     goto error;
658
659   data_parser_make_active_file (parser, ds, reader, dict);
660   fh_unref (fh);
661   free (encoding);
662   return CMD_SUCCESS;
663
664  error:
665   data_parser_destroy (parser);
666   dict_destroy (dict);
667   fh_unref (fh);
668   free (name);
669   free (encoding);
670   return CMD_CASCADING_FAILURE;
671 }
672
673
674 static void 
675 destroy_spreadsheet_read_info (UNUSED struct spreadsheet_read_info *sri,
676                                UNUSED struct spreadsheet_read_options *opts)
677 {
678 }