1 /* PSPP - a program for statistical analysis.
2 Copyright (C) 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
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.
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.
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/>. */
21 #include "data/dataset.h"
22 #include "data/dictionary.h"
23 #include "data/format.h"
24 #include "data/gnumeric-reader.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/i18n.h"
35 #include "libpspp/message.h"
37 #include "gl/xalloc.h"
40 #define _(msgid) gettext (msgid)
41 #define N_(msgid) (msgid)
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 *);
48 cmd_get_data (struct lexer *lexer, struct dataset *ds)
50 lex_force_match (lexer, T_SLASH);
52 if (!lex_force_match_id (lexer, "TYPE"))
55 lex_force_match (lexer, T_EQUALS);
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);
64 msg (SE, _("Unsupported TYPE %s."), lex_tokcstr (lexer));
69 parse_get_psql (struct lexer *lexer, struct dataset *ds)
71 struct psql_read_info psql;
72 psql.allow_clear = false;
76 ds_init_empty (&psql.sql);
78 lex_force_match (lexer, T_SLASH);
80 if (!lex_force_match_id (lexer, "CONNECT"))
83 lex_force_match (lexer, T_EQUALS);
85 if (!lex_force_string (lexer))
88 psql.conninfo = ss_xstrdup (lex_tokss (lexer));
92 while (lex_match (lexer, T_SLASH) )
94 if ( lex_match_id (lexer, "ASSUMEDSTRWIDTH"))
96 lex_match (lexer, T_EQUALS);
97 psql.str_width = lex_integer (lexer);
100 else if ( lex_match_id (lexer, "BSIZE"))
102 lex_match (lexer, T_EQUALS);
103 psql.bsize = lex_integer (lexer);
106 else if ( lex_match_id (lexer, "UNENCRYPTED"))
108 psql.allow_clear = true;
110 else if (lex_match_id (lexer, "SQL"))
112 lex_match (lexer, T_EQUALS);
113 if ( ! lex_force_string (lexer) )
116 ds_put_substring (&psql.sql, lex_tokss (lexer));
121 struct dictionary *dict = NULL;
122 struct casereader *reader = psql_open_reader (&psql, &dict);
126 dataset_set_dict (ds, dict);
127 dataset_set_source (ds, reader);
131 ds_destroy (&psql.sql);
132 free (psql.conninfo);
138 ds_destroy (&psql.sql);
139 free (psql.conninfo);
145 parse_get_gnm (struct lexer *lexer, struct dataset *ds)
147 struct gnumeric_read_info gri = {NULL, NULL, NULL, 1, true, -1};
149 lex_force_match (lexer, T_SLASH);
151 if (!lex_force_match_id (lexer, "FILE"))
154 lex_force_match (lexer, T_EQUALS);
156 if (!lex_force_string (lexer))
159 gri.file_name = utf8_to_filename (lex_tokcstr (lexer));
163 while (lex_match (lexer, T_SLASH) )
165 if ( lex_match_id (lexer, "ASSUMEDSTRWIDTH"))
167 lex_match (lexer, T_EQUALS);
168 gri.asw = lex_integer (lexer);
171 else if (lex_match_id (lexer, "SHEET"))
173 lex_match (lexer, T_EQUALS);
174 if (lex_match_id (lexer, "NAME"))
176 if ( ! lex_force_string (lexer) )
179 gri.sheet_name = ss_xstrdup (lex_tokss (lexer));
180 gri.sheet_index = -1;
184 else if (lex_match_id (lexer, "INDEX"))
186 gri.sheet_index = lex_integer (lexer);
192 else if (lex_match_id (lexer, "CELLRANGE"))
194 lex_match (lexer, T_EQUALS);
196 if (lex_match_id (lexer, "FULL"))
198 gri.cell_range = NULL;
200 else if (lex_match_id (lexer, "RANGE"))
202 if ( ! lex_force_string (lexer) )
205 gri.cell_range = ss_xstrdup (lex_tokss (lexer));
211 else if (lex_match_id (lexer, "READNAMES"))
213 lex_match (lexer, T_EQUALS);
215 if ( lex_match_id (lexer, "ON"))
217 gri.read_names = true;
219 else if (lex_match_id (lexer, "OFF"))
221 gri.read_names = false;
228 lex_error (lexer, NULL);
234 struct dictionary *dict = NULL;
235 struct casereader *reader = gnumeric_open_reader (&gri, &dict);
239 dataset_set_dict (ds, dict);
240 dataset_set_source (ds, reader);
244 free (gri.file_name);
245 free (gri.sheet_name);
246 free (gri.cell_range);
251 free (gri.file_name);
252 free (gri.sheet_name);
253 free (gri.cell_range);
258 set_type (struct data_parser *parser, const char *subcommand,
259 enum data_parser_type type, bool *has_type)
263 data_parser_set_type (parser, type);
266 else if (type != data_parser_get_type (parser))
268 msg (SE, _("%s is allowed only with %s arrangement, but %s arrangement "
269 "was stated or implied earlier in this command."),
271 type == DP_FIXED ? "FIXED" : "DELIMITED",
272 type == DP_FIXED ? "DELIMITED" : "FIXED");
279 parse_get_txt (struct lexer *lexer, struct dataset *ds)
281 struct data_parser *parser = NULL;
282 struct dictionary *dict = dict_create ();
283 struct file_handle *fh = NULL;
284 struct dfm_reader *reader = NULL;
288 enum data_parser_type type;
291 lex_force_match (lexer, T_SLASH);
293 if (!lex_force_match_id (lexer, "FILE"))
295 lex_force_match (lexer, T_EQUALS);
296 fh = fh_parse (lexer, FH_REF_FILE | FH_REF_INLINE);
300 parser = data_parser_create (dict);
302 data_parser_set_type (parser, DP_DELIMITED);
303 data_parser_set_span (parser, false);
304 data_parser_set_quotes (parser, ss_empty ());
305 data_parser_set_empty_line_has_field (parser, true);
309 if (!lex_force_match (lexer, T_SLASH))
312 if (lex_match_id (lexer, "ARRANGEMENT"))
316 lex_match (lexer, T_EQUALS);
317 if (lex_match_id (lexer, "FIXED"))
318 ok = set_type (parser, "ARRANGEMENT=FIXED", DP_FIXED, &has_type);
319 else if (lex_match_id (lexer, "DELIMITED"))
320 ok = set_type (parser, "ARRANGEMENT=DELIMITED",
321 DP_DELIMITED, &has_type);
324 lex_error (lexer, _("expecting %s or %s"), "FIXED", "DELIMITED");
330 else if (lex_match_id (lexer, "FIRSTCASE"))
332 lex_match (lexer, T_EQUALS);
333 if (!lex_force_int (lexer))
335 if (lex_integer (lexer) < 1)
337 msg (SE, _("Value of FIRSTCASE must be 1 or greater."));
340 data_parser_set_skip (parser, lex_integer (lexer) - 1);
343 else if (lex_match_id_n (lexer, "DELCASE", 4))
345 if (!set_type (parser, "DELCASE", DP_DELIMITED, &has_type))
347 lex_match (lexer, T_EQUALS);
348 if (lex_match_id (lexer, "LINE"))
349 data_parser_set_span (parser, false);
350 else if (lex_match_id (lexer, "VARIABLES"))
352 data_parser_set_span (parser, true);
354 /* VARIABLES takes an integer argument, but for no
355 good reason. We just ignore it. */
356 if (!lex_force_int (lexer))
362 lex_error (lexer, _("expecting %s or %s"), "LINE", "VARIABLES");
366 else if (lex_match_id (lexer, "FIXCASE"))
368 if (!set_type (parser, "FIXCASE", DP_FIXED, &has_type))
370 lex_match (lexer, T_EQUALS);
371 if (!lex_force_int (lexer))
373 if (lex_integer (lexer) < 1)
375 msg (SE, _("Value of FIXCASE must be at least 1."));
378 data_parser_set_records (parser, lex_integer (lexer));
381 else if (lex_match_id (lexer, "IMPORTCASES"))
383 lex_match (lexer, T_EQUALS);
384 if (lex_match (lexer, T_ALL))
386 data_parser_set_case_limit (parser, -1);
387 data_parser_set_case_percent (parser, 100);
389 else if (lex_match_id (lexer, "FIRST"))
391 if (!lex_force_int (lexer))
393 if (lex_integer (lexer) < 1)
395 msg (SE, _("Value of FIRST must be at least 1."));
398 data_parser_set_case_limit (parser, lex_integer (lexer));
401 else if (lex_match_id (lexer, "PERCENT"))
403 if (!lex_force_int (lexer))
405 if (lex_integer (lexer) < 1 || lex_integer (lexer) > 100)
407 msg (SE, _("Value of PERCENT must be between 1 and 100."));
410 data_parser_set_case_percent (parser, lex_integer (lexer));
414 else if (lex_match_id_n (lexer, "DELIMITERS", 4))
416 struct string hard_seps = DS_EMPTY_INITIALIZER;
417 const char *soft_seps = "";
421 if (!set_type (parser, "DELIMITERS", DP_DELIMITED, &has_type))
423 lex_match (lexer, T_EQUALS);
425 if (!lex_force_string (lexer))
428 /* XXX should support multibyte UTF-8 characters */
429 s = lex_tokss (lexer);
430 if (ss_match_string (&s, ss_cstr ("\\t")))
431 ds_put_cstr (&hard_seps, "\t");
432 if (ss_match_string (&s, ss_cstr ("\\\\")))
433 ds_put_cstr (&hard_seps, "\\");
434 while ((c = ss_get_byte (&s)) != EOF)
438 ds_put_byte (&hard_seps, c);
439 data_parser_set_soft_delimiters (parser, ss_cstr (soft_seps));
440 data_parser_set_hard_delimiters (parser, ds_ss (&hard_seps));
441 ds_destroy (&hard_seps);
445 else if (lex_match_id (lexer, "QUALIFIERS"))
447 if (!set_type (parser, "QUALIFIERS", DP_DELIMITED, &has_type))
449 lex_match (lexer, T_EQUALS);
451 if (!lex_force_string (lexer))
454 /* XXX should support multibyte UTF-8 characters */
455 if (settings_get_syntax () == COMPATIBLE
456 && ss_length (lex_tokss (lexer)) != 1)
458 msg (SE, _("In compatible syntax mode, the QUALIFIER string "
459 "must contain exactly one character."));
463 data_parser_set_quotes (parser, lex_tokss (lexer));
466 else if (settings_get_syntax () == ENHANCED
467 && lex_match_id (lexer, "ESCAPE"))
468 data_parser_set_quote_escape (parser, true);
469 else if (lex_match_id (lexer, "VARIABLES"))
473 lex_error (lexer, _("expecting %s"), "VARIABLES");
477 lex_match (lexer, T_EQUALS);
480 type = data_parser_get_type (parser);
483 struct fmt_spec input, output;
487 while (type == DP_FIXED && lex_match (lexer, T_SLASH))
489 if (!lex_force_int (lexer))
491 if (lex_integer (lexer) < record)
493 msg (SE, _("The record number specified, %ld, is at or "
494 "before the previous record, %d. Data "
495 "fields must be listed in order of "
496 "increasing record number."),
497 lex_integer (lexer), record);
500 if (lex_integer (lexer) > data_parser_get_records (parser))
502 msg (SE, _("The record number specified, %ld, exceeds "
503 "the number of records per case specified "
505 lex_integer (lexer), data_parser_get_records (parser));
508 record = lex_integer (lexer);
512 if (!lex_force_id (lexer)
513 || !dict_id_is_valid (dict, lex_tokcstr (lexer), true))
515 name = xstrdup (lex_tokcstr (lexer));
518 if (type == DP_DELIMITED)
520 if (!parse_format_specifier (lexer, &input)
521 || !fmt_check_input (&input))
526 if (!parse_column_range (lexer, 0, &fc, &lc, NULL))
528 if (!parse_format_specifier_name (lexer, &input.type))
530 input.w = lc - fc + 1;
532 if (!fmt_check_input (&input))
535 output = fmt_for_output_from_input (&input);
537 v = dict_create_var (dict, name, fmt_var_width (&input));
540 msg (SE, _("%s is a duplicate variable name."), name);
543 var_set_both_formats (v, &output);
545 if (type == DP_DELIMITED)
546 data_parser_add_delimited_field (parser, &input,
547 var_get_case_index (v),
550 data_parser_add_fixed_field (parser, &input, var_get_case_index (v),
555 while (lex_token (lexer) != T_ENDCMD);
557 reader = dfm_open_reader (fh, lexer);
561 data_parser_make_active_file (parser, ds, reader, dict);
566 data_parser_destroy (parser);
570 return CMD_CASCADING_FAILURE;