a565f4471c3aeef45f34db40c44641b34a620ec9
[pspp] / src / language / data-io / save-translate.c
1 /* PSPP - a program for statistical analysis.
2    Copyright (C) 2010, 2011, 2013, 2016 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/case-map.h"
22 #include "data/casereader.h"
23 #include "data/casewriter.h"
24 #include "data/csv-file-writer.h"
25 #include "data/dataset.h"
26 #include "data/dictionary.h"
27 #include "data/file-name.h"
28 #include "data/format.h"
29 #include "data/settings.h"
30 #include "language/command.h"
31 #include "language/data-io/file-handle.h"
32 #include "language/data-io/trim.h"
33 #include "language/lexer/lexer.h"
34 #include "libpspp/message.h"
35
36
37 #include "gettext.h"
38 #define _(msgid) gettext (msgid)
39 #define N_(msgid) (msgid)
40
41 int
42 cmd_save_translate (struct lexer *lexer, struct dataset *ds)
43 {
44   enum { CSV_FILE = 1, TAB_FILE } type;
45
46   struct dictionary *dict;
47   struct case_map_stage *stage;
48   struct case_map *map;
49   struct casewriter *writer;
50   struct file_handle *handle;
51
52   bool replace;
53
54   bool retain_unselected;
55   bool recode_user_missing;
56   bool include_var_names;
57   bool use_value_labels;
58   bool use_print_formats;
59   char decimal;
60   char delimiter;
61   char qualifier;
62
63   bool ok;
64
65   type = 0;
66
67   dict = dict_clone (dataset_dict (ds));
68   dict_set_names_must_be_ids (dict, false);
69   stage = NULL;
70   map = NULL;
71
72   handle = NULL;
73   replace = false;
74
75   retain_unselected = true;
76   recode_user_missing = false;
77   include_var_names = false;
78   use_value_labels = false;
79   use_print_formats = false;
80   decimal = settings_get_fmt_settings ()->decimal;
81   delimiter = 0;
82   qualifier = '"';
83
84   stage = case_map_stage_create (dict);
85   dict_delete_scratch_vars (dict);
86
87   while (lex_token (lexer) != T_ENDCMD)
88     {
89       if (!lex_force_match (lexer, T_SLASH))
90         goto error;
91
92       if (lex_match_id (lexer, "OUTFILE"))
93         {
94           if (handle != NULL)
95             {
96               lex_sbc_only_once ("OUTFILE");
97               goto error;
98             }
99
100           lex_match (lexer, T_EQUALS);
101
102           handle = fh_parse (lexer, FH_REF_FILE, NULL);
103           if (handle == NULL)
104             goto error;
105         }
106       else if (lex_match_id (lexer, "TYPE"))
107         {
108           if (type != 0)
109             {
110               lex_sbc_only_once ("TYPE");
111               goto error;
112             }
113
114           lex_match (lexer, T_EQUALS);
115           if (lex_match_id (lexer, "CSV"))
116             type = CSV_FILE;
117           else if (lex_match_id (lexer, "TAB"))
118             type = TAB_FILE;
119           else
120             {
121               lex_error_expecting (lexer, "CSV", "TAB");
122               goto error;
123             }
124         }
125       else if (lex_match_id (lexer, "REPLACE"))
126         replace = true;
127       else if (lex_match_id (lexer, "FIELDNAMES"))
128         include_var_names = true;
129       else if (lex_match_id (lexer, "MISSING"))
130         {
131           lex_match (lexer, T_EQUALS);
132           if (lex_match_id (lexer, "IGNORE"))
133             recode_user_missing = false;
134           else if (lex_match_id (lexer, "RECODE"))
135             recode_user_missing = true;
136           else
137             {
138               lex_error_expecting (lexer, "IGNORE", "RECODE");
139               goto error;
140             }
141         }
142       else if (lex_match_id (lexer, "CELLS"))
143         {
144           lex_match (lexer, T_EQUALS);
145           if (lex_match_id (lexer, "VALUES"))
146             use_value_labels = false;
147           else if (lex_match_id (lexer, "LABELS"))
148             use_value_labels = true;
149           else
150             {
151               lex_error_expecting (lexer, "VALUES", "LABELS");
152               goto error;
153             }
154         }
155       else if (lex_match_id (lexer, "TEXTOPTIONS"))
156         {
157           lex_match (lexer, T_EQUALS);
158           for (;;)
159             {
160               if (lex_match_id (lexer, "DELIMITER"))
161                 {
162                   lex_match (lexer, T_EQUALS);
163                   if (!lex_force_string (lexer))
164                     goto error;
165                   /* XXX should support multibyte UTF-8 delimiters */
166                   if (ss_length (lex_tokss (lexer)) != 1)
167                     {
168                       msg (SE, _("The %s string must contain exactly one "
169                                  "character."), "DELIMITER");
170                       goto error;
171                     }
172                   delimiter = ss_first (lex_tokss (lexer));
173                   lex_get (lexer);
174                 }
175               else if (lex_match_id (lexer, "QUALIFIER"))
176                 {
177                   lex_match (lexer, T_EQUALS);
178                   if (!lex_force_string (lexer))
179                     goto error;
180                   /* XXX should support multibyte UTF-8 qualifiers */
181                   if (ss_length (lex_tokss (lexer)) != 1)
182                     {
183                       msg (SE, _("The %s string must contain exactly one "
184                                  "character."), "QUALIFIER");
185                       goto error;
186                     }
187                   qualifier = ss_first (lex_tokss (lexer));
188                   lex_get (lexer);
189                 }
190               else if (lex_match_id (lexer, "DECIMAL"))
191                 {
192                   lex_match (lexer, T_EQUALS);
193                   if (lex_match_id (lexer, "DOT"))
194                     decimal = '.';
195                   else if (lex_match_id (lexer, "COMMA"))
196                     decimal = ',';
197                   else
198                     {
199                       lex_error_expecting (lexer, "DOT", "COMMA");
200                       goto error;
201                     }
202                 }
203               else if (lex_match_id (lexer, "FORMAT"))
204                 {
205                   lex_match (lexer, T_EQUALS);
206                   if (lex_match_id (lexer, "PLAIN"))
207                     use_print_formats = false;
208                   else if (lex_match_id (lexer, "VARIABLE"))
209                     use_print_formats = true;
210                   else
211                     {
212                       lex_error_expecting (lexer, "PLAIN", "VARIABLE");
213                       goto error;
214                     }
215                 }
216               else
217                 break;
218             }
219         }
220       else if (lex_match_id (lexer, "UNSELECTED"))
221         {
222           lex_match (lexer, T_EQUALS);
223           if (lex_match_id (lexer, "RETAIN"))
224             retain_unselected = true;
225           else if (lex_match_id (lexer, "DELETE"))
226             retain_unselected = false;
227           else
228             {
229               lex_error_expecting (lexer, "RETAIN", "DELETE");
230               goto error;
231             }
232         }
233       else if (!parse_dict_trim (lexer, dict, true))
234         goto error;
235     }
236
237   if (type == 0)
238     {
239       lex_sbc_missing ("TYPE");
240       goto error;
241     }
242   else if (handle == NULL)
243     {
244       lex_sbc_missing ("OUTFILE");
245       goto error;
246     }
247   else if (!replace && fn_exists (handle))
248     {
249       msg (SE, _("Output file `%s' exists but %s was not specified."),
250            fh_get_file_name (handle), "REPLACE");
251       goto error;
252     }
253
254   dict_delete_scratch_vars (dict);
255   dict_compact_values (dict);
256
257   struct csv_writer_options csv_opts = {
258     .recode_user_missing = recode_user_missing,
259     .include_var_names = include_var_names,
260     .use_value_labels = use_value_labels,
261     .use_print_formats = use_print_formats,
262     .decimal = decimal,
263     .delimiter = (delimiter ? delimiter
264                   : type == TAB_FILE ? '\t'
265                   : decimal == '.' ? ','
266                   : ';'),
267     .qualifier = qualifier,
268   };
269   writer = csv_writer_open (handle, dict, &csv_opts);
270   if (writer == NULL)
271     goto error;
272   fh_unref (handle);
273
274   map = case_map_stage_get_case_map (stage);
275   case_map_stage_destroy (stage);
276   if (map != NULL)
277     writer = case_map_create_output_translator (map, writer);
278   dict_unref (dict);
279
280   casereader_transfer (proc_open_filtering (ds, !retain_unselected), writer);
281   ok = casewriter_destroy (writer);
282   ok = proc_commit (ds) && ok;
283
284   return ok ? CMD_SUCCESS : CMD_CASCADING_FAILURE;
285
286 error:
287   case_map_stage_destroy (stage);
288   fh_unref (handle);
289   dict_unref (dict);
290   case_map_destroy (map);
291   return CMD_FAILURE;
292 }