/* mpf_set_str (dest, string, base) -- Convert the string STRING
   in base BASE to a float in dest.  If BASE is zero, the leading characters
   of STRING is used to figure out the base.

Copyright 1993, 1994, 1995, 1996, 1997, 2000, 2001 Free Software Foundation,
Inc.

This file is part of the GNU MP Library.

The GNU MP 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 MP 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 MP Library; see the file COPYING.LIB.  If not, write to
the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
MA 02111-1307, USA. */

#include "config.h"

#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#if HAVE_LOCALE_H
#include <locale.h>    /* for localeconv */
#endif

#include "gmp.h"
#include "gmp-impl.h"
#include "longlong.h"

static int
digit_value_in_base (int c, int base)
{
  int digit;

  if (isdigit (c))
    digit = c - '0';
  else if (islower (c))
    digit = c - 'a' + 10;
  else if (isupper (c))
    digit = c - 'A' + 10;
  else
    return -1;

  if (digit < base)
    return digit;
  return -1;
}

#if HAVE_LOCALECONV
/* Avoid memcmp for the usual case that point is one character.  Don't
   bother with str+1,point+1,pointlen-1 since those offsets would add to the
   code size.  */
#define POINTCMP_FAST(c, str)                                           \
  ((c) == point0                                                        \
   && (pointlen == 1 || memcmp (str, point, pointlen) == 0))
#define POINTCMP_SMALL(c, str)   (memcmp (str, point, pointlen) == 0)
#define POINTLEN                 (pointlen)
#else
#define POINTCMP_FAST(c, str)    ((c) == '.')
#define POINTCMP_SMALL(c, str)   ((c) == '.')
#define POINTLEN                 1
#endif

int
mpf_set_str (mpf_ptr x, const char *str, int base)
{
  size_t str_size;
  char *s, *begs;
  size_t i;
  mp_size_t xsize;
  int c;
  int negative;
  char *dotpos = 0;
  int expflag;
  int decimal_exponent_flag;
#if HAVE_LOCALECONV
  const char  *point = localeconv()->decimal_point;
  size_t      pointlen = strlen (point);
  int         point0 = point[0];
#endif
  TMP_DECL (marker);

  TMP_MARK (marker);

  c = *str;

  /* Skip whitespace.  */
  while (isspace (c))
    c = *++str;

  negative = 0;
  if (c == '-')
    {
      negative = 1;
      c = *++str;
    }

  decimal_exponent_flag = base < 0;
  base = ABS (base);

  /* require at least one digit, possibly after an initial decimal point */
  if (digit_value_in_base (c, base == 0 ? 10 : base) < 0)
    {
      if (! POINTCMP_SMALL (c, str))
        return -1;
      if (digit_value_in_base (str[POINTLEN], base == 0 ? 10 : base) < 0)
        return -1;
    }

  /* If BASE is 0, try to find out the base by looking at the initial
     characters.  */
  if (base == 0)
    {
      base = 10;
#if 0
      if (c == '0')
	{
	  base = 8;
	  if (str[1] == 'x' || str[1] == 'X')
	    {
	      base = 16;
	      str += 2;
	      c = *str;
	    }
	}
#endif
    }

  expflag = 0;
  str_size = strlen (str);
  for (i = 0; i < str_size; i++)
    {
      c = str[i];
      if (c == '@' || (base <= 10 && (c == 'e' || c == 'E')))
	{
	  expflag = 1;
	  str_size = i;
	  break;
	}

    }

  s = begs = (char *) TMP_ALLOC (str_size + 1);

  for (i = 0; i < str_size; i++)
    {
      c = *str;
      if (!isspace (c))
	{
	  int dig;

	  if (POINTCMP_FAST (c, str))
            {
	      if (dotpos != 0)
		{
		  TMP_FREE (marker);
		  return -1;
		}
	      dotpos = s;
              str += POINTLEN - 1;
              i += POINTLEN - 1;
	    }
	  else
	    {
	      dig = digit_value_in_base (c, base);
	      if (dig < 0)
		{
		  TMP_FREE (marker);
		  return -1;
		}
	      *s++ = dig;
	    }
	}
      c = *++str;
    }

  str_size = s - begs;

  xsize = str_size / __mp_bases[base].chars_per_limb + 2;
  {
    long exp_in_base;
    mp_size_t ralloc, rsize, msize;
    int cnt, i;
    mp_ptr mp, tp, rp;
    mp_exp_t exp_in_limbs;
    mp_size_t prec = x->_mp_prec + 1;
    int divflag;
    mp_size_t madj, radj;

    mp = (mp_ptr) TMP_ALLOC (xsize * BYTES_PER_MP_LIMB);
    msize = mpn_set_str (mp, (unsigned char *) begs, str_size, base);

    if (msize == 0)
      {
	x->_mp_size = 0;
	x->_mp_exp = 0;
	TMP_FREE (marker);
	return 0;
      }

    madj = 0;
    /* Ignore excess limbs in MP,MSIZE.  */
    if (msize > prec)
      {
	madj = msize - prec;
	mp += msize - prec;
	msize = prec;
      }

    if (expflag != 0)
      exp_in_base = strtol (str + 1, (char **) 0,
			    decimal_exponent_flag ? 10 : base);
    else
      exp_in_base = 0;
    if (dotpos != 0)
      exp_in_base -= s - dotpos;
    divflag = exp_in_base < 0;
    exp_in_base = ABS (exp_in_base);

    if (exp_in_base == 0)
      {
	MPN_COPY (x->_mp_d, mp, msize);
	x->_mp_size = negative ? -msize : msize;
	x->_mp_exp = msize + madj;
	TMP_FREE (marker);
	return 0;
      }

    radj = 0;			/* counts number of ignored low limbs in r */

    ralloc = 2 * (prec + 1);
    rp = (mp_ptr) TMP_ALLOC (ralloc * BYTES_PER_MP_LIMB);
    tp = (mp_ptr) TMP_ALLOC (ralloc * BYTES_PER_MP_LIMB);

    rp[0] = base;
    rsize = 1;
    count_leading_zeros (cnt, exp_in_base);
    for (i = BITS_PER_MP_LIMB - cnt - 2; i >= 0; i--)
      {
	mpn_sqr_n (tp, rp, rsize);
	rsize = 2 * rsize;
	rsize -= tp[rsize - 1] == 0;
	radj <<= 1;

	if (rsize > prec)
	  {
	    radj += rsize - prec;
	    MPN_COPY_INCR (rp, tp + rsize - prec, prec);
	    rsize = prec;
	  }
	else
	  MP_PTR_SWAP (rp, tp);

	if (((exp_in_base >> i) & 1) != 0)
	  {
	    mp_limb_t cy;
	    cy = mpn_mul_1 (rp, rp, rsize, (mp_limb_t) base);
	    rp[rsize] = cy;
	    rsize += cy != 0;
	  }
      }

    if (rsize > prec)
      {
	radj += rsize - prec;
	rp += rsize - prec;
	rsize = prec;
      }

    if (divflag)
      {
	mp_ptr qp;
	mp_limb_t qlimb;
	if (msize < rsize)
	  {
	    /* Pad out MP,MSIZE for current divrem semantics.  */
	    mp_ptr tmp = (mp_ptr) TMP_ALLOC ((rsize + 1) * BYTES_PER_MP_LIMB);
	    MPN_ZERO (tmp, rsize - msize);
	    MPN_COPY (tmp + rsize - msize, mp, msize);
	    mp = tmp;
	    madj -= rsize - msize;
	    msize = rsize;
	  }
	if (! (rp[rsize-1] & MP_LIMB_T_HIGHBIT))
	  {
	    mp_limb_t cy;
            count_leading_zeros (cnt, rp[rsize - 1]);
	    mpn_lshift (rp, rp, rsize, cnt);
	    cy = mpn_lshift (mp, mp, msize, cnt);
	    if (cy)
	      mp[msize++] = cy;
	  }

	qp = (mp_ptr) TMP_ALLOC ((prec + 1) * BYTES_PER_MP_LIMB);
	qlimb = mpn_divrem (qp, prec - (msize - rsize), mp, msize, rp, rsize);
	tp = qp;
	exp_in_limbs = qlimb + (msize - rsize) + (madj - radj);
	rsize = prec;
	if (qlimb != 0)
	  {
	    tp[prec] = qlimb;
	    /* Skip the least significant limb not to overrun the destination
	       variable.  */
	    tp++;
	  }
      }
    else
      {
	tp = (mp_ptr) TMP_ALLOC ((rsize + msize) * BYTES_PER_MP_LIMB);
	if (rsize > msize)
	  mpn_mul (tp, rp, rsize, mp, msize);
	else
	  mpn_mul (tp, mp, msize, rp, rsize);
	rsize += msize;
	rsize -= tp[rsize - 1] == 0;
	exp_in_limbs = rsize + madj + radj;

	if (rsize > prec)
	  {
	    tp += rsize - prec;
	    rsize = prec;
	    exp_in_limbs += 0;
	  }
      }

    MPN_COPY (x->_mp_d, tp, rsize);
    x->_mp_size = negative ? -rsize : rsize;
    x->_mp_exp = exp_in_limbs;
    TMP_FREE (marker);
    return 0;
  }
}
