Remove double semicolons.
[pspp] / src / language / tests / float-format.c
1 /* PSPP - a program for statistical analysis.
2    Copyright (C) 2006 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 <libpspp/float-format.h>
20
21 #include "gettext.h"
22 #include <inttypes.h>
23
24 #include <language/command.h>
25 #include <language/lexer/lexer.h>
26 #include <libpspp/assertion.h>
27 #include <libpspp/message.h>
28 #include <libpspp/str.h>
29
30 #define _(msgid) gettext (msgid)
31
32 /* Maximum supported size of a floating-point number, in bytes. */
33 #define FP_MAX_SIZE 32
34
35 /* A floating-point number tagged with its representation. */
36 struct fp
37   {
38     enum float_format format;           /* Format. */
39     uint8_t data[FP_MAX_SIZE];          /* Representation. */
40   };
41
42 /* Associates a format name with its identifier. */
43 struct assoc
44   {
45     char name[4];
46     enum float_format format;
47   };
48
49 /* List of floating-point formats. */
50 static const struct assoc fp_formats[] =
51   {
52     {"ISL", FLOAT_IEEE_SINGLE_LE},
53     {"ISB", FLOAT_IEEE_SINGLE_BE},
54     {"IDL", FLOAT_IEEE_DOUBLE_LE},
55     {"IDB", FLOAT_IEEE_DOUBLE_BE},
56     {"VF", FLOAT_VAX_F},
57     {"VD", FLOAT_VAX_D},
58     {"VG", FLOAT_VAX_G},
59     {"ZS", FLOAT_Z_SHORT},
60     {"ZL", FLOAT_Z_LONG},
61     {"X", FLOAT_HEX},
62     {"FP", FLOAT_FP},
63   };
64 static const size_t format_cnt = sizeof fp_formats / sizeof *fp_formats;
65
66 /* Parses a floating-point format name into *FORMAT,
67    and returns success. */
68 static bool
69 parse_float_format (struct lexer *lexer, enum float_format *format)
70 {
71   size_t i;
72
73   for (i = 0; i < format_cnt; i++)
74     if (lex_match_id (lexer, fp_formats[i].name))
75       {
76         *format = fp_formats[i].format;
77         return true;
78       }
79   lex_error (lexer, "expecting floating-point format identifier");
80   return false;
81 }
82
83 /* Returns the name for the given FORMAT. */
84 static const char *
85 get_float_format_name (enum float_format format)
86 {
87   size_t i;
88
89   for (i = 0; i < format_cnt; i++)
90     if (fp_formats[i].format == format)
91       return fp_formats[i].name;
92
93   NOT_REACHED ();
94 }
95
96 /* Parses a number in the form FORMAT(STRING), where FORMAT is
97    the name of the format and STRING gives the number's
98    representation.  Also supports ordinary floating-point numbers
99    written in decimal notation.  Returns success. */
100 static bool
101 parse_fp (struct lexer *lexer, struct fp *fp)
102 {
103   if (lex_is_number (lexer))
104     {
105       double number = lex_number (lexer);
106       fp->format = FLOAT_NATIVE_DOUBLE;
107       memcpy (fp->data, &number, sizeof number);
108       lex_get (lexer);
109     }
110   else if (lex_token (lexer) == T_ID)
111     {
112       size_t length;
113
114       if (!parse_float_format (lexer, &fp->format)
115           || !lex_force_match (lexer, '(')
116           || !lex_force_string (lexer))
117         return false;
118
119       length = ds_length (lex_tokstr (lexer));
120       if (fp->format != FLOAT_HEX)
121         {
122           if (length != float_get_size (fp->format))
123             {
124               msg (SE, _("%zu-byte string needed but %zu-byte string "
125                          "supplied."),
126                    float_get_size (fp->format), length);
127               return false;
128             }
129           assert (length <= sizeof fp->data);
130           memcpy (fp->data, ds_data (lex_tokstr (lexer)), length);
131         }
132       else
133         {
134           if (length >= sizeof fp->data)
135             {
136               msg (SE, _("Hexadecimal floating constant too long."));
137               return false;
138             }
139           strncpy ((char *) fp->data, ds_cstr (lex_tokstr (lexer)), sizeof fp->data);
140         }
141
142       lex_get (lexer);
143       if (!lex_force_match (lexer, ')'))
144         return false;
145     }
146   else
147     {
148       lex_error (lexer, NULL);
149       return false;
150     }
151   return true;
152 }
153
154 /* Renders SRC, which contains SRC_SIZE bytes of a floating-point
155    number in the given FORMAT, as relatively human-readable
156    null-terminated string in the DST_SIZE bytes in DST.  DST_SIZE
157    must be be large enough to hold the output. */
158 static void
159 make_printable (enum float_format format, const void *src_, size_t src_size,
160                 char *dst, size_t dst_size)
161 {
162   assert (dst_size >= 2 * src_size + 1);
163   if (format != FLOAT_HEX)
164     {
165       const uint8_t *src = src_;
166       while (src_size-- > 0)
167         {
168           sprintf (dst, "%02x", *src++);
169           dst += 2;
170         }
171       *dst = '\0';
172     }
173   else
174     strncpy (dst, src_, src_size + 1);
175 }
176
177 /* Checks that RESULT is identical to TO.
178    If so, returns false.
179    If not, issues a helpful error message that includes the given
180    CONVERSION_TYPE and the value that was converted FROM, and
181    returns true. */
182 static bool
183 mismatch (const struct fp *from, const struct fp *to, char *result,
184           const char *conversion_type)
185 {
186   size_t to_size = float_get_size (to->format);
187   if (!memcmp (to->data, result, to_size))
188     return false;
189   else
190     {
191       size_t from_size = float_get_size (from->format);
192       char original[FP_MAX_SIZE * 2 + 1];
193       char expected[FP_MAX_SIZE * 2 + 1];
194       char actual[FP_MAX_SIZE * 2 + 1];
195       make_printable (from->format, from->data, from_size, original,
196                       sizeof original);
197       make_printable (to->format, to->data, to_size, expected,
198                       sizeof expected);
199       make_printable (to->format, result, to_size, actual, sizeof actual);
200       msg (SE,
201            _("%s conversion of %s from %s to %s should have produced %s "
202              "but actually produced %s."),
203            conversion_type,
204            original, get_float_format_name (from->format),
205            get_float_format_name (to->format), expected,
206            actual);
207       return true;
208     }
209 }
210
211 /* Checks that converting FROM into the format of TO yields
212    exactly the data in TO. */
213 static bool
214 verify_conversion (const struct fp *from, const struct fp *to)
215 {
216   char tmp1[FP_MAX_SIZE], tmp2[FP_MAX_SIZE];
217
218   /* First try converting directly. */
219   float_convert (from->format, from->data, to->format, tmp1);
220   if (mismatch (from, to, tmp1, "Direct"))
221     return false;
222
223   /* Then convert via FLOAT_FP to prevent short-circuiting that
224      float_convert() does for some conversions (e.g. little<->big
225      endian for IEEE formats). */
226   float_convert (from->format, from->data, FLOAT_FP, tmp1);
227   float_convert (FLOAT_FP, tmp1, to->format, tmp2);
228   if (mismatch (from, to, tmp2, "Indirect"))
229     return false;
230
231   return true;
232 }
233
234 /* Executes the DEBUG FLOAT FORMAT command. */
235 int
236 cmd_debug_float_format (struct lexer *lexer, struct dataset *ds UNUSED)
237 {
238   struct fp fp[16];
239   size_t fp_cnt = 0;
240   bool bijective = false;
241   bool ok;
242
243   for (;;)
244     {
245       if (fp_cnt >= sizeof fp / sizeof *fp)
246         {
247           msg (SE, _("Too many values in single command."));
248           return CMD_FAILURE;
249         }
250       if (!parse_fp (lexer, &fp[fp_cnt++]))
251         return CMD_FAILURE;
252
253       if (lex_token (lexer) == '.' && fp_cnt > 1)
254         break;
255       else if (!lex_force_match (lexer, '='))
256         return CMD_FAILURE;
257
258       if (fp_cnt == 1)
259         {
260           if (lex_match (lexer, '='))
261             bijective = true;
262           else if (lex_match (lexer, T_GT))
263             bijective = false;
264           else
265             {
266               lex_error (lexer, NULL);
267               return CMD_FAILURE;
268             }
269         }
270       else
271         {
272           if ((bijective && !lex_force_match (lexer, '='))
273               || (!bijective && !lex_force_match (lexer, T_GT)))
274             return CMD_FAILURE;
275         }
276     }
277
278   ok = true;
279   if (bijective)
280     {
281       size_t i, j;
282
283       for (i = 0; i < fp_cnt; i++)
284         for (j = 0; j < fp_cnt; j++)
285           if (!verify_conversion (&fp[i], &fp[j]))
286             ok = false;
287     }
288   else
289     {
290       size_t i;
291
292       for (i = 1; i < fp_cnt; i++)
293         if (!verify_conversion (&fp[i - 1], &fp[i]))
294           ok = false;
295     }
296
297   return ok ? CMD_SUCCESS : CMD_FAILURE;
298 }