/* read_data,c -- Read data file and check function.

Copyright (C) 2008, 2009, 2010, 2011, 2012 INRIA

This file is part of GNU MPC.

GNU MPC 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 3 of the License, or (at your

option) any later version.

GNU MPC 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 this program. If not, see http://www.gnu.org/licenses/ .

*/

#include <stdlib.h>

#include <string.h>

#include "mpc-tests.h"

char *pathname;

unsigned long line_number;

   /* file name with complete path and currently read line;

      kept globally to simplify parameter passing */

unsigned long test_line_number;

   /* start line of data test (which may extend over several lines) */

int nextchar;

   /* character appearing next in the file, may be EOF */

#define MPC_INEX_CMP(r, i, c)                                 \

  (((r) == TERNARY_NOT_CHECKED || (r) == MPC_INEX_RE(c))      \

   && ((i) == TERNARY_NOT_CHECKED || (i) == MPC_INEX_IM (c)))

#define MPFR_INEX_STR(inex)                     \

  (inex) == TERNARY_NOT_CHECKED ? "?"           \

    : (inex) == +1 ? "+1"                       \

    : (inex) == -1 ? "-1" : "0"

static const char *mpfr_rnd_mode [] =

  { "GMP_RNDN", "GMP_RNDZ", "GMP_RNDU", "GMP_RNDD" };

const char *rnd_mode[] =

  { "MPC_RNDNN", "MPC_RNDZN", "MPC_RNDUN", "MPC_RNDDN",

    "undefined", "undefined", "undefined", "undefined", "undefined",

    "undefined", "undefined", "undefined", "undefined", "undefined",

    "undefined", "undefined",

    "MPC_RNDNZ", "MPC_RNDZZ", "MPC_RNDUZ", "MPC_RNDDZ",

    "undefined", "undefined", "undefined", "undefined", "undefined",

    "undefined", "undefined", "undefined", "undefined", "undefined",

    "undefined", "undefined",

    "MPC_RNDNU", "MPC_RNDZU", "MPC_RNDUU", "MPC_RNDDU",

    "undefined", "undefined", "undefined", "undefined", "undefined",

    "undefined", "undefined", "undefined", "undefined", "undefined",

    "undefined", "undefined",

    "MPC_RNDND", "MPC_RNDZD", "MPC_RNDUD", "MPC_RNDDD",

    "undefined", "undefined", "undefined", "undefined", "undefined",

    "undefined", "undefined", "undefined", "undefined", "undefined",

    "undefined", "undefined",

  };

/* file functions */

FILE *

open_data_file (const char *file_name)

{

  FILE *fp;

  char *src_dir;

  char default_srcdir[] = ".";

  src_dir = getenv ("srcdir");

  if (src_dir == NULL)

    src_dir = default_srcdir;

  pathname = (char *) malloc ((strlen (src_dir)) + strlen (file_name) + 2);

  if (pathname == NULL)

    {

      printf ("Cannot allocate memory\n");

      exit (1);

    }

  sprintf (pathname, "%s/%s", src_dir, file_name);

  fp = fopen (pathname, "r");

  if (fp == NULL)

    {

      fprintf (stderr, "Unable to open %s\n", pathname);

      exit (1);

    }

  return fp;

}

void

close_data_file (FILE *fp)

{

  free (pathname);

  fclose (fp);

}

/* read primitives */

static void

skip_line (FILE *fp)

   /* skips characters until reaching '\n' or EOF; */

   /* '\n' is skipped as well                      */

{

   while (nextchar != EOF && nextchar != '\n')

     nextchar = getc (fp);

   if (nextchar != EOF)

     {

       line_number ++;

       nextchar = getc (fp);

     }

}

static void

skip_whitespace (FILE *fp)

   /* skips over whitespace if any until reaching EOF */

   /* or non-whitespace                               */

{

   while (isspace (nextchar))

     {

       if (nextchar == '\n')

         line_number ++;

       nextchar = getc (fp);

     }

}

void

skip_whitespace_comments (FILE *fp)

   /* skips over all whitespace and comments, if any */

{

   skip_whitespace (fp);

   while (nextchar == '#') {

      skip_line (fp);

      if (nextchar != EOF)

         skip_whitespace (fp);

   }

}

size_t

read_string (FILE *fp, char **buffer_ptr, size_t buffer_length, const char *name)

{

  size_t pos;

  char *buffer;

  pos = 0;

  buffer = *buffer_ptr;

  if (nextchar == '"')

    nextchar = getc (fp);

  else

    goto error;

  while (nextchar != EOF && nextchar != '"')

    {

      if (nextchar == '\n')

        line_number ++;

      if (pos + 1 > buffer_length)

        {

          buffer = (char *) realloc (buffer, 2 * buffer_length);

          if (buffer == NULL)

            {

              printf ("Cannot allocate memory\n");

              exit (1);

            }

          buffer_length *= 2;

        }

      buffer[pos++] = (char) nextchar;

      nextchar = getc (fp);

    }

  if (nextchar != '"')

    goto error;

  if (pos + 1 > buffer_length)

    {

      buffer = (char *) realloc (buffer, buffer_length + 1);

      if (buffer == NULL)

        {

          printf ("Cannot allocate memory\n");

          exit (1);

        }

      buffer_length *= 2;

    }

  buffer[pos] = '\0';

  nextchar = getc (fp);

  skip_whitespace_comments (fp);

  *buffer_ptr = buffer;

  return buffer_length;

 error:

  printf ("Error: Unable to read %s in file '%s' line '%lu'\n",

          name, pathname, line_number);

  exit (1);

}

/* All following read routines skip over whitespace and comments; */

/* so after calling them, nextchar is either EOF or the beginning */

/* of a non-comment token.                                        */

void

read_ternary (FILE *fp, int* ternary)

{

  switch (nextchar)

    {

    case '!':

      *ternary = TERNARY_ERROR;

      break;

    case '?':

      *ternary = TERNARY_NOT_CHECKED;

      break;

    case '+':

      *ternary = +1;

      break;

    case '0':

      *ternary = 0;

      break;

    case '-':

      *ternary = -1;

      break;

    default:

      printf ("Error: Unexpected ternary value '%c' in file '%s' line %lu\n",

              nextchar, pathname, line_number);

      exit (1);

    }

  nextchar = getc (fp);

  skip_whitespace_comments (fp);

}

void

read_mpfr_rounding_mode (FILE *fp, mpfr_rnd_t* rnd)

{

  switch (nextchar)

    {

    case 'n': case 'N':

      *rnd = GMP_RNDN;

      break;

    case 'z': case 'Z':

      *rnd = GMP_RNDZ;

      break;

    case 'u': case 'U':

      *rnd = GMP_RNDU;

      break;

    case 'd': case 'D':

      *rnd = GMP_RNDD;

      break;

    default:

      printf ("Error: Unexpected rounding mode '%c' in file '%s' line %lu\n",

              nextchar, pathname, line_number);

      exit (1);

    }

    nextchar = getc (fp);

    if (nextchar != EOF && !isspace (nextchar)) {

      printf ("Error: Rounding mode not followed by white space in file "

              "'%s' line %lu\n",

              pathname, line_number);

      exit (1);

    }

    skip_whitespace_comments (fp);

}

void

read_mpc_rounding_mode (FILE *fp, mpc_rnd_t* rnd)

{

   mpfr_rnd_t re, im;

   read_mpfr_rounding_mode (fp, &re);

   read_mpfr_rounding_mode (fp, &im);

   *rnd = MPC_RND (re, im);

}

void

read_int (FILE *fp, int *nread, const char *name)

{

  int n = 0;

  if (nextchar == EOF)

    {

      printf ("Error: Unexpected EOF when reading int "

              "in file '%s' line %lu\n",

              pathname, line_number);

      exit (1);

    }

  ungetc (nextchar, fp);

  n = fscanf (fp, "%i", nread);

  if (ferror (fp) || n == 0 || n == EOF)

    {

      printf ("Error: Cannot read %s in file '%s' line %lu\n",

              name, pathname, line_number);

      exit (1);

    }

  nextchar = getc (fp);

  skip_whitespace_comments (fp);

}

static void

read_uint (FILE *fp, unsigned long int *ui)

{

  int n = 0;

  if (nextchar == EOF)

    {

      printf ("Error: Unexpected EOF when reading uint "

              "in file '%s' line %lu\n",

              pathname, line_number);

      exit (1);

    }

  ungetc (nextchar, fp);

  n = fscanf (fp, "%lu", ui);

  if (ferror (fp) || n == 0 || n == EOF)

    {

      printf ("Error: Cannot read uint in file '%s' line %lu\n",

              pathname, line_number);

      exit (1);

    }

  nextchar = getc (fp);

  skip_whitespace_comments (fp);

}

static void

read_sint (FILE *fp, long int *si)

{

  int n = 0;

  if (nextchar == EOF)

    {

      printf ("Error: Unexpected EOF when reading sint "

              "in file '%s' line %lu\n",

              pathname, line_number);

      exit (1);

    }

  ungetc (nextchar, fp);

  n = fscanf (fp, "%li", si);

  if (ferror (fp) || n == 0 || n == EOF)

    {

      printf ("Error: Cannot read sint in file '%s' line %lu\n",

              pathname, line_number);

      exit (1);

    }

  nextchar = getc (fp);

  skip_whitespace_comments (fp);

}

mpfr_prec_t

read_mpfr_prec (FILE *fp)

{

   unsigned long prec;

   int n;

   if (nextchar == EOF) {

      printf ("Error: Unexpected EOF when reading mpfr precision "

              "in file '%s' line %lu\n",

              pathname, line_number);

      exit (1);

   }

   ungetc (nextchar, fp);

   n = fscanf (fp, "%lu", &prec);

   if (ferror (fp)) /* then also n == EOF */

      perror ("Error when reading mpfr precision");

   if (n == 0 || n == EOF || prec < MPFR_PREC_MIN || prec > MPFR_PREC_MAX) {

      printf ("Error: Impossible mpfr precision in file '%s' line %lu\n",

              pathname, line_number);

      exit (1);

   }

   nextchar = getc (fp);

   skip_whitespace_comments (fp);

   return (mpfr_prec_t) prec;

}

static void

read_mpfr_mantissa (FILE *fp, mpfr_ptr x)

{

   if (nextchar == EOF) {

      printf ("Error: Unexpected EOF when reading mpfr mantissa "

              "in file '%s' line %lu\n",

              pathname, line_number);

      exit (1);

   }

   ungetc (nextchar, fp);

   if (mpfr_inp_str (x, fp, 0, GMP_RNDN) == 0) {

      printf ("Error: Impossible to read mpfr mantissa "

              "in file '%s' line %lu\n",

              pathname, line_number);

      exit (1);

   }

   nextchar = getc (fp);

   skip_whitespace_comments (fp);

}

void

read_mpfr (FILE *fp, mpfr_ptr x, int *known_sign)

{

   int sign;

   mpfr_set_prec (x, read_mpfr_prec (fp));

   sign = nextchar;

   read_mpfr_mantissa (fp, x);

   /* the sign always matters for regular values ('+' is implicit),

      but when no sign appears before 0 or Inf in the data file, it means

      that only absolute value must be checked. */

   if (known_sign != NULL)

     *known_sign =

       (!mpfr_zero_p (x) && !mpfr_inf_p (x))

       || sign == '+' || sign == '-';

}

void

read_mpc (FILE *fp, mpc_ptr z, known_signs_t *ks)

{

  read_mpfr (fp, mpc_realref (z), ks == NULL ? NULL : &ks->re);

  read_mpfr (fp, mpc_imagref (z), ks == NULL ? NULL : &ks->im);

}

static void

check_compatible (int inex, mpfr_t expected, mpfr_rnd_t rnd, const char *s)

{

  if ((rnd == GMP_RNDU && inex == -1) ||

      (rnd == GMP_RNDD && inex == +1) ||

      (rnd == GMP_RNDZ && !mpfr_signbit (expected) && inex == +1) ||

      (rnd == GMP_RNDZ && mpfr_signbit (expected) && inex == -1))

    {

      if (s != NULL)

        printf ("Incompatible ternary value '%c' (%s part) in file '%s' line %lu\n",

              (inex == 1) ? '+' : '-', s, pathname, test_line_number);

      else

        printf ("Incompatible ternary value '%c' in file '%s' line %lu\n",

              (inex == 1) ? '+' : '-', pathname, test_line_number);

    }

}

/* read lines of data */

static void

read_cc (FILE *fp, int *inex_re, int *inex_im, mpc_ptr expected,

         known_signs_t *signs, mpc_ptr op, mpc_rnd_t *rnd)

{

  test_line_number = line_number;

  read_ternary (fp, inex_re);

  read_ternary (fp, inex_im);

  read_mpc (fp, expected, signs);

  read_mpc (fp, op, NULL);

  read_mpc_rounding_mode (fp, rnd);

  check_compatible (*inex_re, mpc_realref(expected), MPC_RND_RE(*rnd), "real");

  check_compatible (*inex_im, mpc_imagref(expected), MPC_RND_IM(*rnd), "imag");

}

static void

read_fc (FILE *fp, int *inex, mpfr_ptr expected, int *sign, mpc_ptr op,

         mpfr_rnd_t *rnd)

{

  test_line_number = line_number;

  read_ternary (fp, inex);

  read_mpfr (fp, expected, sign);

  read_mpc (fp, op, NULL);

  read_mpfr_rounding_mode (fp, rnd);

  check_compatible (*inex, expected, *rnd, NULL);

}

static void

read_ccc (FILE *fp, int *inex_re, int *inex_im, mpc_ptr expected,

          known_signs_t *signs, mpc_ptr op1, mpc_ptr op2, mpc_rnd_t *rnd)

{

  test_line_number = line_number;

  read_ternary (fp, inex_re);

  read_ternary (fp, inex_im);

  read_mpc (fp, expected, signs);

  read_mpc (fp, op1, NULL);

  read_mpc (fp, op2, NULL);

  read_mpc_rounding_mode (fp, rnd);

  check_compatible (*inex_re, mpc_realref(expected), MPC_RND_RE(*rnd), "real");

  check_compatible (*inex_im, mpc_imagref(expected), MPC_RND_IM(*rnd), "imag");

}

/* read lines of data for function with three mpc_t inputs and one mpc_t

   output like mpc_fma */

static void

read_cccc (FILE *fp, int *inex_re, int *inex_im, mpc_ptr expected,

	   known_signs_t *signs, mpc_ptr op1, mpc_ptr op2, mpc_ptr op3,

	   mpc_rnd_t *rnd)

{

  test_line_number = line_number;

  read_ternary (fp, inex_re);

  read_ternary (fp, inex_im);

  read_mpc (fp, expected, signs);

  read_mpc (fp, op1, NULL);

  read_mpc (fp, op2, NULL);

  read_mpc (fp, op3, NULL);

  read_mpc_rounding_mode (fp, rnd);

  check_compatible (*inex_re, mpc_realref(expected), MPC_RND_RE(*rnd), "real");

  check_compatible (*inex_im, mpc_imagref(expected), MPC_RND_IM(*rnd), "imag");

}

static void

read_cfc (FILE *fp, int *inex_re, int *inex_im, mpc_ptr expected,

          known_signs_t *signs, mpfr_ptr op1, mpc_ptr op2, mpc_rnd_t *rnd)

{

  test_line_number = line_number;

  read_ternary (fp, inex_re);

  read_ternary (fp, inex_im);

  read_mpc (fp, expected, signs);

  read_mpfr (fp, op1, NULL);

  read_mpc (fp, op2, NULL);

  read_mpc_rounding_mode (fp, rnd);

  check_compatible (*inex_re, mpc_realref(expected), MPC_RND_RE(*rnd), "real");

  check_compatible (*inex_im, mpc_imagref(expected), MPC_RND_IM(*rnd), "imag");

}

static void

read_ccf (FILE *fp, int *inex_re, int *inex_im, mpc_ptr expected,

          known_signs_t *signs, mpc_ptr op1, mpfr_ptr op2, mpc_rnd_t *rnd)

{

  test_line_number = line_number;

  read_ternary (fp, inex_re);

  read_ternary (fp, inex_im);

  read_mpc (fp, expected, signs);

  read_mpc (fp, op1, NULL);

  read_mpfr (fp, op2, NULL);

  read_mpc_rounding_mode (fp, rnd);

  check_compatible (*inex_re, mpc_realref(expected), MPC_RND_RE(*rnd), "real");

  check_compatible (*inex_im, mpc_imagref(expected), MPC_RND_IM(*rnd), "imag");

}

static void

read_ccu (FILE *fp, int *inex_re, int *inex_im, mpc_ptr expected,

          known_signs_t *signs, mpc_ptr op1, unsigned long int *op2, mpc_rnd_t *rnd)

{

  test_line_number = line_number;

  read_ternary (fp, inex_re);

  read_ternary (fp, inex_im);

  read_mpc (fp, expected, signs);

  read_mpc (fp, op1, NULL);

  read_uint (fp, op2);

  read_mpc_rounding_mode (fp, rnd);

  check_compatible (*inex_re, mpc_realref(expected), MPC_RND_RE(*rnd), "real");

  check_compatible (*inex_im, mpc_imagref(expected), MPC_RND_IM(*rnd), "imag");

}

static void

read_ccs (FILE *fp, int *inex_re, int *inex_im, mpc_ptr expected,

          known_signs_t *signs, mpc_ptr op1, long int *op2, mpc_rnd_t *rnd)

{

  test_line_number = line_number;

  read_ternary (fp, inex_re);

  read_ternary (fp, inex_im);

  read_mpc (fp, expected, signs);

  read_mpc (fp, op1, NULL);

  read_sint (fp, op2);

  read_mpc_rounding_mode (fp, rnd);

  check_compatible (*inex_re, mpc_realref(expected), MPC_RND_RE(*rnd), "real");

  check_compatible (*inex_im, mpc_imagref(expected), MPC_RND_IM(*rnd), "imag");

}

/* set MPFR flags to random values */

static void

set_mpfr_flags (int counter)

{

  if (counter & 1)

    mpfr_set_underflow ();

  else

    mpfr_clear_underflow ();

  if (counter & 2)

    mpfr_set_overflow ();

  else

    mpfr_clear_overflow ();

  /* the divide-by-0 flag was added in MPFR 3.1.0 */

#ifdef mpfr_set_divby0

  if (counter & 4)

    mpfr_set_divby0 ();

  else

    mpfr_clear_divby0 ();

#endif

  if (counter & 8)

    mpfr_set_nanflag ();

  else

    mpfr_clear_nanflag ();

  if (counter & 16)

    mpfr_set_inexflag ();

  else

    mpfr_clear_inexflag ();

  if (counter & 32)

    mpfr_set_erangeflag ();

  else

    mpfr_clear_erangeflag ();

}

/* Check MPFR flags: we allow that some flags are set internally by MPC,

   for example if MPC does internal computations (using MPFR) which yield

   an overflow, even if the final MPC result fits in the exponent range.

   However we don't allow MPC to *clear* the MPFR flags */

static void

check_mpfr_flags (int counter)

{

  int old, neu;

  old = (counter & 1) != 0;

  neu = mpfr_underflow_p () != 0;

  if (old && (neu == 0))

    {

      printf ("Error, underflow flag has been modified from %d to %d\n",

              old, neu);

      exit (1);

    }

  old = (counter & 2) != 0;

  neu = mpfr_overflow_p () != 0;

  if (old && (neu == 0))

    {

      printf ("Error, overflow flag has been modified from %d to %d\n",

              old, neu);

      exit (1);

    }

#ifdef mpfr_divby0_p

  old = (counter & 4) != 0;

  neu = mpfr_divby0_p () != 0;

  if (old && (neu == 0))

    {

      printf ("Error, divby0 flag has been modified from %d to %d\n",

              old, neu);

      exit (1);

    }

#endif

  old = (counter & 8) != 0;

  neu = mpfr_nanflag_p () != 0;

  if (old && (neu == 0))

    {

      printf ("Error, nanflag flag has been modified from %d to %d\n",

              old, neu);

      exit (1);

    }

  old = (counter & 16) != 0;

  neu = mpfr_inexflag_p () != 0;

  if (old && (neu == 0))

    {

      printf ("Error, inexflag flag has been modified from %d to %d\n",

              old, neu);

      exit (1);

    }

  old = (counter & 32) != 0;

  neu = mpfr_erangeflag_p () != 0;

  if (old && (neu == 0))

    {

      printf ("Error, erangeflag flag has been modified from %d to %d\n",

              old, neu);

      exit (1);

    }

}

/* data_check (function, data_file_name) checks function results against

 precomputed data in a file.*/

void

data_check (mpc_function function, const char *file_name)

{

  FILE *fp;

  int inex_re;

  mpfr_t x1, x2;

  mpfr_rnd_t mpfr_rnd = GMP_RNDN;

  int sign_real;

  int inex_im;

  mpc_t z1, z2, z3, z4, z5;

  mpc_rnd_t rnd = MPC_RNDNN;

  unsigned long int ui;

  long int si;

  known_signs_t signs;

  int inex = 0;

  static int rand_counter = 0;

  fp = open_data_file (file_name);

  /* 1. init needed variables */

  mpc_init2 (z1, 2);

  switch (function.type)

    {

    case FC:

      mpfr_init (x1);

      mpfr_init (x2);

      break;

    case CC: case CCU: case CCS:

      mpc_init2 (z2, 2);

      mpc_init2 (z3, 2);

      break;

    case C_CC:

      mpc_init2 (z2, 2);

      mpc_init2 (z3, 2);

      mpc_init2 (z4, 2);

      break;

    case CCCC:

      mpc_init2 (z2, 2);

      mpc_init2 (z3, 2);

      mpc_init2 (z4, 2);

      mpc_init2 (z5, 2);

      break;

    case CFC: case CCF:

      mpfr_init (x1);

      mpc_init2 (z2, 2);

      mpc_init2 (z3, 2);

      break;

    default:

      ;

    }

  /* 2. read data file */

  line_number = 1;

  nextchar = getc (fp);

  skip_whitespace_comments (fp);

  while (nextchar != EOF) {

      set_mpfr_flags (rand_counter);

      /* for each kind of function prototype: */

      /* 3.1 read a line of data: expected result, parameters, rounding mode */

      /* 3.2 compute function at the same precision as the expected result */

      /* 3.3 compare this result with the expected one */

      switch (function.type)

        {

        case FC: /* example mpc_norm */

          read_fc (fp, &inex_re, x1, &sign_real, z1, &mpfr_rnd);

          mpfr_set_prec (x2, mpfr_get_prec (x1));

          inex = function.pointer.FC (x2, z1, mpfr_rnd);

          if ((inex_re != TERNARY_NOT_CHECKED && inex_re != inex)

              || !same_mpfr_value (x1, x2, sign_real))

            {

              mpfr_t got, expected;

              mpc_t op;

              op[0] = z1[0];

              got[0] = x2[0];

              expected[0] = x1[0];

              printf ("%s(op) failed (%s:%lu)\nwith rounding mode %s\n",

                      function.name, file_name, test_line_number,

                      mpfr_rnd_mode[mpfr_rnd]);

              if (inex_re != TERNARY_NOT_CHECKED && inex_re != inex)

                printf("ternary value: got %s, expected %s\n",

                       MPFR_INEX_STR (inex), MPFR_INEX_STR (inex_re));

              MPC_OUT (op);

              printf ("     ");

              MPFR_OUT (got);

              MPFR_OUT (expected);

              exit (1);

            }

          break;

        case CC: /* example mpc_log */

          read_cc (fp, &inex_re, &inex_im, z1, &signs, z2, &rnd;;

          mpfr_set_prec (mpc_realref (z3), MPC_PREC_RE (z1));

          mpfr_set_prec (mpc_imagref (z3), MPC_PREC_IM (z1));

          inex = function.pointer.CC (z3, z2, rnd);

          if (!MPC_INEX_CMP (inex_re, inex_im, inex)

              || !same_mpc_value (z3, z1, signs))

            {

              mpc_t op, got, expected; /* display sensible variable names */

              op[0] = z2[0];

              expected[0]= z1[0];

              got[0] = z3[0];

              printf ("%s(op) failed (line %lu)\nwith rounding mode %s\n",

                      function.name, test_line_number, rnd_mode[rnd]);

              if (!MPC_INEX_CMP (inex_re, inex_im, inex))

                printf("ternary value: got %s, expected (%s, %s)\n",

                       MPC_INEX_STR (inex),

                       MPFR_INEX_STR (inex_re), MPFR_INEX_STR (inex_im));

              MPC_OUT (op);

              printf ("     ");

              MPC_OUT (got);

              MPC_OUT (expected);

              exit (1);

            }

          break;

        case C_CC: /* example mpc_mul */

          read_ccc (fp, &inex_re, &inex_im, z1, &signs, z2, z3, &rnd;;

          mpfr_set_prec (mpc_realref(z4), MPC_PREC_RE (z1));

          mpfr_set_prec (mpc_imagref(z4), MPC_PREC_IM (z1));

          inex = function.pointer.C_CC (z4, z2, z3, rnd);

          if (!MPC_INEX_CMP (inex_re, inex_im, inex)

              || !same_mpc_value (z4, z1, signs))

            {

              /* display sensible variable names */

              mpc_t op1, op2, got, expected;

              op1[0] = z2[0];

              op2[0] = z3[0];

              expected[0]= z1[0];

              got[0] = z4[0];

              printf ("%s(op) failed (line %lu)\nwith rounding mode %s\n",

                      function.name, test_line_number, rnd_mode[rnd]);

              if (!MPC_INEX_CMP (inex_re, inex_im, inex))

                printf("ternary value: got %s, expected (%s, %s)\n",

                       MPC_INEX_STR (inex),

                       MPFR_INEX_STR (inex_re), MPFR_INEX_STR (inex_im));

              MPC_OUT (op1);

              MPC_OUT (op2);

              printf ("     ");

              MPC_OUT (got);

              MPC_OUT (expected);

              exit (1);

            }

          if (function.properties & FUNC_PROP_SYMETRIC)

            {

              inex = function.pointer.C_CC (z4, z3, z2, rnd);

              if (!MPC_INEX_CMP (inex_re, inex_im, inex)

              || !same_mpc_value (z4, z1, signs))

                {

                  /* display sensible variable names */

                  mpc_t op1, op2, got, expected;

                  op1[0] = z3[0];

                  op2[0] = z2[0];

                  expected[0]= z1[0];

                  got[0] = z4[0];

                  printf ("%s(op) failed (line %lu/symetric test)\n"

                          "with rounding mode %s\n",

                          function.name, test_line_number, rnd_mode[rnd]);

                  if (!MPC_INEX_CMP (inex_re, inex_im, inex))

                    printf("ternary value: got %s, expected (%s, %s)\n",

                           MPC_INEX_STR (inex),

                           MPFR_INEX_STR (inex_re), MPFR_INEX_STR (inex_im));

                  MPC_OUT (op1);

                  MPC_OUT (op2);

                  printf ("     ");

                  MPC_OUT (got);

                  MPC_OUT (expected);

                  exit (1);

                }

            }

          break;

        case CCCC: /* example mpc_fma */

          read_cccc (fp, &inex_re, &inex_im, z1, &signs, z2, z3, z4, &rnd;;

	  /* z1 is the expected value, z2, z3, z4 are the inputs, and z5 is

	     the computed value */

          mpfr_set_prec (mpc_realref(z5), MPC_PREC_RE (z1));

          mpfr_set_prec (mpc_imagref(z5), MPC_PREC_IM (z1));

          inex = function.pointer.CCCC (z5, z2, z3, z4, rnd);

          if (!MPC_INEX_CMP (inex_re, inex_im, inex)

              || !same_mpc_value (z5, z1, signs))

            {

              /* display sensible variable names */

              mpc_t op1, op2, op3, got, expected;

              op1[0] = z2[0];

              op2[0] = z3[0];

              op3[0] = z4[0];

              expected[0]= z1[0];

              got[0] = z5[0];

              printf ("%s(op) failed (line %lu)\nwith rounding mode %s\n",

                      function.name, test_line_number, rnd_mode[rnd]);

              if (!MPC_INEX_CMP (inex_re, inex_im, inex))

                printf("ternary value: got %s, expected (%s, %s)\n",

                       MPC_INEX_STR (inex),

                       MPFR_INEX_STR (inex_re), MPFR_INEX_STR (inex_im));

              MPC_OUT (op1);

              MPC_OUT (op2);

              MPC_OUT (op3);

              printf ("     ");

              MPC_OUT (got);

              MPC_OUT (expected);

              exit (1);

            }

          if (function.properties & FUNC_PROP_SYMETRIC)

            {

              inex = function.pointer.CCCC (z5, z3, z2, z4, rnd);

              if (!MPC_INEX_CMP (inex_re, inex_im, inex)

              || !same_mpc_value (z5, z1, signs))

                {

                  /* display sensible variable names */

                  mpc_t op1, op2, op3, got, expected;

                  op1[0] = z3[0];

                  op2[0] = z2[0];

		  op3[0] = z4[0];

                  expected[0]= z1[0];

                  got[0] = z5[0];

                  printf ("%s(op) failed (line %lu/symetric test)\n"

                          "with rounding mode %s\n",