Update all #include directives to the currently preferred style.
[pspp-builds.git] / 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 }