vasnprintf.c

开源备份软件源码 AMANDA, the Advanced Maryland Automatic Network Disk Archiver, is a backup system that a

			if (converted == NULL)
#  endif
			  {
			    int saved_errno = errno;
			    if (!(result == resultbuf || result == NULL))
			      free (result);
			    if (buf_malloced != NULL)
			      free (buf_malloced);
			    CLEANUP ();
			    errno = saved_errno;
			    return NULL;
			  }
			if (converted != result + length)
			  {
			    ENSURE_ALLOCATION (xsum (length, converted_len));
			    DCHAR_CPY (result + length, converted, converted_len);
			    free (converted);
			  }
			length += converted_len;
		      }
# endif

		      if (has_width && width > characters
			  && (dp->flags & FLAG_LEFT))
			{
			  size_t n = width - characters;
			  ENSURE_ALLOCATION (xsum (length, n));
			  DCHAR_SET (result + length, ' ', n);
			  length += n;
			}
		    }
		    break;

		  case TYPE_U16_STRING:
		    {
		      const uint16_t *arg = a.arg[dp->arg_index].a.a_u16_string;
		      const uint16_t *arg_end;
		      size_t characters;

		      if (has_precision)
			{
			  /* Use only PRECISION characters, from the left.  */
			  arg_end = arg;
			  characters = 0;
			  for (; precision > 0; precision--)
			    {
			      int count = u16_strmblen (arg_end);
			      if (count == 0)
				break;
			      if (count < 0)
				{
				  if (!(result == resultbuf || result == NULL))
				    free (result);
				  if (buf_malloced != NULL)
				    free (buf_malloced);
				  CLEANUP ();
				  errno = EILSEQ;
				  return NULL;
				}
			      arg_end += count;
			      characters++;
			    }
			}
		      else if (has_width)
			{
			  /* Use the entire string, and count the number of
			     characters.  */
			  arg_end = arg;
			  characters = 0;
			  for (;;)
			    {
			      int count = u16_strmblen (arg_end);
			      if (count == 0)
				break;
			      if (count < 0)
				{
				  if (!(result == resultbuf || result == NULL))
				    free (result);
				  if (buf_malloced != NULL)
				    free (buf_malloced);
				  CLEANUP ();
				  errno = EILSEQ;
				  return NULL;
				}
			      arg_end += count;
			      characters++;
			    }
			}
		      else
			{
			  /* Use the entire string.  */
			  arg_end = arg + u16_strlen (arg);
			  /* The number of characters doesn't matter.  */
			  characters = 0;
			}

		      if (has_width && width > characters
			  && !(dp->flags & FLAG_LEFT))
			{
			  size_t n = width - characters;
			  ENSURE_ALLOCATION (xsum (length, n));
			  DCHAR_SET (result + length, ' ', n);
			  length += n;
			}

# if DCHAR_IS_UINT16_T
		      {
			size_t n = arg_end - arg;
			ENSURE_ALLOCATION (xsum (length, n));
			DCHAR_CPY (result + length, arg, n);
			length += n;
		      }
# else
		      { /* Convert.  */
			DCHAR_T *converted = result + length;
			size_t converted_len = allocated - length;
#  if DCHAR_IS_TCHAR
			/* Convert from UTF-16 to locale encoding.  */
			if (u16_conv_to_encoding (locale_charset (),
						  iconveh_question_mark,
						  arg, arg_end - arg, NULL,
						  &converted, &converted_len)
			    < 0)
#  else
			/* Convert from UTF-16 to UTF-8/UTF-32.  */
			converted =
			  U16_TO_DCHAR (arg, arg_end - arg,
					converted, &converted_len);
			if (converted == NULL)
#  endif
			  {
			    int saved_errno = errno;
			    if (!(result == resultbuf || result == NULL))
			      free (result);
			    if (buf_malloced != NULL)
			      free (buf_malloced);
			    CLEANUP ();
			    errno = saved_errno;
			    return NULL;
			  }
			if (converted != result + length)
			  {
			    ENSURE_ALLOCATION (xsum (length, converted_len));
			    DCHAR_CPY (result + length, converted, converted_len);
			    free (converted);
			  }
			length += converted_len;
		      }
# endif

		      if (has_width && width > characters
			  && (dp->flags & FLAG_LEFT))
			{
			  size_t n = width - characters;
			  ENSURE_ALLOCATION (xsum (length, n));
			  DCHAR_SET (result + length, ' ', n);
			  length += n;
			}
		    }
		    break;

		  case TYPE_U32_STRING:
		    {
		      const uint32_t *arg = a.arg[dp->arg_index].a.a_u32_string;
		      const uint32_t *arg_end;
		      size_t characters;

		      if (has_precision)
			{
			  /* Use only PRECISION characters, from the left.  */
			  arg_end = arg;
			  characters = 0;
			  for (; precision > 0; precision--)
			    {
			      int count = u32_strmblen (arg_end);
			      if (count == 0)
				break;
			      if (count < 0)
				{
				  if (!(result == resultbuf || result == NULL))
				    free (result);
				  if (buf_malloced != NULL)
				    free (buf_malloced);
				  CLEANUP ();
				  errno = EILSEQ;
				  return NULL;
				}
			      arg_end += count;
			      characters++;
			    }
			}
		      else if (has_width)
			{
			  /* Use the entire string, and count the number of
			     characters.  */
			  arg_end = arg;
			  characters = 0;
			  for (;;)
			    {
			      int count = u32_strmblen (arg_end);
			      if (count == 0)
				break;
			      if (count < 0)
				{
				  if (!(result == resultbuf || result == NULL))
				    free (result);
				  if (buf_malloced != NULL)
				    free (buf_malloced);
				  CLEANUP ();
				  errno = EILSEQ;
				  return NULL;
				}
			      arg_end += count;
			      characters++;
			    }
			}
		      else
			{
			  /* Use the entire string.  */
			  arg_end = arg + u32_strlen (arg);
			  /* The number of characters doesn't matter.  */
			  characters = 0;
			}

		      if (has_width && width > characters
			  && !(dp->flags & FLAG_LEFT))
			{
			  size_t n = width - characters;
			  ENSURE_ALLOCATION (xsum (length, n));
			  DCHAR_SET (result + length, ' ', n);
			  length += n;
			}

# if DCHAR_IS_UINT32_T
		      {
			size_t n = arg_end - arg;
			ENSURE_ALLOCATION (xsum (length, n));
			DCHAR_CPY (result + length, arg, n);
			length += n;
		      }
# else
		      { /* Convert.  */
			DCHAR_T *converted = result + length;
			size_t converted_len = allocated - length;
#  if DCHAR_IS_TCHAR
			/* Convert from UTF-32 to locale encoding.  */
			if (u32_conv_to_encoding (locale_charset (),
						  iconveh_question_mark,
						  arg, arg_end - arg, NULL,
						  &converted, &converted_len)
			    < 0)
#  else
			/* Convert from UTF-32 to UTF-8/UTF-16.  */
			converted =
			  U32_TO_DCHAR (arg, arg_end - arg,
					converted, &converted_len);
			if (converted == NULL)
#  endif
			  {
			    int saved_errno = errno;
			    if (!(result == resultbuf || result == NULL))
			      free (result);
			    if (buf_malloced != NULL)
			      free (buf_malloced);
			    CLEANUP ();
			    errno = saved_errno;
			    return NULL;
			  }
			if (converted != result + length)
			  {
			    ENSURE_ALLOCATION (xsum (length, converted_len));
			    DCHAR_CPY (result + length, converted, converted_len);
			    free (converted);
			  }
			length += converted_len;
		      }
# endif

		      if (has_width && width > characters
			  && (dp->flags & FLAG_LEFT))
			{
			  size_t n = width - characters;
			  ENSURE_ALLOCATION (xsum (length, n));
			  DCHAR_SET (result + length, ' ', n);
			  length += n;
			}
		    }
		    break;

		  default:
		    abort ();
		  }
	      }
#endif
#if NEED_PRINTF_DIRECTIVE_A && !defined IN_LIBINTL
	    else if (dp->conversion == 'a' || dp->conversion == 'A')
	      {
		arg_type type = a.arg[dp->arg_index].type;
		int flags = dp->flags;
		int has_width;
		size_t width;
		int has_precision;
		size_t precision;
		size_t tmp_length;
		DCHAR_T tmpbuf[700];
		DCHAR_T *tmp;
		DCHAR_T *pad_ptr;
		DCHAR_T *p;

		has_width = 0;
		width = 0;
		if (dp->width_start != dp->width_end)
		  {
		    if (dp->width_arg_index != ARG_NONE)
		      {
			int arg;

			if (!(a.arg[dp->width_arg_index].type == TYPE_INT))
			  abort ();
			arg = a.arg[dp->width_arg_index].a.a_int;
			if (arg < 0)
			  {
			    /* "A negative field width is taken as a '-' flag
			        followed by a positive field width."  */
			    flags |= FLAG_LEFT;
			    width = (unsigned int) (-arg);
			  }
			else
			  width = arg;
		      }
		    else
		      {
			const FCHAR_T *digitp = dp->width_start;

			do
			  width = xsum (xtimes (width, 10), *digitp++ - '0');
			while (digitp != dp->width_end);
		      }
		    has_width = 1;
		  }

		has_precision = 0;
		precision = 0;
		if (dp->precision_start != dp->precision_end)
		  {
		    if (dp->precision_arg_index != ARG_NONE)
		      {
			int arg;

			if (!(a.arg[dp->precision_arg_index].type == TYPE_INT))
			  abort ();
			arg = a.arg[dp->precision_arg_index].a.a_int;
			/* "A negative precision is taken as if the precision
			    were omitted."  */
			if (arg >= 0)
			  {
			    precision = arg;
			    has_precision = 1;
			  }
		      }
		    else
		      {
			const FCHAR_T *digitp = dp->precision_start + 1;

			precision = 0;
			while (digitp != dp->precision_end)
			  precision = xsum (xtimes (precision, 10), *digitp++ - '0');
			has_precision = 1;
		      }
		  }

		/* Allocate a temporary buffer of sufficient size.  */
		if (type == TYPE_LONGDOUBLE)
		  tmp_length =
		    (unsigned int) ((LDBL_DIG + 1)
				    * 0.831 /* decimal -> hexadecimal */
				   )
		    + 1; /* turn floor into ceil */
		else
		  tmp_length =
		    (unsigned int) ((DBL_DIG + 1)
				    * 0.831 /* decimal -> hexadecimal */
				   )
		    + 1; /* turn floor into ceil */
		if (tmp_length < precision)
		  tmp_length = precision;
		/* Account for sign, decimal point etc. */
		tmp_length = xsum (tmp_length, 12);

		if (tmp_length < width)
		  tmp_length = width;

		tmp_length = xsum (tmp_length, 1); /* account for trailing NUL */

		if (tmp_length <= sizeof (tmpbuf) / sizeof (DCHAR_T))
		  tmp = tmpbuf;
		else
		  {
		    size_t tmp_memsize = xtimes (tmp_length, sizeof (DCHAR_T));

		    if (size_overflow_p (tmp_memsize))
		      /* Overflow, would lead to out of memory.  */
		      goto out_of_memory;
		    tmp = (DCHAR_T *) malloc (tmp_memsize);
		    if (tmp == NULL)
		      /* Out of memory.  */
		      goto out_of_memory;
		  }

		pad_ptr = NULL;
		p = tmp;
		if (type == TYPE_LONGDOUBLE)
		  {
		    long double arg = a.arg[dp->arg_index].a.a_longdouble;

		    if (isnanl (arg))
		      {
			if (dp->conversion == 'A')
			  {
			    *p++ = 'N'; *p++ = 'A'; *p++ = 'N';
			  }
			else
			  {
			    *p++ = 'n'; *p++ = 'a'; *p++ = 'n';
			  }
		      }
		    else
		      {
			int sign = 0;
			DECL_LONG_DOUBLE_ROUNDING

			BEGIN_LONG_DOUBLE_ROUNDING ();

			if (signbit (arg)) /* arg < 0.0L or negative zero */
			  {
			    sign = -1;
			    arg = -arg;
			  }

			if (sign < 0)
			  *p++ = '-';
			else if (flags & FLAG_SHOWSIGN)
			  *p++ = '+';
			else if (flags & FLAG_SPACE)
			  *p++ = ' ';

			if (arg > 0.0L && arg + arg == arg)
			  {
			    if (dp->conversion == 'A')
			      {
				*p++ = 'I'; *p++ = 'N'; *p++ = 'F';
			      }
			    else
			      {
				*p++ = 'i'; *p++ = 'n'; *p++ = 'f';
			      }
			  }
			else
			  {
			    int exponent;
			    long double mantissa;

			    if (arg > 0.0L)
			      mantissa = printf_frexpl (arg, &exponent);
			    else
			      {
				exponent = 0;
				mantissa = 0.0L;
			      }

			    if (has_precision
				&& precision < (unsigned int) ((LDBL_DIG + 1) * 0.831) + 1)
			      {
				/* Round the mantissa.  */
				long double tail = mantissa;
				size_t q;

				for (q = precision; ; q--)
				  {
				    int digit = (int) tail;
				    tail -= digit;
				    if (q == 0)
				      {
					if (digit & 1 ? tail >= 0.5L : tail > 0.5L)
					  tail = 1 - tail;
					else
					  tail = - tail;
					break;
				      }
				    tail *= 16.0L;
				  }
				if (tail != 0.0L)
				  for (q = precision; q > 0; q--)
				    tail *= 0.0625L;
				mantissa += tail;
			      }

			    *p++ = '0';
			    *p++ = dp->conversion - 'A' + 'X';
			    pad_ptr = p;
			    {
			      int digit;

			      digit = (int) mantissa;
			      mantissa -= digit;
			      *p++ = '0' + digit;
			      if ((flags & FLAG_ALT)
				  || mantissa > 0.0L || precision > 0)
				{