Merge commit 'origin/stable'
[pspp-builds.git] / src / language / data-io / get-data.c
1 /* PSPP - a program for statistical analysis.
2    Copyright (C) 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/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           printf ("Unknown data file type \"\%s\"\n", lex_tokid (lexer));
223           goto error;
224         }
225       lex_get (lexer);
226     }
227
228   {
229     struct dictionary *dict = NULL;
230     struct casereader *reader = gnumeric_open_reader (&gri, &dict);
231
232     if ( reader )
233       proc_set_active_file (ds, reader, dict);
234   }
235
236   free (gri.file_name);
237   free (gri.sheet_name);
238   free (gri.cell_range);
239   return CMD_SUCCESS;
240
241  error:
242
243   free (gri.file_name);
244   free (gri.sheet_name);
245   free (gri.cell_range);
246   return CMD_FAILURE;
247 }
248
249 static bool
250 set_type (struct data_parser *parser, const char *subcommand,
251           enum data_parser_type type, bool *has_type)
252 {
253   if (!*has_type)
254     {
255       data_parser_set_type (parser, type);
256       *has_type = true;
257     }
258   else if (type != data_parser_get_type (parser))
259     {
260       msg (SE, _("%s is allowed only with %s arrangement, but %s arrangement "
261                  "was stated or implied earlier in this command."),
262            subcommand,
263            type == DP_FIXED ? "FIXED" : "DELIMITED",
264            type == DP_FIXED ? "DELIMITED" : "FIXED");
265       return false;
266     }
267   return true;
268 }
269
270 static int
271 parse_get_txt (struct lexer *lexer, struct dataset *ds)
272 {
273   struct data_parser *parser = NULL;
274   struct dictionary *dict = dict_create ();
275   struct file_handle *fh = NULL;
276   struct dfm_reader *reader = NULL;
277
278   int record;
279   enum data_parser_type type;
280   bool has_type;
281
282   lex_force_match (lexer, '/');
283
284   if (!lex_force_match_id (lexer, "FILE"))
285     goto error;
286   lex_force_match (lexer, '=');
287   fh = fh_parse (lexer, FH_REF_FILE | FH_REF_INLINE);
288   if (fh == NULL)
289     goto error;
290
291   parser = data_parser_create (dict);
292   has_type = false;
293   data_parser_set_type (parser, DP_DELIMITED);
294   data_parser_set_span (parser, false);
295   data_parser_set_quotes (parser, ss_empty ());
296   data_parser_set_empty_line_has_field (parser, true);
297
298   for (;;)
299     {
300       if (!lex_force_match (lexer, '/'))
301         goto error;
302
303       if (lex_match_id (lexer, "ARRANGEMENT"))
304         {
305           bool ok;
306
307           lex_match (lexer, '=');
308           if (lex_match_id (lexer, "FIXED"))
309             ok = set_type (parser, "ARRANGEMENT=FIXED", DP_FIXED, &has_type);
310           else if (lex_match_id (lexer, "DELIMITED"))
311             ok = set_type (parser, "ARRANGEMENT=DELIMITED",
312                            DP_DELIMITED, &has_type);
313           else
314             {
315               lex_error (lexer, _("expecting FIXED or DELIMITED"));
316               goto error;
317             }
318           if (!ok)
319             goto error;
320         }
321       else if (lex_match_id (lexer, "FIRSTCASE"))
322         {
323           lex_match (lexer, '=');
324           if (!lex_force_int (lexer))
325             goto error;
326           if (lex_integer (lexer) < 1)
327             {
328               msg (SE, _("Value of FIRSTCASE must be 1 or greater."));
329               goto error;
330             }
331           data_parser_set_skip (parser, lex_integer (lexer) - 1);
332           lex_get (lexer);
333         }
334       else if (lex_match_id_n (lexer, "DELCASE", 4))
335         {
336           if (!set_type (parser, "DELCASE", DP_DELIMITED, &has_type))
337             goto error;
338           lex_match (lexer, '=');
339           if (lex_match_id (lexer, "LINE"))
340             data_parser_set_span (parser, false);
341           else if (lex_match_id (lexer, "VARIABLES"))
342             {
343               data_parser_set_span (parser, true);
344
345               /* VARIABLES takes an integer argument, but for no
346                  good reason.  We just ignore it. */
347               if (!lex_force_int (lexer))
348                 goto error;
349               lex_get (lexer);
350             }
351           else
352             {
353               lex_error (lexer, _("expecting LINE or VARIABLES"));
354               goto error;
355             }
356         }
357       else if (lex_match_id (lexer, "FIXCASE"))
358         {
359           if (!set_type (parser, "FIXCASE", DP_FIXED, &has_type))
360             goto error;
361           lex_match (lexer, '=');
362           if (!lex_force_int (lexer))
363             goto error;
364           if (lex_integer (lexer) < 1)
365             {
366               msg (SE, _("Value of FIXCASE must be at least 1."));
367               goto error;
368             }
369           data_parser_set_records (parser, lex_integer (lexer));
370           lex_get (lexer);
371         }
372       else if (lex_match_id (lexer, "IMPORTCASES"))
373         {
374           lex_match (lexer, '=');
375           if (lex_match (lexer, T_ALL))
376             {
377               data_parser_set_case_limit (parser, -1);
378               data_parser_set_case_percent (parser, 100);
379             }
380           else if (lex_match_id (lexer, "FIRST"))
381             {
382               if (!lex_force_int (lexer))
383                 goto error;
384               if (lex_integer (lexer) < 1)
385                 {
386                   msg (SE, _("Value of FIRST must be at least 1."));
387                   goto error;
388                 }
389               data_parser_set_case_limit (parser, lex_integer (lexer));
390               lex_get (lexer);
391             }
392           else if (lex_match_id (lexer, "PERCENT"))
393             {
394               if (!lex_force_int (lexer))
395                 goto error;
396               if (lex_integer (lexer) < 1 || lex_integer (lexer) > 100)
397                 {
398                   msg (SE, _("Value of PERCENT must be between 1 and 100."));
399                   goto error;
400                 }
401               data_parser_set_case_percent (parser, lex_integer (lexer));
402               lex_get (lexer);
403             }
404         }
405       else if (lex_match_id_n (lexer, "DELIMITERS", 4))
406         {
407           struct string hard_seps = DS_EMPTY_INITIALIZER;
408           const char *soft_seps = "";
409           struct substring s;
410           int c;
411
412           if (!set_type (parser, "DELIMITERS", DP_DELIMITED, &has_type))
413             goto error;
414           lex_match (lexer, '=');
415
416           if (!lex_force_string (lexer))
417             goto error;
418
419           s = ds_ss (lex_tokstr (lexer));
420           if (ss_match_string (&s, ss_cstr ("\\t")))
421             ds_put_cstr (&hard_seps, "\t");
422           if (ss_match_string (&s, ss_cstr ("\\\\")))
423             ds_put_cstr (&hard_seps, "\\");
424           while ((c = ss_get_char (&s)) != EOF)
425             if (c == ' ')
426               soft_seps = " ";
427             else
428               ds_put_char (&hard_seps, c);
429           data_parser_set_soft_delimiters (parser, ss_cstr (soft_seps));
430           data_parser_set_hard_delimiters (parser, ds_ss (&hard_seps));
431           ds_destroy (&hard_seps);
432
433           lex_get (lexer);
434         }
435       else if (lex_match_id (lexer, "QUALIFIERS"))
436         {
437           if (!set_type (parser, "QUALIFIERS", DP_DELIMITED, &has_type))
438             goto error;
439           lex_match (lexer, '=');
440
441           if (!lex_force_string (lexer))
442             goto error;
443
444           if (settings_get_syntax () == COMPATIBLE
445               && ds_length (lex_tokstr (lexer)) != 1)
446             {
447               msg (SE, _("In compatible syntax mode, the QUALIFIER string "
448                          "must contain exactly one character."));
449               goto error;
450             }
451
452           data_parser_set_quotes (parser, ds_ss (lex_tokstr (lexer)));
453           lex_get (lexer);
454         }
455       else if (settings_get_syntax () == ENHANCED
456                && lex_match_id (lexer, "ESCAPE"))
457         data_parser_set_quote_escape (parser, true);
458       else if (lex_match_id (lexer, "VARIABLES"))
459         break;
460       else
461         {
462           lex_error (lexer, _("expecting VARIABLES"));
463           goto error;
464         }
465     }
466   lex_match (lexer, '=');
467
468
469   record = 1;
470   type = data_parser_get_type (parser);
471   do
472     {
473       char name[VAR_NAME_LEN + 1];
474       struct fmt_spec input, output;
475       int fc, lc;
476       struct variable *v;
477
478       while (type == DP_FIXED && lex_match (lexer, '/'))
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       strcpy (name, lex_tokid (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     }
543   while (lex_token (lexer) != '.');
544
545   reader = dfm_open_reader (fh, lexer);
546   if (reader == NULL)
547     goto error;
548
549   data_parser_make_active_file (parser, ds, reader, dict);
550   fh_unref (fh);
551   return CMD_SUCCESS;
552
553  error:
554   data_parser_destroy (parser);
555   dict_destroy (dict);
556   fh_unref (fh);
557   return CMD_CASCADING_FAILURE;
558 }