glibc/stdlib/gen-tst-strtod-round.c

/* Generate table of tests in tst-strtod-round.c from
   tst-strtod-round-data.
   Copyright (C) 2012-2018 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <http://www.gnu.org/licenses/>.  */

/* Compile this program as:

   gcc -std=gnu11 -O2 -Wall -Wextra gen-tst-strtod-round.c -lmpfr \
     -o gen-tst-strtod-round

   (use of current MPFR version recommended) and run it as:

   gen-tst-strtod-round tst-strtod-round-data tst-strtod-round-data.h

   The output file will be generated as tst-strtod-round-data.h
*/


#define _GNU_SOURCE
#include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <mpfr.h>

/* Work around incorrect ternary value from mpfr_strtofr
   <https://sympa.inria.fr/sympa/arc/mpfr/2012-08/msg00005.html>.  */
#define WORKAROUND

static int
string_to_fp (mpfr_t f, const char *s, mpfr_rnd_t rnd)
{
  mpfr_clear_overflow ();
#ifdef WORKAROUND
  mpfr_t f2;
  mpfr_init2 (f2, 100000);
  int r0 = mpfr_strtofr (f2, s, NULL, 0, rnd);
  int r = mpfr_set (f, f2, rnd);
  r |= mpfr_subnormalize (f, r, rnd);
  mpfr_clear (f2);
  return r0 | r;
#else
  int r = mpfr_strtofr (f, s, NULL, 0, rnd);
  r |= mpfr_subnormalize (f, r, rnd);
  return r;
#endif
}

void
print_fp (FILE *fout, mpfr_t f, const char *suffix)
{
  if (mpfr_inf_p (f))
    mpfr_fprintf (fout, "\t%sINF%s", mpfr_signbit (f) ? "-" : "", suffix);
  else
    mpfr_fprintf (fout, "\t%Ra%s", f, suffix);
}

static void
round_str (FILE *fout, const char *s, int prec, int emin, int emax,
	   bool ibm_ld)
{
  mpfr_t max_value;
  mpfr_t f;
  mpfr_set_default_prec (prec);
  mpfr_set_emin (emin);
  mpfr_set_emax (emax);
  mpfr_init (f);
  int r = string_to_fp (f, s, MPFR_RNDD);
  bool overflow = mpfr_overflow_p () != 0;
  if (ibm_ld)
    {
      assert (prec == 106 && emin == -1073 && emax == 1024);
      /* The maximum value in IBM long double has discontiguous
	 mantissa bits.  */
      mpfr_init2 (max_value, 107);
      mpfr_set_str (max_value, "0x1.fffffffffffff7ffffffffffffcp+1023", 0,
		    MPFR_RNDN);
      if (mpfr_cmpabs (f, max_value) > 0)
	{
	  r = 1;
	  overflow = true;
	}
    }
  mpfr_fprintf (fout, "\t%s,\n", r ? "false" : "true");
  print_fp (fout, f, overflow ? ", true,\n" : ", false,\n");
  string_to_fp (f, s, MPFR_RNDN);
  overflow = (mpfr_overflow_p () != 0
	      || (ibm_ld && mpfr_cmpabs (f, max_value) > 0));
  print_fp (fout, f, overflow ? ", true,\n" : ", false,\n");
  string_to_fp (f, s, MPFR_RNDZ);
  overflow = (mpfr_overflow_p () != 0
	      || (ibm_ld && mpfr_cmpabs (f, max_value) > 0));
  print_fp (fout, f, overflow ? ", true,\n" : ", false,\n");
  string_to_fp (f, s, MPFR_RNDU);
  overflow = (mpfr_overflow_p () != 0
	      || (ibm_ld && mpfr_cmpabs (f, max_value) > 0));
  print_fp (fout, f, overflow ? ", true" : ", false");
  mpfr_clear (f);
  if (ibm_ld)
    mpfr_clear (max_value);
}

static void
round_for_all (FILE *fout, const char *s)
{
  static const struct fmt {
    int prec;
    int emin;
    int emax;
    bool ibm_ld;
  } formats[] = {
    { 24, -148, 128, false },
    { 53, -1073, 1024, false },
    /* This is the Intel extended float format.  */
    { 64, -16444, 16384, false },
    /* This is the Motorola extended float format.  */
    { 64, -16445, 16384, false },
    { 106, -1073, 1024, true },
    { 113, -16493, 16384, false },
  };
  mpfr_fprintf (fout, "  TEST (\"");
  const char *p;
  for (p = s; *p; p++)
    {
      fputc (*p, fout);
      if ((p - s) % 60 == 59 && p[1])
	mpfr_fprintf (fout, "\"\n\t\"");
    }
  mpfr_fprintf (fout, "\",\n");
  int i;
  int n_formats = sizeof (formats) / sizeof (formats[0]);
  for (i = 0; i < n_formats; i++)
    {
      round_str (fout, s, formats[i].prec, formats[i].emin,
		 formats[i].emax, formats[i].ibm_ld);
      if (i < n_formats - 1)
	mpfr_fprintf (fout, ",\n");
    }
  mpfr_fprintf (fout, "),\n");
}

int
main (int argc, char **argv)
{
  char *p = NULL;
  size_t len;
  ssize_t nbytes;
  FILE *fin, *fout;
  char *fin_name, *fout_name;

  if (argc < 3)
    {
      fprintf (stderr, "Usage: %s <input> <output>\n", basename (argv[0]));
      return EXIT_FAILURE;
    }

  fin_name = argv[1];
  fout_name = argv[2];

  fin = fopen (fin_name, "r");
  if (fin == NULL)
    {
      perror ("Could not open input for reading");
      return EXIT_FAILURE;
    }

  fout = fopen (fout_name, "w");
  if (fout == NULL)
    {
      perror ("Could not open output for writing");
      return EXIT_FAILURE;
    }

  fprintf (fout, "/* This file was generated by %s from %s.  */\n",
	  __FILE__, fin_name);
  fputs ("static const struct test tests[] = {\n", fout);
  while ((nbytes = getline (&p, &len, fin)) != -1)
    {
      if (p[nbytes - 1] == '\n')
	p[nbytes - 1] = 0;
      round_for_all (fout, p);
      free (p);
      p = NULL;
    }
  fputs ("};\n", fout);

  return EXIT_SUCCESS;
}