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