src/language/tests/float-format.c

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 2006, 2010 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 <inttypes.h>
  22 #include <limits.h>
  23 #include <unistr.h>
  24
  25 #include "language/command.h"
  26 #include "language/lexer/lexer.h"
  27 #include "libpspp/assertion.h"
  28 #include "libpspp/cast.h"
  29 #include "libpspp/message.h"
  30 #include "libpspp/str.h"
  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 /* Returns the integer value of (hex) digit C. */
  97 static int
  98 digit_value (int c)
  99 {
 100   switch (c)
 101     {
 102     case '0': return 0;
 103     case '1': return 1;
 104     case '2': return 2;
 105     case '3': return 3;
 106     case '4': return 4;
 107     case '5': return 5;
 108     case '6': return 6;
 109     case '7': return 7;
 110     case '8': return 8;
 111     case '9': return 9;
 112     case 'a': case 'A': return 10;
 113     case 'b': case 'B': return 11;
 114     case 'c': case 'C': return 12;
 115     case 'd': case 'D': return 13;
 116     case 'e': case 'E': return 14;
 117     case 'f': case 'F': return 15;
 118     default: return INT_MAX;
 119     }
 120 }
 121
 122 /* Parses a number in the form FORMAT(STRING), where FORMAT is
 123    the name of the format and STRING gives the number's
 124    representation.  Also supports ordinary floating-point numbers
 125    written in decimal notation.  Returns success. */
 126 static bool
 127 parse_fp (struct lexer *lexer, struct fp *fp)
 128 {
 129   memset (fp, 0, sizeof *fp);
 130   if (lex_is_number (lexer))
 131     {
 132       double number = lex_number (lexer);
 133       fp->format = FLOAT_NATIVE_DOUBLE;
 134       memcpy (fp->data, &number, sizeof number);
 135       lex_get (lexer);
 136     }
 137   else if (lex_token (lexer) == T_ID)
 138     {
 139       struct substring s;
 140
 141       if (!parse_float_format (lexer, &fp->format)
 142           || !lex_force_match (lexer, T_LPAREN)
 143           || !lex_force_string (lexer))
 144         return false;
 145
 146       s = lex_tokss (lexer);
 147       if (fp->format != FLOAT_HEX)
 148         {
 149           size_t i;
 150
 151           if (s.length != float_get_size (fp->format) * 2)
 152             {
 153               msg (SE, "%zu-byte string needed but %zu-byte string "
 154                    "supplied.", float_get_size (fp->format), s.length);
 155               return false;
 156             }
 157           assert (s.length / 2 <= sizeof fp->data);
 158           for (i = 0; i < s.length / 2; i++)
 159             {
 160               int hi = digit_value (s.string[i * 2]);
 161               int lo = digit_value (s.string[i * 2 + 1]);
 162
 163               if (hi >= 16 || lo >= 16)
 164                 {
 165                   msg (SE, "Invalid hex digit in string.");
 166                   return false;
 167                 }
 168
 169               fp->data[i] = hi * 16 + lo;
 170             }
 171         }
 172       else
 173         {
 174           if (s.length >= sizeof fp->data)
 175             {
 176               msg (SE, "Hexadecimal floating constant too long.");
 177               return false;
 178             }
 179           memcpy (fp->data, s.string, s.length);
 180         }
 181
 182       lex_get (lexer);
 183       if (!lex_force_match (lexer, T_RPAREN))
 184         return false;
 185     }
 186   else
 187     {
 188       lex_error (lexer, NULL);
 189       return false;
 190     }
 191   return true;
 192 }
 193
 194 /* Renders SRC, which contains SRC_SIZE bytes of a floating-point
 195    number in the given FORMAT, as relatively human-readable
 196    null-terminated string in the DST_SIZE bytes in DST.  DST_SIZE
 197    must be be large enough to hold the output. */
 198 static void
 199 make_printable (enum float_format format, const void *src_, size_t src_size,
 200                 char *dst, size_t dst_size)
 201 {
 202   assert (dst_size >= 2 * src_size + 1);
 203   if (format != FLOAT_HEX)
 204     {
 205       const uint8_t *src = src_;
 206       while (src_size-- > 0)
 207         {
 208           sprintf (dst, "%02x", *src++);
 209           dst += 2;
 210         }
 211       *dst = '\0';
 212     }
 213   else
 214     strncpy (dst, src_, src_size + 1);
 215 }
 216
 217 /* Checks that RESULT is identical to TO.
 218    If so, returns false.
 219    If not, issues a helpful error message that includes the given
 220    CONVERSION_TYPE and the value that was converted FROM, and
 221    returns true. */
 222 static bool
 223 mismatch (const struct fp *from, const struct fp *to, char *result,
 224           const char *conversion_type)
 225 {
 226   size_t to_size = float_get_size (to->format);
 227   if (!memcmp (to->data, result, to_size))
 228     return false;
 229   else
 230     {
 231       size_t from_size = float_get_size (from->format);
 232       char original[FP_MAX_SIZE * 2 + 1];
 233       char expected[FP_MAX_SIZE * 2 + 1];
 234       char actual[FP_MAX_SIZE * 2 + 1];
 235       make_printable (from->format, from->data, from_size, original,
 236                       sizeof original);
 237       make_printable (to->format, to->data, to_size, expected,
 238                       sizeof expected);
 239       make_printable (to->format, result, to_size, actual, sizeof actual);
 240       msg (SE, "%s conversion of %s from %s to %s should have produced %s "
 241            "but actually produced %s.",
 242            conversion_type,
 243            original, get_float_format_name (from->format),
 244            get_float_format_name (to->format), expected,
 245            actual);
 246       return true;
 247     }
 248 }
 249
 250 /* Checks that converting FROM into the format of TO yields
 251    exactly the data in TO. */
 252 static bool
 253 verify_conversion (const struct fp *from, const struct fp *to)
 254 {
 255   char tmp1[FP_MAX_SIZE], tmp2[FP_MAX_SIZE];
 256
 257   /* First try converting directly. */
 258   float_convert (from->format, from->data, to->format, tmp1);
 259   if (mismatch (from, to, tmp1, "Direct"))
 260     return false;
 261
 262   /* Then convert via FLOAT_FP to prevent short-circuiting that
 263      float_convert() does for some conversions (e.g. little<->big
 264      endian for IEEE formats). */
 265   float_convert (from->format, from->data, FLOAT_FP, tmp1);
 266   float_convert (FLOAT_FP, tmp1, to->format, tmp2);
 267   if (mismatch (from, to, tmp2, "Indirect"))
 268     return false;
 269
 270   return true;
 271 }
 272
 273 /* Executes the DEBUG FLOAT FORMAT command. */
 274 int
 275 cmd_debug_float_format (struct lexer *lexer, struct dataset *ds UNUSED)
 276 {
 277   struct fp fp[16];
 278   size_t fp_cnt = 0;
 279   bool bijective = false;
 280   bool ok;
 281
 282   for (;;)
 283     {
 284       if (fp_cnt >= sizeof fp / sizeof *fp)
 285         {
 286           msg (SE, "Too many values in single command.");
 287           return CMD_FAILURE;
 288         }
 289       if (!parse_fp (lexer, &fp[fp_cnt++]))
 290         return CMD_FAILURE;
 291
 292       if (lex_token (lexer) == T_ENDCMD && fp_cnt > 1)
 293         break;
 294       else if (!lex_force_match (lexer, T_EQUALS))
 295         return CMD_FAILURE;
 296
 297       if (fp_cnt == 1)
 298         {
 299           if (lex_match (lexer, T_EQUALS))
 300             bijective = true;
 301           else if (lex_match (lexer, T_GT))
 302             bijective = false;
 303           else
 304             {
 305               lex_error (lexer, NULL);
 306               return CMD_FAILURE;
 307             }
 308         }
 309       else
 310         {
 311           if ((bijective && !lex_force_match (lexer, T_EQUALS))
 312               || (!bijective && !lex_force_match (lexer, T_GT)))
 313             return CMD_FAILURE;
 314         }
 315     }
 316
 317   ok = true;
 318   if (bijective)
 319     {
 320       size_t i, j;
 321
 322       for (i = 0; i < fp_cnt; i++)
 323         for (j = 0; j < fp_cnt; j++)
 324           if (!verify_conversion (&fp[i], &fp[j]))
 325             ok = false;
 326     }
 327   else
 328     {
 329       size_t i;
 330
 331       for (i = 1; i < fp_cnt; i++)
 332         if (!verify_conversion (&fp[i - 1], &fp[i]))
 333           ok = false;
 334     }
 335
 336   return ok ? CMD_SUCCESS : CMD_FAILURE;
 337 }