Remove recoding in data_store.
[pspp-builds.git] / src / ui / syntax-gen.c
1 /* PSPPIRE - a graphical user interface for PSPP.
2    Copyright (C) 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 <ui/syntax-gen.h>
20
21 #include <ctype.h>
22 #include <mbchar.h>
23
24 #include <data/data-in.h>
25 #include <data/data-out.h>
26 #include <data/format.h>
27 #include <data/value.h>
28 #include <libpspp/assertion.h>
29 #include <libpspp/message.h>
30 #include <libpspp/str.h>
31
32 /* Appends to OUTPUT a pair of hex digits for each byte in IN. */
33 static void
34 syntax_gen_hex_digits (struct string *output, struct substring in)
35 {
36   size_t i;
37   for (i = 0; i < in.length; i++)
38     {
39       unsigned char c = in.string[i];
40       ds_put_char (output, "0123456789ABCDEF"[c >> 4]);
41       ds_put_char (output, "0123456789ABCDEF"[c & 0xf]);
42     }
43 }
44
45 /* Returns true if IN contains any control characters, false
46    otherwise */
47 static bool
48 has_control_chars (struct substring in)
49 {
50   size_t i;
51
52   for (i = 0; i < in.length; i++)
53     if (iscntrl ((unsigned char) in.string[i]))
54       return true;
55   return false;
56 }
57
58 static bool
59 has_single_quote (struct substring str)
60 {
61   return (SIZE_MAX != ss_find_char (str, '\''));
62 }
63
64 static bool
65 has_double_quote (struct substring str)
66 {
67   return (SIZE_MAX != ss_find_char (str, '"'));
68 }
69
70 /* Appends to OUTPUT valid PSPP syntax for a quoted string that
71    contains IN.
72
73    IN must be encoded in UTF-8, and the quoted result will also
74    be encoded in UTF-8.
75
76    The string will be output as a regular quoted string unless it
77    contains control characters, in which case it is output as a
78    hex string. */
79 void
80 syntax_gen_string (struct string *output, struct substring in)
81 {
82   if (has_control_chars (in))
83     {
84       ds_put_cstr (output, "X'");
85       syntax_gen_hex_digits (output, in);
86       ds_put_char (output, '\'');
87     }
88   else
89     {
90       int quote;
91       size_t i;
92
93       /* This seemingly simple implementation is possible, because UTF-8
94          guarantees that bytes corresponding to basic characters (such as
95          '\'') cannot appear in a multi-byte character sequence except to
96          represent that basic character.
97       */
98       assert (is_basic ('\''));
99
100       quote = has_double_quote (in) && !has_single_quote (in) ? '\'' : '"';
101       ds_put_char (output, quote);
102       for (i = 0; i < in.length; i++)
103         {
104           char c = in.string[i];
105           if (c == quote)
106             ds_put_char (output, quote);
107           ds_put_char (output, c);
108         }
109       ds_put_char (output, quote);
110     }
111 }
112
113 /* Appends to OUTPUT a representation of NUMBER in PSPP syntax.
114    The representation is precise, that is, when PSPP parses the
115    representation, its value will be exactly NUMBER.  (This might
116    not be the case on a C implementation where double has a
117    different representation.)
118
119    If NUMBER is the system-missing value, it is output as the
120    identifier SYSMIS.  This may not be appropriate, because
121    SYSMIS is not consistently parsed throughout PSPP syntax as
122    the system-missing value.  But in such circumstances the
123    system-missing value would not be meaningful anyhow, so the
124    caller should refrain from supplying the system-missing value
125    in such cases.
126
127    A value of LOWEST or HIGHEST is not treated specially.
128
129    If FORMAT is null, then the representation will be in numeric
130    form, e.g. 123 or 1.23e10.
131
132    If FORMAT is non-null, then it must point to a numeric format.
133    If the format is one easier for a user to understand when
134    expressed as a string than as a number (for example, a date
135    format), and the string representation precisely represents
136    NUMBER, then the string representation is written to OUTPUT.
137    Otherwise, NUMBER is output as if FORMAT was a null
138    pointer. */
139 void
140 syntax_gen_number (struct string *output,
141                    double number, const struct fmt_spec *format)
142 {
143   assert (format == NULL || fmt_is_numeric (format->type));
144   if (format != NULL
145       && (format->type
146           & (FMT_CAT_DATE | FMT_CAT_TIME | FMT_CAT_DATE_COMPONENT)))
147     {
148       union value v_in, v_out;
149       char *s;
150       bool ok;
151
152       v_in.f = number;
153       s = data_out (&v_in, "FIXME",  format);
154       msg_disable ();
155       ok = data_in (ss_cstr (s), LEGACY_NATIVE,
156                     format->type, false, 0, 0, &v_out, 0);
157       msg_enable ();
158       if (ok && v_out.f == number)
159         {
160           syntax_gen_string (output, ss_cstr (s));
161           free (s);
162           return;
163         }
164       free (s);
165     }
166
167   if (number == SYSMIS)
168     ds_put_cstr (output, "SYSMIS");
169   else
170     {
171       /* FIXME: This should consistently yield precisely the same
172          value as NUMBER on input, but its results for values
173          cannot be exactly represented in decimal are ugly: many
174          of them will have far more decimal digits than are
175          needed.  The free-format floating point output routine
176          from Steele and White, "How to Print Floating-Point
177          Numbers Accurately" is really what we want.  The MPFR
178          library has an implementation of this, or equivalent
179          functionality, in its mpfr_strtofr routine, but it would
180          not be nice to make PSPP depend on this.  Probably, we
181          should implement something equivalent to it. */
182       ds_put_format (output, "%.*g", DBL_DIG + 1, number);
183     }
184 }
185
186 /* Appends to OUTPUT a representation of VALUE, which has the
187    specified WIDTH.  If FORMAT is non-null, it influences the
188    output format.  The representation is precise, that is, when
189    PSPP parses the representation, its value will be exactly
190    VALUE. */
191 void
192 syntax_gen_value (struct string *output, const union value *value, int width,
193                   const struct fmt_spec *format)
194 {
195   assert (format == NULL || fmt_var_width (format) == width);
196   if (width == 0)
197     syntax_gen_number (output, value->f, format);
198   else
199     syntax_gen_string (output, ss_buffer (value_str (value, width), width));
200 }
201
202 /* Appends <low> THRU <high> to OUTPUT.  If LOW is LOWEST, then
203    it is formatted as the identifier LO; if HIGH is HIGHEST, then
204    it is formatted as the identifier HI.  Otherwise, LOW and HIGH
205    are formatted as with a call to syntax_gen_num with the specified
206    FORMAT.
207
208    This is the opposite of the function parse_num_range. */
209 void
210 syntax_gen_num_range (struct string *output, double low, double high,
211                       const struct fmt_spec *format)
212 {
213   if (low == LOWEST)
214     ds_put_cstr (output, "LO");
215   else
216     syntax_gen_number (output, low, format);
217
218   ds_put_cstr (output, " THRU ");
219
220   if (high == HIGHEST)
221     ds_put_cstr (output, "HI");
222   else
223     syntax_gen_number (output, high, format);
224 }
225
226 /* Same as syntax_gen_pspp, below, but takes a va_list. */
227 void
228 syntax_gen_pspp_valist (struct string *output, const char *format,
229                         va_list args)
230 {
231   for (;;)
232     {
233       size_t copy = strcspn (format, "%");
234       ds_put_substring (output, ss_buffer (format, copy));
235       format += copy;
236
237       if (*format == '\0')
238         return;
239       assert (*format == '%');
240       format++;
241       switch (*format++)
242         {
243         case 's':
244           {
245             const char *s = va_arg (args, char *);
246             switch (*format++)
247               {
248               case 'q':
249                 syntax_gen_string (output, ss_cstr (s));
250                 break;
251               case 's':
252                 ds_put_cstr (output, s);
253                 break;
254               default:
255                 NOT_REACHED ();
256               }
257           }
258           break;
259
260         case 'd':
261           {
262             int i = va_arg (args, int);
263             ds_put_format (output, "%d", i);
264           }
265           break;
266
267         case 'f':
268           {
269             double d = va_arg (args, double);
270             switch (*format++)
271               {
272               case 'p':
273                 ds_put_format (output, "%f", d);
274                 break;
275               default:
276                 NOT_REACHED ();
277               }
278             break;
279           }
280
281         case '%':
282           ds_put_char (output, '%');
283           break;
284
285         default:
286           NOT_REACHED ();
287         }
288     }
289 }
290
291 /* printf-like function specialized for outputting PSPP syntax.
292    FORMAT is appended to OUTPUT.  The following substitutions are
293    supported:
294
295      %sq: The char * argument is formatted as a PSPP string, as
296           if with a call to syntax_gen_string.
297
298      %ss: The char * argument is appended literally.
299
300      %d: Same as printf's %d.
301
302      %fp: The double argument is formatted precisely as a PSPP
303           number, as if with a call to syntax_gen_number with a
304           null FORMAT argument.
305
306      %%: Literal %.
307
308    (These substitutions were chosen to allow GCC to check for
309    correct argument types.)
310
311    This function is somewhat experimental.  If it proves useful,
312    the allowed substitutions will almost certainly be
313    expanded. */
314 void
315 syntax_gen_pspp (struct string *output, const char *format, ...)
316 {
317   va_list args;
318   va_start (args, format);
319   syntax_gen_pspp_valist (output, format, args);
320   va_end (args);
321 }