stdlib/gen-tst-strtod-round.c

   1 /* Generate table of tests in tst-strtod-round.c from
   2    tst-strtod-round-data.
   3    Copyright (C) 2012-2017 Free Software Foundation, Inc.
   4    This file is part of the GNU C Library.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, see
  18    <http://www.gnu.org/licenses/>.  */
  19
  20 /* Compile this program as:
  21
  22    gcc -std=gnu11 -O2 -Wall -Wextra gen-tst-strtod-round.c -lmpfr \
  23      -o gen-tst-strtod-round
  24
  25    (use of current MPFR version recommended) and run it as:
  26
  27    gen-tst-strtod-round tst-strtod-round-data tst-strtod-round-data.h
  28
  29    The output file will be generated as tst-strtod-round-data.h
  30 */
  31
  32
  33 #define _GNU_SOURCE
  34 #include <assert.h>
  35 #include <stdbool.h>
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #include <mpfr.h>
  40
  41 /* Work around incorrect ternary value from mpfr_strtofr
  42    <https://sympa.inria.fr/sympa/arc/mpfr/2012-08/msg00005.html>.  */
  43 #define WORKAROUND
  44
  45 static int
  46 string_to_fp (mpfr_t f, const char *s, mpfr_rnd_t rnd)
  47 {
  48 #ifdef WORKAROUND
  49   mpfr_t f2;
  50   mpfr_init2 (f2, 100000);
  51   int r0 = mpfr_strtofr (f2, s, NULL, 0, rnd);
  52   int r = mpfr_set (f, f2, rnd);
  53   r |= mpfr_subnormalize (f, r, rnd);
  54   mpfr_clear (f2);
  55   return r0 | r;
  56 #else
  57   int r = mpfr_strtofr (f, s, NULL, 0, rnd);
  58   r |= mpfr_subnormalize (f, r, rnd);
  59   return r;
  60 #endif
  61 }
  62
  63 void
  64 print_fp (FILE *fout, mpfr_t f, const char *suffix)
  65 {
  66   if (mpfr_inf_p (f))
  67     mpfr_fprintf (fout, "\t%sINF%s", mpfr_signbit (f) ? "-" : "", suffix);
  68   else
  69     mpfr_fprintf (fout, "\t%Ra%s", f, suffix);
  70 }
  71
  72 static void
  73 round_str (FILE *fout, const char *s, int prec, int emin, int emax,
  74            bool ibm_ld)
  75 {
  76   mpfr_t f;
  77   mpfr_set_default_prec (prec);
  78   mpfr_set_emin (emin);
  79   mpfr_set_emax (emax);
  80   mpfr_init (f);
  81   int r = string_to_fp (f, s, MPFR_RNDD);
  82   if (ibm_ld)
  83     {
  84       assert (prec == 106 && emin == -1073 && emax == 1024);
  85       /* The maximum value in IBM long double has discontiguous
  86          mantissa bits.  */
  87       mpfr_t max_value;
  88       mpfr_init2 (max_value, 107);
  89       mpfr_set_str (max_value, "0x1.fffffffffffff7ffffffffffffcp+1023", 0,
  90                     MPFR_RNDN);
  91       if (mpfr_cmpabs (f, max_value) > 0)
  92         r = 1;
  93       mpfr_clear (max_value);
  94     }
  95   mpfr_fprintf (fout, "\t%s,\n", r ? "false" : "true");
  96   print_fp (fout, f, ",\n");
  97   string_to_fp (f, s, MPFR_RNDN);
  98   print_fp (fout, f, ",\n");
  99   string_to_fp (f, s, MPFR_RNDZ);
 100   print_fp (fout, f, ",\n");
 101   string_to_fp (f, s, MPFR_RNDU);
 102   print_fp (fout, f, "");
 103   mpfr_clear (f);
 104 }
 105
 106 static void
 107 round_for_all (FILE *fout, const char *s)
 108 {
 109   static const struct fmt {
 110     int prec;
 111     int emin;
 112     int emax;
 113     bool ibm_ld;
 114   } formats[] = {
 115     { 24, -148, 128, false },
 116     { 53, -1073, 1024, false },
 117     /* This is the Intel extended float format.  */
 118     { 64, -16444, 16384, false },
 119     /* This is the Motorola extended float format.  */
 120     { 64, -16445, 16384, false },
 121     { 106, -1073, 1024, true },
 122     { 113, -16493, 16384, false },
 123   };
 124   mpfr_fprintf (fout, "  TEST (\"");
 125   const char *p;
 126   for (p = s; *p; p++)
 127     {
 128       fputc (*p, fout);
 129       if ((p - s) % 60 == 59 && p[1])
 130         mpfr_fprintf (fout, "\"\n\t\"");
 131     }
 132   mpfr_fprintf (fout, "\",\n");
 133   int i;
 134   int n_formats = sizeof (formats) / sizeof (formats[0]);
 135   for (i = 0; i < n_formats; i++)
 136     {
 137       round_str (fout, s, formats[i].prec, formats[i].emin,
 138                  formats[i].emax, formats[i].ibm_ld);
 139       if (i < n_formats - 1)
 140         mpfr_fprintf (fout, ",\n");
 141     }
 142   mpfr_fprintf (fout, "),\n");
 143 }
 144
 145 int
 146 main (int argc, char **argv)
 147 {
 148   char *p = NULL;
 149   size_t len;
 150   ssize_t nbytes;
 151   FILE *fin, *fout;
 152   char *fin_name, *fout_name;
 153
 154   if (argc < 3)
 155     {
 156       fprintf (stderr, "Usage: %s <input> <output>\n", basename (argv[0]));
 157       return EXIT_FAILURE;
 158     }
 159
 160   fin_name = argv[1];
 161   fout_name = argv[2];
 162
 163   fin = fopen (fin_name, "r");
 164   if (fin == NULL)
 165     {
 166       perror ("Could not open input for reading");
 167       return EXIT_FAILURE;
 168     }
 169
 170   fout = fopen (fout_name, "w");
 171   if (fout == NULL)
 172     {
 173       perror ("Could not open output for writing");
 174       return EXIT_FAILURE;
 175     }
 176
 177   fprintf (fout, "/* This file was generated by %s from %s.  */\n",
 178           __FILE__, fin_name);
 179   fputs ("static const struct test tests[] = {\n", fout);
 180   while ((nbytes = getline (&p, &len, fin)) != -1)
 181     {
 182       if (p[nbytes - 1] == '\n')
 183         p[nbytes - 1] = 0;
 184       round_for_all (fout, p);
 185       free (p);
 186       p = NULL;
 187     }
 188   fputs ("};\n", fout);
 189
 190   return EXIT_SUCCESS;
 191 }