/* pformat.c
 *
 * $Id: pformat.c,v 1.9 2011/01/07 22:57:00 keithmarshall Exp $
 *
 * Provides a core implementation of the formatting capabilities
 * common to the entire `printf()' family of functions; it conforms
 * generally to C99 and SUSv3/POSIX specifications, with extensions
 * to support Microsoft's non-standard format specifications.
 *
 * Written by Keith Marshall <keithmarshall@users.sourceforge.net>
 *
 * This is free software.  You may redistribute and/or modify it as you
 * see fit, without restriction of copyright.
 *
 * This software is provided "as is", in the hope that it may be useful,
 * but WITHOUT WARRANTY OF ANY KIND, not even any implied warranty of
 * MERCHANTABILITY, nor of FITNESS FOR ANY PARTICULAR PURPOSE.  At no
 * time will the author accept any form of liability for any damages,
 * however caused, resulting from the use of this software.
 *
 * The elements of this implementation which deal with the formatting
 * of floating point numbers, (i.e. the `%e', `%E', `%f', `%F', `%g'
 * and `%G' format specifiers, but excluding the hexadecimal floating
 * point `%a' and `%A' specifiers), make use of the `__gdtoa' function
 * written by David M. Gay, and are modelled on his sample code, which
 * has been deployed under its accompanying terms of use:--
 *
 ******************************************************************
 * Copyright (C) 1997, 1999, 2001 Lucent Technologies
 * All Rights Reserved
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation for any purpose and without fee is hereby
 * granted, provided that the above copyright notice appear in all
 * copies and that both that the copyright notice and this
 * permission notice and warranty disclaimer appear in supporting
 * documentation, and that the name of Lucent or any of its entities
 * not be used in advertising or publicity pertaining to
 * distribution of the software without specific, written prior
 * permission.
 *
 * LUCENT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
 * IN NO EVENT SHALL LUCENT OR ANY OF ITS ENTITIES BE LIABLE FOR ANY
 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
 * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
 * THIS SOFTWARE.
 ******************************************************************
 *
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <stdio.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <locale.h>
#include <wchar.h>

#ifdef __ENABLE_DFP
#ifndef __STDC_WANT_DEC_FP__
#define __STDC_WANT_DEC_FP__ 1
#endif

#include "../math/DFP/dfp_internal.h"
#endif /* __ENABLE_DFP */

#include <math.h>

/* FIXME: The following belongs in values.h, but current MinGW
 * has nothing useful there!  OTOH, values.h is not a standard
 * header, and it's use may be considered obsolete; perhaps it
 * is better to just keep these definitions here.
 */

#include <pshpack1.h>
/* workaround gcc bug */
#ifdef __GNUC__
#define ATTRIB_GCC_STRUCT __attribute__((gcc_struct))
#else
#define ATTRIB_GCC_STRUCT
#endif
typedef struct ATTRIB_GCC_STRUCT __tI128 {
  int64_t digits[2];
} __tI128;

typedef struct ATTRIB_GCC_STRUCT __tI128_2 {
  uint32_t digits32[4];
} __tI128_2;

typedef union ATTRIB_GCC_STRUCT __uI128 {
  __tI128 t128;
  __tI128_2 t128_2;
} __uI128;
#include <poppack.h>

#ifndef _VALUES_H
/*
 * values.h
 *
 */
#define _VALUES_H

#include <limits.h>

#define _TYPEBITS(type)     (sizeof(type) * CHAR_BIT)

#if defined(__ENABLE_PRINTF128) || defined(__ENABLE_DFP)
#define LLONGBITS           _TYPEBITS(__tI128)
#else
#define LLONGBITS           _TYPEBITS(long long)
#endif

#endif /* !defined _VALUES_H -- end of file */

#include "mingw_pformat.h"

/* Bit-map constants, defining the internal format control
 * states, which propagate through the flags.
 */
#define PFORMAT_GROUPED     0x00001000
#define PFORMAT_HASHED      0x00000800
#define PFORMAT_LJUSTIFY    0x00000400
#define PFORMAT_ZEROFILL    0x00000200

#define PFORMAT_JUSTIFY    (PFORMAT_LJUSTIFY | PFORMAT_ZEROFILL)
#define PFORMAT_IGNORE      -1

#define PFORMAT_SIGNED      0x000001C0
#define PFORMAT_POSITIVE    0x00000100
#define PFORMAT_NEGATIVE    0x00000080
#define PFORMAT_ADDSPACE    0x00000040

#define PFORMAT_XCASE       0x00000020

#define PFORMAT_LDOUBLE     0x00000004

#ifdef __ENABLE_DFP
#define PFORMAT_DECIM32     0x00020000
#define PFORMAT_DECIM64     0x00040000
#define PFORMAT_DECIM128    0x00080000
#endif

/* `%o' format digit extraction mask, and shift count...
 * (These are constant, and do not propagate through the flags).
 */
#define PFORMAT_OMASK       0x00000007
#define PFORMAT_OSHIFT      0x00000003

/* `%x' and `%X' format digit extraction mask, and shift count...
 * (These are constant, and do not propagate through the flags).
 */
#define PFORMAT_XMASK       0x0000000F
#define PFORMAT_XSHIFT      0x00000004

/* The radix point character, used in floating point formats, is
 * localised on the basis of the active LC_NUMERIC locale category.
 * It is stored locally, as a `wchar_t' entity, which is converted
 * to a (possibly multibyte) character on output.  Initialisation
 * of the stored `wchar_t' entity, together with a record of its
 * effective multibyte character length, is required each time
 * `__pformat()' is entered, (static storage would not be thread
 * safe), but this initialisation is deferred until it is actually
 * needed; on entry, the effective character length is first set to
 * the following value, (and the `wchar_t' entity is zeroed), to
 * indicate that a call of `localeconv()' is needed, to complete
 * the initialisation.
 */
#define PFORMAT_RPINIT      -3

/* The floating point format handlers return the following value
 * for the radix point position index, when the argument value is
 * infinite, or not a number.
 */
#define PFORMAT_INFNAN      -32768

#ifdef _WIN32
/*
 * The Microsoft standard for printing `%e' format exponents is
 * with a minimum of three digits, unless explicitly set otherwise,
 * by a prior invocation of the `_set_output_format()' function.
 *
 * The following macro allows us to replicate this behaviour.
 */
# define PFORMAT_MINEXP    __pformat_exponent_digits()
 /*
  * However, this feature is unsupported for versions of the
  * MSVC runtime library prior to msvcr80.dll, and by default,
  * MinGW uses an earlier version, (equivalent to msvcr60.dll),
  * for which `_TWO_DIGIT_EXPONENT' will be undefined.
  */
# ifndef _TWO_DIGIT_EXPONENT
 /*
  * This hack works around the lack of the `_set_output_format()'
  * feature, when supporting versions of the MSVC runtime library
  * prior to msvcr80.dll; it simply enforces Microsoft's original
  * convention, for all cases where the feature is unsupported.
  */
#  define _get_output_format()  0
#  define _TWO_DIGIT_EXPONENT   1
# endif
/*
 * Irrespective of the MSVCRT version supported, *we* will add
 * an additional capability, through the following inline function,
 * which will allow the user to choose his own preferred default
 * for `PRINTF_EXPONENT_DIGITS', through the simple expedient
 * of defining it as an environment variable.
 */
static
int __pformat_exponent_digits( void )
{
  char *exponent_digits = getenv( "PRINTF_EXPONENT_DIGITS" );
  return ((exponent_digits != NULL) && ((unsigned)(*exponent_digits - '0') < 3))
    || (_get_output_format() & _TWO_DIGIT_EXPONENT)
    ? 2
    : 3
    ;
}
#else
/*
 * When we don't care to mimic Microsoft's standard behaviour,
 * we adopt the C99/POSIX standard of two digit exponents.
 */
# define PFORMAT_MINEXP         2
#endif

typedef union
{
  /* A data type agnostic representation,
   * for printf arguments of any integral data type...
   */
  signed long             __pformat_long_t;
  signed long long        __pformat_llong_t;
  unsigned long           __pformat_ulong_t;
  unsigned long long      __pformat_ullong_t;
  unsigned short          __pformat_ushort_t;
  unsigned char           __pformat_uchar_t;
  signed short            __pformat_short_t;
  signed char             __pformat_char_t;
  void *                  __pformat_ptr_t;
  __uI128                 __pformat_u128_t;
} __pformat_intarg_t;

typedef enum
{
  /* Format interpreter state indices...
   * (used to identify the active phase of format string parsing).
   */
  PFORMAT_INIT = 0,
  PFORMAT_SET_WIDTH,
  PFORMAT_GET_PRECISION,
  PFORMAT_SET_PRECISION,
  PFORMAT_END
} __pformat_state_t;
      
typedef enum
{
  /* Argument length classification indices...
   * (used for arguments representing integer data types).
   */
  PFORMAT_LENGTH_INT = 0,
  PFORMAT_LENGTH_SHORT,
  PFORMAT_LENGTH_LONG,
  PFORMAT_LENGTH_LLONG,
  PFORMAT_LENGTH_LLONG128,
  PFORMAT_LENGTH_CHAR
} __pformat_length_t;
/*
 * And a macro to map any arbitrary data type to an appropriate
 * matching index, selected from those above; the compiler should
 * collapse this to a simple assignment.
 */

#ifdef __GNUC__
/* provides for some deadcode elimination via compile time eval */
#define __pformat_arg_length(x) \
__builtin_choose_expr (                                         \
  __builtin_types_compatible_p (typeof (x), __tI128),           \
   PFORMAT_LENGTH_LLONG128,                                     \
    __builtin_choose_expr (                                     \
      __builtin_types_compatible_p (typeof (x), long long),     \
        PFORMAT_LENGTH_LLONG,                                   \
    __builtin_choose_expr (                                     \
      __builtin_types_compatible_p (typeof (x), long),          \
        PFORMAT_LENGTH_LONG,                                    \
    __builtin_choose_expr (                                     \
      __builtin_types_compatible_p (typeof (x), short),         \
        PFORMAT_LENGTH_SHORT,                                   \
    __builtin_choose_expr (                                     \
      __builtin_types_compatible_p (typeof (x), char),          \
        PFORMAT_LENGTH_CHAR,                                    \
    __builtin_choose_expr (                                     \
      __builtin_types_compatible_p (typeof (x), __uI128),       \
        PFORMAT_LENGTH_LLONG128,                                \
    __builtin_choose_expr (                                              \
      __builtin_types_compatible_p (typeof (x), unsigned long),          \
        PFORMAT_LENGTH_LONG,                                             \
    __builtin_choose_expr (                                              \
      __builtin_types_compatible_p (typeof (x), unsigned long long),     \
        PFORMAT_LENGTH_LLONG,                                            \
    __builtin_choose_expr (                                              \
      __builtin_types_compatible_p (typeof (x), unsigned short),         \
        PFORMAT_LENGTH_SHORT,                                            \
    __builtin_choose_expr (                                              \
      __builtin_types_compatible_p (typeof (x), unsigned char),          \
        PFORMAT_LENGTH_CHAR,                                             \
  PFORMAT_LENGTH_INT))))))))))

#else
#define __pformat_arg_length( type )    \
  sizeof( type ) == sizeof( __tI128 )   ? PFORMAT_LENGTH_LLONG128 : \
  sizeof( type ) == sizeof( long long ) ? PFORMAT_LENGTH_LLONG : \
  sizeof( type ) == sizeof( long )      ? PFORMAT_LENGTH_LONG  : \
  sizeof( type ) == sizeof( short )     ? PFORMAT_LENGTH_SHORT : \
  sizeof( type ) == sizeof( char )      ? PFORMAT_LENGTH_CHAR  : \
  /* should never need this default */    PFORMAT_LENGTH_INT
#endif

typedef struct
{
  /* Formatting and output control data...
   * An instance of this control block is created, (on the stack),
   * for each call to `__pformat()', and is passed by reference to
   * each of the output handlers, as required.
   */
  void *         dest;
  int            flags;
  int            width;
  int            precision;
  int            rplen;
  wchar_t        rpchr;
  int		 thousands_chr_len;
  wchar_t	 thousands_chr;
  int            count;
  int            quota;
  int            expmin;
} __pformat_t;

#if defined(__ENABLE_PRINTF128) || defined(__ENABLE_DFP)
/* trim leading, leave at least n characters */
static char * __bigint_trim_leading_zeroes(char *in, int n){
  char *src = in;
  int len = strlen(in);
  while( len > n && *++src == '0') len--;

  /* we want to null terminator too */
  memmove(in, src, strlen(src) + 1);
  return in;
}

/* LSB first */
static
void __bigint_to_string(const uint32_t *digits, const uint32_t digitlen, char *buff, const uint32_t bufflen){
  int64_t digitsize = sizeof(*digits) * 8;
  int64_t shiftpos = digitlen * digitsize - 1;
  memset(buff, 0, bufflen);

  while(shiftpos >= 0) {
    /* increment */
    for(uint32_t i = 0; i < bufflen - 1; i++){
      buff[i] += (buff[i] > 4) ? 3 : 0;
    }

    /* shift left */
    for(uint32_t i = 0; i < bufflen - 1; i++)
      buff[i] <<= 1;

    /* shift in */
    buff[bufflen - 2] |= digits[shiftpos / digitsize] & (0x1 << (shiftpos % digitsize)) ? 1 : 0;

    /* overflow check */
    for(uint32_t i = bufflen - 1; i > 0; i--){
      buff[i - 1] |= (buff[i] > 0xf);
      buff[i] &= 0x0f;
    }
    shiftpos--;
  }

  for(uint32_t i = 0; i < bufflen - 1; i++){
    buff[i] += '0';
  }
  buff[bufflen - 1] = '\0';
}

#if defined(__ENABLE_PRINTF128)
/* LSB first, hex version */
static
void __bigint_to_stringx(const uint32_t *digits, const uint32_t digitlen, char *buff, const uint32_t bufflen, int upper){
  int32_t stride = sizeof(*digits) * 2;
  uint32_t lastpos = 0;

  for(uint32_t i = 0; i < digitlen * stride; i++){
    int32_t buffpos = bufflen - i - 2;
    buff[buffpos] = (digits[ i / stride ] & (0xf << 4 * (i % stride))) >> ( 4 * (i % stride));
    buff[buffpos] += (buff[buffpos] > 9) ? ((upper) ? 0x7 : 0x27) : 0;
    buff[buffpos] += '0';
    lastpos = buffpos;
    if(buffpos == 0) break; /* sanity check */
  }
  memset(buff, '0', lastpos);
  buff[bufflen - 1] = '\0';
}

/* LSB first, octet version */
static
void __bigint_to_stringo(const uint32_t *digits, const uint32_t digitlen, char *buff, const uint32_t bufflen){
  const uint32_t digitsize = sizeof(*digits) * 8;
  const uint64_t bits = digitsize * digitlen;
  uint32_t pos = bufflen - 2;
  uint32_t reg = 0;
  for(uint32_t i = 0; i <= bits; i++){
    reg |= (digits[ i / digitsize] & (0x1 << (i % digitsize))) ? 1 << (i % 3) : 0;
    if( (i && ( i + 1) % 3 == 0) || (i + 1) == bits){ /* make sure all is committed after last bit */
      buff[pos] = '0' + reg;
      reg = 0;
      if(!pos) break; /* sanity check */
      pos--;
    }
  }
  if(pos < bufflen - 1)
    memset(buff,'0', pos + 1);
  buff[bufflen - 1] = '\0';
}
#endif /* defined(__ENABLE_PRINTF128) */
#endif /* defined(__ENABLE_PRINTF128) || defined(__ENABLE_DFP) */

static
void __pformat_putc( int c, __pformat_t *stream )
{
  /* Place a single character into the `__pformat()' output queue,
   * provided any specified output quota has not been exceeded.
   */
  if( (stream->flags & PFORMAT_NOLIMIT) || (stream->quota > stream->count) )
  {
    /* Either there was no quota specified,
     * or the active quota has not yet been reached.
     */
    if( stream->flags & PFORMAT_TO_FILE )
      /*
       * This is single character output to a FILE stream...
       */
      __fputc(c, (FILE *)(stream->dest));

    else
      /* Whereas, this is to an internal memory buffer...
       */
      ((APICHAR *)(stream->dest))[stream->count] = c;
  }
  ++stream->count;
}

static
void __pformat_putchars( const char *s, int count, __pformat_t *stream )
{
  /* Handler for `%c' and (indirectly) `%s' conversion specifications.
   *
   * Transfer characters from the string buffer at `s', character by
   * character, up to the number of characters specified by `count', or
   * if `precision' has been explicitly set to a value less than `count',
   * stopping after the number of characters specified for `precision',
   * to the `__pformat()' output stream.
   *
   * Characters to be emitted are passed through `__pformat_putc()', to
   * ensure that any specified output quota is honoured.
   */
  if( (stream->precision >= 0) && (count > stream->precision) )
    /*
     * Ensure that the maximum number of characters transferred doesn't
     * exceed any explicitly set `precision' specification.
     */
    count = stream->precision;

  /* Establish the width of any field padding required...
   */
  if( stream->width > count )
    /*
     * as the number of spaces equivalent to the number of characters
     * by which those to be emitted is fewer than the field width...
     */
    stream->width -= count;

  else
    /* ignoring any width specification which is insufficient.
     */
    stream->width = PFORMAT_IGNORE;

  if( (stream->width > 0) && ((stream->flags & PFORMAT_LJUSTIFY) == 0) )
    /*
     * When not doing flush left justification, (i.e. the `-' flag
     * is not set), any residual unreserved field width must appear
     * as blank padding, to the left of the output string.
     */
    while( stream->width-- )
      __pformat_putc( '\x20', stream );

  /* Emit the data...
   */
#ifdef __BUILD_WIDEAPI
  {
    /* mbrtowc */
    size_t l;
    wchar_t w[12], *p;
    while( count > 0 )
    {
      mbstate_t ps;
      memset(&ps, 0, sizeof(ps) );
      --count;
      p = &w[0];
      l = mbrtowc (p, s, strlen (s), &ps);
      if (!l)
        break;
      if ((ssize_t)l < 0)
      {
        l = 1;
        w[0] = (wchar_t) *s;
      }
      s += l;
      __pformat_putc((int)w[0], stream);
    }
  }
#else
  while( count-- )
    /*
     * copying the requisite number of characters from the input.
     */
    __pformat_putc( *s++, stream );
#endif

  /* If we still haven't consumed the entire specified field width,
   * we must be doing flush left justification; any residual width
   * must be filled with blanks, to the right of the output value.
   */
  while( stream->width-- > 0 )
    __pformat_putc( '\x20', stream );
}

static
void __pformat_puts( const char *s, __pformat_t *stream )
{
  /* Handler for `%s' conversion specifications.
   *
   * Transfer a NUL terminated character string, character by character,
   * stopping when the end of the string is encountered, or if `precision'
   * has been explicitly set, when the specified number of characters has
   * been emitted, if that is less than the length of the input string,
   * to the `__pformat()' output stream.
   *
   * This is implemented as a trivial call to `__pformat_putchars()',
   * passing the length of the input string as the character count,
   * (after first verifying that the input pointer is not NULL).
   */
  if( s == NULL ) s = "(null)";
  __pformat_putchars( s, strlen( s ), stream );
}

static
void __pformat_wputchars( const wchar_t *s, int count, __pformat_t *stream )
{
  /* Handler for `%C'(`%lc') and `%S'(`%ls') conversion specifications;
   * (this is a wide character variant of `__pformat_putchars()').
   *
   * Each multibyte character sequence to be emitted is passed, byte
   * by byte, through `__pformat_putc()', to ensure that any specified
   * output quota is honoured.
   */
  char buf[16];
  mbstate_t state;
  int len = wcrtomb(buf, L'\0', &state);

  if( (stream->precision >= 0) && (count > stream->precision) )
    /*
     * Ensure that the maximum number of characters transferred doesn't
     * exceed any explicitly set `precision' specification.
     */
    count = stream->precision;

  /* Establish the width of any field padding required...
   */
  if( stream->width > count )
    /*
     * as the number of spaces equivalent to the number of characters
     * by which those to be emitted is fewer than the field width...
     */
    stream->width -= count;

  else
    /* ignoring any width specification which is insufficient.
     */
    stream->width = PFORMAT_IGNORE;

  if( (stream->width > 0) && ((stream->flags & PFORMAT_LJUSTIFY) == 0) )
    /*
     * When not doing flush left justification, (i.e. the `-' flag
     * is not set), any residual unreserved field width must appear
     * as blank padding, to the left of the output string.
     */
    while( stream->width-- )
      __pformat_putc( '\x20', stream );

  /* Emit the data, converting each character from the wide
   * to the multibyte domain as we go...
   */
#ifdef __BUILD_WIDEAPI
  len = count;
  while(len-- > 0 && *s != 0)
  {
      __pformat_putc(*s++, stream);
  }
  count = len;
#else
  while( (count-- > 0) && ((len = wcrtomb( buf, *s++, &state )) > 0) )
  {
    char *p = buf;
    while( len-- > 0 )
      __pformat_putc( *p++, stream );
  }
#endif
  /* If we still haven't consumed the entire specified field width,
   * we must be doing flush left justification; any residual width
   * must be filled with blanks, to the right of the output value.
   */
  while( stream->width-- > 0 )
    __pformat_putc( '\x20', stream );
}

static
void __pformat_wcputs( const wchar_t *s, __pformat_t *stream )
{
  /* Handler for `%S' (`%ls') conversion specifications.
   *
   * Transfer a NUL terminated wide character string, character by
   * character, converting to its equivalent multibyte representation
   * on output, and stopping when the end of the string is encountered,
   * or if `precision' has been explicitly set, when the specified number
   * of characters has been emitted, if that is less than the length of
   * the input string, to the `__pformat()' output stream.
   *
   * This is implemented as a trivial call to `__pformat_wputchars()',
   * passing the length of the input string as the character count,
   * (after first verifying that the input pointer is not NULL).
   */
  if( s == NULL ) s = L"(null)";
  __pformat_wputchars( s, wcslen( s ), stream );
}

static
int __pformat_int_bufsiz( int bias, int size, __pformat_t *stream )
{
  /* Helper to establish the size of the internal buffer, which
   * is required to queue the ASCII decomposition of an integral
   * data value, prior to transfer to the output stream.
   */
  size = ((size - 1 + LLONGBITS) / size) + bias;
  size += (stream->precision > 0) ? stream->precision : 0;
  if ((stream->flags & PFORMAT_GROUPED) != 0 && stream->thousands_chr != 0)
    size += (size / 3);
  return (size > stream->width) ? size : stream->width;
}

static
void __pformat_int( __pformat_intarg_t value, __pformat_t *stream )
{
  /* Handler for `%d', `%i' and `%u' conversion specifications.
   *
   * Transfer the ASCII representation of an integer value parameter,
   * formatted as a decimal number, to the `__pformat()' output queue;
   * output will be truncated, if any specified quota is exceeded.
   */
  int32_t bufflen = __pformat_int_bufsiz(1, PFORMAT_OSHIFT, stream);
#ifdef __ENABLE_PRINTF128
  char *tmp_buff = NULL;
#endif
  char *buf = NULL;
  char *p;
  int precision;

  buf = alloca(bufflen);
  p = buf;
  if( stream->flags & PFORMAT_NEGATIVE )
#ifdef __ENABLE_PRINTF128
  {
    /* The input value might be negative, (i.e. it is a signed value)...
     */
    if( value.__pformat_u128_t.t128.digits[1] < 0) {
      /*
       * It IS negative, but we want to encode it as unsigned,
       * displayed with a leading minus sign, so convert it...
       */
      /* two's complement */
      value.__pformat_u128_t.t128.digits[0] = ~value.__pformat_u128_t.t128.digits[0];
      value.__pformat_u128_t.t128.digits[1] = ~value.__pformat_u128_t.t128.digits[1];
      value.__pformat_u128_t.t128.digits[0] += 1;
      value.__pformat_u128_t.t128.digits[1] += (!value.__pformat_u128_t.t128.digits[0]) ? 1 : 0;
    } else
      /* It is unequivocally a POSITIVE value, so turn off the
       * request to prefix it with a minus sign...
       */
      stream->flags &= ~PFORMAT_NEGATIVE;
  }

  tmp_buff = alloca(bufflen);
  /* Encode the input value for display...
   */
  __bigint_to_string(value.__pformat_u128_t.t128_2.digits32,
    4, tmp_buff, bufflen);
  __bigint_trim_leading_zeroes(tmp_buff,1);

  memset(p,0,bufflen);
  for(int32_t i = strlen(tmp_buff) - 1; i >= 0; i--){
  if ( i && (stream->flags & PFORMAT_GROUPED) != 0 && stream->thousands_chr != 0
        && (i % 4) == 3)
      {
        *p++ = ',';
      }
      *p++ = tmp_buff[i];
    if( i > bufflen - 1) break; /* sanity chec */
    if(  tmp_buff[i] == '\0' ) break; /* end */
  }
#else
  {
    /* The input value might be negative, (i.e. it is a signed value)...
     */
    if( value.__pformat_llong_t < 0LL )
      /*
       * It IS negative, but we want to encode it as unsigned,
       * displayed with a leading minus sign, so convert it...
       */
      value.__pformat_llong_t = -value.__pformat_llong_t;

    else
      /* It is unequivocally a POSITIVE value, so turn off the
       * request to prefix it with a minus sign...
       */
      stream->flags &= ~PFORMAT_NEGATIVE;
  }
while( value.__pformat_ullong_t )
  {
    /* decomposing it into its constituent decimal digits,
     * in order from least significant to most significant, using
     * the local buffer as a LIFO queue in which to store them. 
     */
    if (p != buf && (stream->flags & PFORMAT_GROUPED) != 0 && stream->thousands_chr != 0
        && ((p - buf) % 4) == 3)
      {
        *p++ = ',';
      }
    *p++ = '0' + (unsigned char)(value.__pformat_ullong_t % 10LL);
    value.__pformat_ullong_t /= 10LL;
  }
#endif

  if(  (stream->precision > 0)
  &&  ((precision = stream->precision - (p - buf)) > 0)  )
    /*
     * We have not yet queued sufficient digits to fill the field width
     * specified for minimum `precision'; pad with zeros to achieve this.
     */
    while( precision-- > 0 )
      *p++ = '0';

  if( (p == buf) && (stream->precision != 0) )
    /*
     * Input value was zero; make sure we print at least one digit,
     * unless the precision is also explicitly zero.
     */
    *p++ = '0';

  if( (stream->width > 0) && ((stream->width -= p - buf) > 0) )
  {
    /* We have now queued sufficient characters to display the input value,
     * at the desired precision, but this will not fill the output field...
     */
    if( stream->flags & PFORMAT_SIGNED )
      /*
       * We will fill one additional space with a sign...
       */
      stream->width--;

    if(  (stream->precision < 0)
    &&  ((stream->flags & PFORMAT_JUSTIFY) == PFORMAT_ZEROFILL)  )
      /*
       * and the `0' flag is in effect, so we pad the remaining spaces,
       * to the left of the displayed value, with zeros.
       */
      while( stream->width-- > 0 )
	*p++ = '0';

    else if( (stream->flags & PFORMAT_LJUSTIFY) == 0 )
      /*
       * the `0' flag is not in effect, and neither is the `-' flag,
       * so we pad to the left of the displayed value with spaces, so that
       * the value appears right justified within the output field.
       */
      while( stream->width-- > 0 )
	__pformat_putc( '\x20', stream );
  }

  if( stream->flags & PFORMAT_NEGATIVE )
    /*
     * A negative value needs a sign...
     */
    *p++ = '-';

  else if( stream->flags & PFORMAT_POSITIVE )
    /*
     * A positive value may have an optionally displayed sign...
     */
    *p++ = '+';

  else if( stream->flags & PFORMAT_ADDSPACE )
    /*
     * Space was reserved for displaying a sign, but none was emitted...
     */
    *p++ = '\x20';

  while( p > buf )
    /*
     * Emit the accumulated constituent digits,
     * in order from most significant to least significant...
     */
    __pformat_putc( *--p, stream );

  while( stream->width-- > 0 )
    /*
     * The specified output field has not yet been completely filled;
     * the `-' flag must be in effect, resulting in a displayed value which
     * appears left justified within the output field; we must pad the field
     * to the right of the displayed value, by emitting additional spaces,
     * until we reach the rightmost field boundary.
     */
    __pformat_putc( '\x20', stream );
}

static
void __pformat_xint( int fmt, __pformat_intarg_t value, __pformat_t *stream )
{
  /* Handler for `%o', `%p', `%x' and `%X' conversions.
   *
   * These can be implemented using a simple `mask and shift' strategy;
   * set up the mask and shift values appropriate to the conversion format,
   * and allocate a suitably sized local buffer, in which to queue encoded
   * digits of the formatted value, in preparation for output.
   */
  int width;
  int shift = (fmt == 'o') ? PFORMAT_OSHIFT : PFORMAT_XSHIFT;
  int bufflen = __pformat_int_bufsiz(2, shift, stream);
  char *buf = NULL;
#ifdef __ENABLE_PRINTF128
  char *tmp_buf = NULL;
#endif
  char *p;
  buf = alloca(bufflen);
  p = buf;
#ifdef __ENABLE_PRINTF128
  tmp_buf = alloca(bufflen);
  if(fmt == 'o'){
    __bigint_to_stringo(value.__pformat_u128_t.t128_2.digits32,4,tmp_buf,bufflen);
  } else {
    __bigint_to_stringx(value.__pformat_u128_t.t128_2.digits32,4,tmp_buf,bufflen, !(fmt & PFORMAT_XCASE));
  }
  __bigint_trim_leading_zeroes(tmp_buf,0);

  memset(buf,0,bufflen);
  for(int32_t i = strlen(tmp_buf); i >= 0; i--)
    *p++ = tmp_buf[i];
#else
  int mask = (fmt == 'o') ? PFORMAT_OMASK : PFORMAT_XMASK;
  while( value.__pformat_ullong_t )
  {
    /* Encode the specified non-zero input value as a sequence of digits,
     * in the appropriate `base' encoding and in reverse digit order, each
     * encoded in its printable ASCII form, with no leading zeros, using
     * the local buffer as a LIFO queue in which to store them.
     */
    char *q;
    if( (*(q = p++) = '0' + (value.__pformat_ullong_t & mask)) > '9' )
      *q = (*q + 'A' - '9' - 1) | (fmt & PFORMAT_XCASE);
    value.__pformat_ullong_t >>= shift;
  }
#endif

  if( p == buf )
    /*
     * Nothing was queued; input value must be zero, which should never be
     * emitted in the `alternative' PFORMAT_HASHED style.
     */
    stream->flags &= ~PFORMAT_HASHED;

  if( ((width = stream->precision) > 0) && ((width -= p - buf) > 0) )
    /*
     * We have not yet queued sufficient digits to fill the field width
     * specified for minimum `precision'; pad with zeros to achieve this.
     */
    while( width-- > 0 )
      *p++ = '0';
  
  else if( (fmt == 'o') && (stream->flags & PFORMAT_HASHED) )
    /*
     * The field width specified for minimum `precision' has already
     * been filled, but the `alternative' PFORMAT_HASHED style for octal
     * output requires at least one initial zero; that will not have
     * been queued, so add it now.
     */
    *p++ = '0';

  if( (p == buf) && (stream->precision != 0) )
    /*
     * Still nothing queued for output, but the `precision' has not been
     * explicitly specified as zero, (which is necessary if no output for
     * an input value of zero is desired); queue exactly one zero digit.
     */
    *p++ = '0';

  if( stream->width > (width = p - buf) )
    /*
     * Specified field width exceeds the minimum required...
     * Adjust so that we retain only the additional padding width.
     */
    stream->width -= width;

  else
    /* Ignore any width specification which is insufficient.
     */
    stream->width = PFORMAT_IGNORE;

  if( ((width = stream->width) > 0)
  &&  (fmt != 'o') && (stream->flags & PFORMAT_HASHED)  )
    /*
     * For `%#x' or `%#X' formats, (which have the `#' flag set),
     * further reduce the padding width to accommodate the radix
     * indicating prefix.
     */
    width -= 2;

  if(  (width > 0) && (stream->precision < 0)
  &&  ((stream->flags & PFORMAT_JUSTIFY) == PFORMAT_ZEROFILL)  )
    /*
     * When the `0' flag is set, and not overridden by the `-' flag,
     * or by a specified precision, add sufficient leading zeros to
     * consume the remaining field width.
     */
    while( width-- > 0 )
      *p++ = '0';

  if( (fmt != 'o') && (stream->flags & PFORMAT_HASHED) )
  {
    /* For formats other than octal, the PFORMAT_HASHED output style
     * requires the addition of a two character radix indicator, as a
     * prefix to the actual encoded numeric value.
     */
    *p++ = fmt;
    *p++ = '0';
  }

  if( (width > 0) && ((stream->flags & PFORMAT_LJUSTIFY) == 0) )
    /*
     * When not doing flush left justification, (i.e. the `-' flag
     * is not set), any residual unreserved field width must appear
     * as blank padding, to the left of the output value.
     */
    while( width-- > 0 )
      __pformat_putc( '\x20', stream );

  while( p > buf )
    /*
     * Move the queued output from the local buffer to the ultimate
     * destination, in LIFO order.
     */
    __pformat_putc( *--p, stream );

  /* If we still haven't consumed the entire specified field width,
   * we must be doing flush left justification; any residual width
   * must be filled with blanks, to the right of the output value.
   */
  while( width-- > 0 )
    __pformat_putc( '\x20', stream );
}

typedef union
{
  /* A multifaceted representation of an IEEE extended precision,
   * (80-bit), floating point number, facilitating access to its
   * component parts.
   */
  double                 __pformat_fpreg_double_t;
  long double            __pformat_fpreg_ldouble_t;
  struct
  { unsigned long long   __pformat_fpreg_mantissa;
    signed short         __pformat_fpreg_exponent;
  };
  unsigned short         __pformat_fpreg_bitmap[5];
  unsigned long          __pformat_fpreg_bits;
} __pformat_fpreg_t;

#ifdef _WIN32
/* TODO: make this unconditional in final release...
 * (see note at head of associated `#else' block.
 */
#include "../gdtoa/gdtoa.h"

static
char *__pformat_cvt( int mode, __pformat_fpreg_t x, int nd, int *dp, int *sign )
{
  /* Helper function, derived from David M. Gay's `g_xfmt()', calling
   * his `__gdtoa()' function in a manner to provide extended precision
   * replacements for `ecvt()' and `fcvt()'.
   */
  int k; unsigned int e = 0; char *ep;
  static FPI fpi = { 64, 1-16383-64+1, 32766-16383-64+1, FPI_Round_near, 0, 14 /* Int_max */ };
 
  /* Classify the argument into an appropriate `__gdtoa()' category...
   */
  if( (k = __fpclassifyl( x.__pformat_fpreg_ldouble_t )) & FP_NAN )
    /*
     * identifying infinities or not-a-number...
     */
    k = (k & FP_NORMAL) ? STRTOG_Infinite : STRTOG_NaN;

  else if( k & FP_NORMAL )
  {
    /* normal and near-zero `denormals'...
     */
    if( k & FP_ZERO )
    {
      /* with appropriate exponent adjustment for a `denormal'...
       */
      k = STRTOG_Denormal;
      e = 1 - 0x3FFF - 63;
    }
    else
    {
      /* or with `normal' exponent adjustment...
       */
      k = STRTOG_Normal;
      e = (x.__pformat_fpreg_exponent & 0x7FFF) - 0x3FFF - 63;
    }
  }

  else
    /* or, if none of the above, it's a zero, (positive or negative).
     */
    k = STRTOG_Zero;

  /* Check for negative values, always treating NaN as unsigned...
   * (return value is zero for positive/unsigned; non-zero for negative).
   */
  *sign = (k == STRTOG_NaN) ? 0 : x.__pformat_fpreg_exponent & 0x8000;

  /* Finally, get the raw digit string, and radix point position index.
   */
  return __gdtoa( &fpi, e, &x.__pformat_fpreg_bits, &k, mode, nd, dp, &ep );
}

static
char *__pformat_ecvt( long double x, int precision, int *dp, int *sign )
{
  /* A convenience wrapper for the above...
   * it emulates `ecvt()', but takes a `long double' argument.
   */
  __pformat_fpreg_t z; z.__pformat_fpreg_ldouble_t = x;
  return __pformat_cvt( 2, z, precision, dp, sign );
}

static
char *__pformat_fcvt( long double x, int precision, int *dp, int *sign )
{
  /* A convenience wrapper for the above...
   * it emulates `fcvt()', but takes a `long double' argument.
   */
  __pformat_fpreg_t z; z.__pformat_fpreg_ldouble_t = x;
  return __pformat_cvt( 3, z, precision, dp, sign );
}

/* The following are required, to clean up the `__gdtoa()' memory pool,
 * after processing the data returned by the above.
 */
#define __pformat_ecvt_release( value ) __freedtoa( value )
#define __pformat_fcvt_release( value ) __freedtoa( value )

#else
/*
 * TODO: remove this before final release; it is included here as a
 * convenience for testing, without requiring a working `__gdtoa()'.
 */
static
char *__pformat_ecvt( long double x, int precision, int *dp, int *sign )
{
  /* Define in terms of `ecvt()'...
   */
  char *retval = ecvt( (double)(x), precision, dp, sign );
  if( isinf( x ) || isnan( x ) )
  {
    /* emulating `__gdtoa()' reporting for infinities and NaN.
     */
    *dp = PFORMAT_INFNAN;
    if( *retval == '-' )
    {
      /* Need to force the `sign' flag, (particularly for NaN).
       */
      ++retval; *sign = 1;
    }
  }
  return retval;
}

static
char *__pformat_fcvt( long double x, int precision, int *dp, int *sign )
{
  /* Define in terms of `fcvt()'...
   */
  char *retval = fcvt( (double)(x), precision, dp, sign );
  if( isinf( x ) || isnan( x ) )
  {
    /* emulating `__gdtoa()' reporting for infinities and NaN.
     */
    *dp = PFORMAT_INFNAN;
    if( *retval == '-' )
    {
      /* Need to force the `sign' flag, (particularly for NaN).
       */
      ++retval; *sign = 1;
    }
  }
  return retval;
}

/* No memory pool clean up needed, for these emulated cases...
 */
#define __pformat_ecvt_release( value ) /* nothing to be done */
#define __pformat_fcvt_release( value ) /* nothing to be done */

/* TODO: end of conditional to be removed. */
#endif

static
void __pformat_emit_radix_point( __pformat_t *stream )
{
  /* Helper to place a localised representation of the radix point
   * character at the ultimate destination, when formatting fixed or
   * floating point numbers.
   */
  if( stream->rplen == PFORMAT_RPINIT )
  {
    /* Radix point initialisation not yet completed;
     * establish a multibyte to `wchar_t' converter...
     */
    int len; wchar_t rpchr; mbstate_t state;
    
    /* Initialise the conversion state...
     */
    memset( &state, 0, sizeof( state ) );

    /* Fetch and convert the localised radix point representation...
     */
    if( (len = mbrtowc( &rpchr, localeconv()->decimal_point, 16, &state )) > 0 )
      /*
       * and store it, if valid.
       */
      stream->rpchr = rpchr;

    /* In any case, store the reported effective multibyte length,
     * (or the error flag), marking initialisation as `done'.
     */
    stream->rplen = len;
  }

  if( stream->rpchr != (wchar_t)(0) )
  {
    /* We have a localised radix point mark;
     * establish a converter to make it a multibyte character...
     */
#ifdef __BUILD_WIDEAPI
   __pformat_putc (stream->rpchr, stream);
#else
    int len; char buf[len = stream->rplen]; mbstate_t state;

    /* Initialise the conversion state...
     */
    memset( &state, 0, sizeof( state ) );

    /* Convert the `wchar_t' representation to multibyte...
     */
    if( (len = wcrtomb( buf, stream->rpchr, &state )) > 0 )
    {
      /* and copy to the output destination, when valid...
       */
      char *p = buf;
      while( len-- > 0 )
	__pformat_putc( *p++, stream );
    }

    else
      /* otherwise fall back to plain ASCII '.'...
       */
      __pformat_putc( '.', stream );
#endif
  }
  else
    /* No localisation: just use ASCII '.'...
     */
    __pformat_putc( '.', stream );
}

static
void __pformat_emit_numeric_value( int c, __pformat_t *stream )
{
  /* Convenience helper to transfer numeric data from an internal
   * formatting buffer to the ultimate destination...
   */
  if( c == '.' )
    /*
     * converting this internal representation of the the radix
     * point to the appropriately localised representation...
     */
    __pformat_emit_radix_point( stream );
  else if (c == ',')
    {
      wchar_t wcs;
      if ((wcs = stream->thousands_chr) != 0)
	__pformat_wputchars (&wcs, 1, stream);
    }
  else
    /* and passing all other characters through, unmodified.
     */
    __pformat_putc( c, stream );
}

static
void __pformat_emit_inf_or_nan( int sign, char *value, __pformat_t *stream )
{
  /* Helper to emit INF or NAN where a floating point value
   * resolves to one of these special states.
   */
  int i;
  char buf[4];
  char *p = buf;

  /* We use the string formatting helper to display INF/NAN,
   * but we don't want truncation if the precision set for the
   * original floating point output request was insufficient;
   * ignore it!
   */
  stream->precision = PFORMAT_IGNORE;

  if( sign )
    /*
     * Negative infinity: emit the sign...
     */
    *p++ = '-';

  else if( stream->flags & PFORMAT_POSITIVE )
    /*
     * Not negative infinity, but '+' flag is in effect;
     * thus, we emit a positive sign...
     */
    *p++ = '+';

  else if( stream->flags & PFORMAT_ADDSPACE )
    /*
     * No sign required, but space was reserved for it...
     */
    *p++ = '\x20';

  /* Copy the appropriate status indicator, up to a maximum of
   * three characters, transforming to the case corresponding to
   * the format specification...
   */
  for( i = 3; i > 0; --i )
    *p++ = (*value++ & ~PFORMAT_XCASE) | (stream->flags & PFORMAT_XCASE);

  /* and emit the result.
   */
  __pformat_putchars( buf, p - buf, stream );
}

static
void __pformat_emit_float( int sign, char *value, int len, __pformat_t *stream )
{
  /* Helper to emit a fixed point representation of numeric data,
   * as encoded by a prior call to `ecvt()' or `fcvt()'; (this does
   * NOT include the exponent, for floating point format).
   */
  if( len > 0 )
  {
    /* The magnitude of `x' is greater than or equal to 1.0...
     * reserve space in the output field, for the required number of
     * decimal digits to be placed before the decimal point...
     */
    if( stream->width >= len)
      /*
       * adjusting as appropriate, when width is sufficient...
       */
      stream->width -= len;

    else
      /* or simply ignoring the width specification, if not.
       */
      stream->width = PFORMAT_IGNORE;
  }

  else if( stream->width > 0 )
    /*
     * The magnitude of `x' is less than 1.0...
     * reserve space for exactly one zero before the decimal point.
     */
    stream->width--;

  /* Reserve additional space for the digits which will follow the
   * decimal point...
   */
  if( (stream->width >= 0) && (stream->width > stream->precision) )
    /*
     * adjusting appropriately, when sufficient width remains...
     * (note that we must check both of these conditions, because
     * precision may be more negative than width, as a result of
     * adjustment to provide extra padding when trailing zeros
     * are to be discarded from "%g" format conversion with a
     * specified field width, but if width itself is negative,
     * then there is explicitly to be no padding anyway).
     */
    stream->width -= stream->precision;

  else
    /* or again, ignoring the width specification, if not.
     */
    stream->width = PFORMAT_IGNORE;

  /* Reserve space in the output field, for display of the decimal point,
   * unless the precision is explicity zero, with the `#' flag not set.
   */
  if ((stream->width > 0)
      && ((stream->precision > 0) || (stream->flags & PFORMAT_HASHED)))
    stream->width--;

  if (len > 0 && (stream->flags & PFORMAT_GROUPED) != 0 && stream->thousands_chr != 0)
    {
      int cths = ((len + 2) / 3) - 1;
      while (cths > 0 && stream->width > 0)
        {
          --cths; stream->width--;
        }
    }

  /* Reserve space in the output field, for display of the sign of the
   * formatted value, if required; (i.e. if the value is negative, or if
   * either the `space' or `+' formatting flags are set).
   */
  if( (stream->width > 0) && (sign || (stream->flags & PFORMAT_SIGNED)) )
    stream->width--;

  /* Emit any padding space, as required to correctly right justify
   * the output within the alloted field width.
   */
  if( (stream->width > 0) && ((stream->flags & PFORMAT_JUSTIFY) == 0) )
    while( stream->width-- > 0 )
      __pformat_putc( '\x20', stream );

  /* Emit the sign indicator, as appropriate...
   */
  if( sign )
    /*
     * mandatory, for negative values...
     */
    __pformat_putc( '-', stream );

  else if( stream->flags & PFORMAT_POSITIVE )
    /*
     * optional, for positive values...
     */
    __pformat_putc( '+', stream );

  else if( stream->flags & PFORMAT_ADDSPACE )
    /*
     * or just fill reserved space, when the space flag is in effect.
     */
    __pformat_putc( '\x20', stream );

  /* If the `0' flag is in effect, and not overridden by the `-' flag,
   * then zero padding, to fill out the field, goes here...
   */
  if(  (stream->width > 0)
  &&  ((stream->flags & PFORMAT_JUSTIFY) == PFORMAT_ZEROFILL)  )
    while( stream->width-- > 0 )
      __pformat_putc( '0', stream );

  /* Emit the digits of the encoded numeric value...
   */
  if( len > 0 )
  {
    /*
     * ...beginning with those which precede the radix point,
     * and appending any necessary significant trailing zeros.
     */
    do {
      __pformat_putc( *value ? *value++ : '0', stream);
      --len;
      if (len != 0 && (stream->flags & PFORMAT_GROUPED) != 0 && stream->thousands_chr != 0
	  && (len % 3) == 0)
	__pformat_wputchars (&stream->thousands_chr, 1, stream);
    }
    while (len > 0);
  }
  else
    /* The magnitude of the encoded value is less than 1.0, so no
     * digits precede the radix point; we emit a mandatory initial
     * zero, followed immediately by the radix point.
     */
    __pformat_putc( '0', stream );

  /* Unless the encoded value is integral, AND the radix point
   * is not expressly demanded by the `#' flag, we must insert
   * the appropriately localised radix point mark here...
   */
  if( (stream->precision > 0) || (stream->flags & PFORMAT_HASHED) )
    __pformat_emit_radix_point( stream );

  /* When the radix point offset, `len', is negative, this implies
   * that additional zeros must appear, following the radix point,
   * and preceding the first significant digit...
   */
  if( len < 0 )
  {
    /* To accommodate these, we adjust the precision, (reducing it
     * by adding a negative value), and then we emit as many zeros
     * as are required.
     */
    stream->precision += len;
    do __pformat_putc( '0', stream );
       while( ++len < 0 );
  }

  /* Now we emit any remaining significant digits, or trailing zeros,
   * until the required precision has been achieved.
   */
  while( stream->precision-- > 0 )
    __pformat_putc( *value ? *value++ : '0', stream );
}

static
void __pformat_emit_efloat( int sign, char *value, int e, __pformat_t *stream )
{
  /* Helper to emit a floating point representation of numeric data,
   * as encoded by a prior call to `ecvt()' or `fcvt()'; (this DOES
   * include the following exponent).
   */
  int exp_width = 1;
  __pformat_intarg_t exponent; exponent.__pformat_llong_t = e -= 1;

  /* Determine how many digit positions are required for the exponent.
   */
  while( (e /= 10) != 0 )
    exp_width++;

  /* Ensure that this is at least as many as the standard requirement.
   */
  if( exp_width < stream->expmin )
    exp_width = stream->expmin;

  /* Adjust the residual field width allocation, to allow for the
   * number of exponent digits to be emitted, together with a sign
   * and exponent separator...
   */
  if( stream->width > (exp_width += 2) )
    stream->width -= exp_width;
  
  else
    /* ignoring the field width specification, if insufficient.
     */
    stream->width = PFORMAT_IGNORE;

  /* Emit the significand, as a fixed point value with one digit
   * preceding the radix point.
   */
  __pformat_emit_float( sign, value, 1, stream );

  /* Reset precision, to ensure the mandatory minimum number of
   * exponent digits will be emitted, and set the flags to ensure
   * the sign is displayed.
   */
  stream->precision = stream->expmin;
  stream->flags |= PFORMAT_SIGNED;

  /* Emit the exponent separator.
   */
  __pformat_putc( ('E' | (stream->flags & PFORMAT_XCASE)), stream );

  /* Readjust the field width setting, such that it again allows
   * for the digits of the exponent, (which had been discounted when
   * computing any left side padding requirement), so that they are
   * correctly included in the computation of any right side padding
   * requirement, (but here we exclude the exponent separator, which
   * has been emitted, and so counted already).
   */
  stream->width += exp_width - 1;

  /* And finally, emit the exponent itself, as a signed integer,
   * with any padding required to achieve flush left justification,
   * (which will be added automatically, by `__pformat_int()').
   */
  __pformat_int( exponent, stream );
}

static
void __pformat_float( long double x, __pformat_t *stream )
{
  /* Handler for `%f' and `%F' format specifiers.
   *
   * This wraps calls to `__pformat_cvt()', `__pformat_emit_float()'
   * and `__pformat_emit_inf_or_nan()', as appropriate, to achieve
   * output in fixed point format.
   */
  int sign, intlen; char *value;
 
  /* Establish the precision for the displayed value, defaulting to six
   * digits following the decimal point, if not explicitly specified.
   */
  if( stream->precision < 0 )
    stream->precision = 6;

  /* Encode the input value as ASCII, for display...
   */
  value = __pformat_fcvt( x, stream->precision, &intlen, &sign );

  if( intlen == PFORMAT_INFNAN )
    /*
     * handle cases of `infinity' or `not-a-number'...
     */
    __pformat_emit_inf_or_nan( sign, value, stream );

  else
  { /* or otherwise, emit the formatted result.
     */
    __pformat_emit_float( sign, value, intlen, stream );

    /* and, if there is any residual field width as yet unfilled,
     * then we must be doing flush left justification, so pad out to
     * the right hand field boundary.
     */
    while( stream->width-- > 0 )
      __pformat_putc( '\x20', stream );
  }

  /* Clean up `__pformat_fcvt()' memory allocation for `value'...
   */
  __pformat_fcvt_release( value );
}

#ifdef __ENABLE_DFP

typedef struct decimal128_decode {
  int64_t significand[2];
  int32_t exponent;
  int sig_neg;
  int exp_neg;
} decimal128_decode;

static uint32_t dec128_decode(decimal128_decode *result, const _Decimal128 deci){
  int64_t significand2;
  int64_t significand1;
  int32_t exp_part;
  int8_t sig_sign;
  ud128 in;
  in.d = deci;

  if(in.t0.bits == 0x3){ /*case 11 */
    /* should not enter here */
    sig_sign = in.t2.sign;
    exp_part = in.t2.exponent;
    significand1 = in.t2.mantissaL;
    significand2 = (in.t2.mantissaH | (0x1ULL << 49));
  } else {
    sig_sign = in.t1.sign;
    exp_part = in.t1.exponent;
    significand1 = in.t1.mantissaL;
    significand2 = in.t1.mantissaH;
  }
  exp_part -= 6176; /* exp bias */

  result->significand[0] = significand1;
  result->significand[1] = significand2; /* higher */
  result->exponent = exp_part;
  result->exp_neg = (exp_part < 0 )? 1 : 0;
  result->sig_neg = sig_sign;

  return 0;
}

static
void  __pformat_efloat_decimal(_Decimal128 x, __pformat_t *stream ){
  decimal128_decode in;
  char str_exp[8];
  char str_sig[40];
  int floatclass = __fpclassifyd128(x);

  /* precision control */
  int32_t prec = ( (stream->precision < 0) || (stream->precision > 38) ) ?
    6 : stream->precision;
  int32_t max_prec;
  int32_t exp_strlen;

  dec128_decode(&in,x);

  if((floatclass & FP_INFINITE) == FP_INFINITE){
    stream->precision = 3;
    if(stream->flags & PFORMAT_SIGNED)
      __pformat_putc( in.sig_neg ? '-' : '+', stream );
    __pformat_puts( (stream->flags & PFORMAT_XCASE) ? "inf" : "INF", stream);
    return;
  } else if(floatclass & FP_NAN){
    stream->precision = 3;
    if(stream->flags & PFORMAT_SIGNED)
      __pformat_putc( in.sig_neg ? '-' : '+', stream );
    __pformat_puts( (stream->flags & PFORMAT_XCASE) ? "nan" : "NAN", stream);
    return;
  }

  /* Stringify significand */
  __bigint_to_string(
    (uint32_t[4]){in.significand[0] & 0x0ffffffff, in.significand[0] >> 32, in.significand[1] & 0x0ffffffff, in.significand[1] >> 32 },
    4, str_sig, sizeof(str_sig));
  __bigint_trim_leading_zeroes(str_sig,1);
  max_prec = strlen(str_sig+1);

  /* Try to canonize exponent */
  in.exponent += max_prec;
  in.exp_neg = (in.exponent < 0 ) ? 1 : 0;

  /* stringify exponent */
  __bigint_to_string(
    (uint32_t[1]) { in.exp_neg ? -in.exponent : in.exponent},
    1, str_exp, sizeof(str_exp));
  exp_strlen = strlen(__bigint_trim_leading_zeroes(str_exp,3));

  /* account for dot, +-e */
  for(int32_t spacers = 0; spacers < stream->width - max_prec - exp_strlen - 4; spacers++)
    __pformat_putc( ' ', stream );

  /* optional sign */
  if (in.sig_neg || (stream->flags & PFORMAT_SIGNED)) {
    __pformat_putc( in.sig_neg ? '-' : '+', stream );
  } else if( stream->width - max_prec - exp_strlen - 4 > 0 ) {
    __pformat_putc( ' ', stream );
  }
  stream->width = 0;
  /* s.sss form */
  __pformat_putc(str_sig[0], stream);
  if(prec) {
    /* str_sig[prec+1] = '\0';*/
    __pformat_emit_radix_point(stream);
    __pformat_putchars(str_sig+1, prec, stream);

    /* Pad with 0s */
    for(int i = max_prec; i < prec; i++)
      __pformat_putc('0', stream);
  }

  stream->precision = exp_strlen; /* force puts to emit */

  __pformat_putc( ('E' | (stream->flags & PFORMAT_XCASE)), stream );
  __pformat_putc( in.exp_neg ? '-' : '+', stream );

  for(int32_t trailing = 0; trailing < 3 - exp_strlen; trailing++)
    __pformat_putc('0', stream);
  __pformat_putchars(str_exp, exp_strlen,stream);
}

static
void  __pformat_float_decimal(_Decimal128 x, __pformat_t *stream ){
  decimal128_decode in;
  char str_exp[8];
  char str_sig[40];
  int floatclass = __fpclassifyd128(x);

  /* precision control */
  int prec = ( (stream->precision < 0) || (stream->precision > 38) ) ?
    6 : stream->precision;
  int max_prec;

  dec128_decode(&in,x);

  if((floatclass & FP_INFINITE) == FP_INFINITE){
    stream->precision = 3;
    if(stream->flags & PFORMAT_SIGNED)
      __pformat_putc( in.sig_neg ? '-' : '+', stream );
    __pformat_puts( (stream->flags & PFORMAT_XCASE) ? "inf" : "INF", stream);
    return;
  } else if(floatclass & FP_NAN){
    stream->precision = 3;
    if(stream->flags & PFORMAT_SIGNED)
      __pformat_putc( in.sig_neg ? '-' : '+', stream );
    __pformat_puts( (stream->flags & PFORMAT_XCASE) ? "nan" : "NAN", stream);
    return;
  }

  /* Stringify significand */
  __bigint_to_string(
    (uint32_t[4]){in.significand[0] & 0x0ffffffff, in.significand[0] >> 32, in.significand[1] & 0x0ffffffff, in.significand[1] >> 32 },
    4, str_sig, sizeof(str_sig));
  __bigint_trim_leading_zeroes(str_sig,0);
  max_prec = strlen(str_sig);

  /* stringify exponent */
  __bigint_to_string(
    (uint32_t[1]) { in.exp_neg ? -in.exponent : in.exponent},
    1, str_exp, sizeof(str_exp));
  __bigint_trim_leading_zeroes(str_exp,0);

  int32_t decimal_place = max_prec + in.exponent;
  int32_t sig_written = 0;

  /*account for . +- */
  for(int32_t spacers = 0; spacers < stream->width - decimal_place - prec - 2; spacers++)
    __pformat_putc( ' ', stream );

  if (in.sig_neg || (stream->flags & PFORMAT_SIGNED)) {
    __pformat_putc( in.sig_neg ? '-' : '+', stream );
  } else if(stream->width - decimal_place - prec - 1 > 0){
    __pformat_putc( ' ', stream );
  }

  if(decimal_place <= 0){ /* easy mode */
    __pformat_putc( '0', stream );
    points:
    __pformat_emit_radix_point(stream);
    for(int32_t written = 0; written < prec; written++){
      if(decimal_place < 0){ /* leading 0s */
        decimal_place++;
        __pformat_putc( '0', stream );
      /* significand */
      } else if ( sig_written < max_prec ){
        __pformat_putc( str_sig[sig_written], stream );
        sig_written++;
      } else { /* trailing 0s */
        __pformat_putc( '0', stream );
      }
    }
  } else { /* hard mode */
    for(; sig_written < decimal_place; sig_written++){
      __pformat_putc( str_sig[sig_written], stream );
      if(sig_written == max_prec - 1) break;
    }
    decimal_place -= sig_written;
    for(; decimal_place > 0; decimal_place--)
      __pformat_putc( '0', stream );
      goto points;
  }

  return;
}

static
void  __pformat_gfloat_decimal(_Decimal128 x, __pformat_t *stream ){
  int prec = ( (stream->precision < 0)) ?
    6 : stream->precision;
  decimal128_decode in;
  dec128_decode(&in,x);
  if(in.exponent > prec) __pformat_efloat_decimal(x,stream);
  else __pformat_float_decimal(x,stream);
}

#endif /* __ENABLE_DFP */

static
void __pformat_efloat( long double x, __pformat_t *stream )
{
  /* Handler for `%e' and `%E' format specifiers.
   *
   * This wraps calls to `__pformat_cvt()', `__pformat_emit_efloat()'
   * and `__pformat_emit_inf_or_nan()', as appropriate, to achieve
   * output in floating point format.
   */
  int sign, intlen; char *value;
 
  /* Establish the precision for the displayed value, defaulting to six
   * digits following the decimal point, if not explicitly specified.
   */
  if( stream->precision < 0 )
    stream->precision = 6;

  /* Encode the input value as ASCII, for display...
   */
  value = __pformat_ecvt( x, stream->precision + 1, &intlen, &sign );

  if( intlen == PFORMAT_INFNAN )
    /*
     * handle cases of `infinity' or `not-a-number'...
     */
    __pformat_emit_inf_or_nan( sign, value, stream );

  else
    /* or otherwise, emit the formatted result.
     */
    __pformat_emit_efloat( sign, value, intlen, stream );

  /* Clean up `__pformat_ecvt()' memory allocation for `value'...
   */
  __pformat_ecvt_release( value );
}

static
void __pformat_gfloat( long double x, __pformat_t *stream )
{
  /* Handler for `%g' and `%G' format specifiers.
   *
   * This wraps calls to `__pformat_cvt()', `__pformat_emit_float()',
   * `__pformat_emit_efloat()' and `__pformat_emit_inf_or_nan()', as
   * appropriate, to achieve output in the more suitable of either
   * fixed or floating point format.
   */
  int sign, intlen; char *value;
 
  /* Establish the precision for the displayed value, defaulting to
   * six significant digits, if not explicitly specified...
   */
  if( stream->precision < 0 )
    stream->precision = 6;

  /* or to a minimum of one digit, otherwise...
   */
  else if( stream->precision == 0 )
    stream->precision = 1;

  /* Encode the input value as ASCII, for display.
   */
  value = __pformat_ecvt( x, stream->precision, &intlen, &sign );

  if( intlen == PFORMAT_INFNAN )
    /*
     * Handle cases of `infinity' or `not-a-number'.
     */
    __pformat_emit_inf_or_nan( sign, value, stream );

  else if( (-4 < intlen) && (intlen <= stream->precision) )
  {
    /* Value lies in the acceptable range for fixed point output,
     * (i.e. the exponent is no less than minus four, and the number
     * of significant digits which precede the radix point is fewer
     * than the least number which would overflow the field width,
     * specified or implied by the established precision).
     */
    if( (stream->flags & PFORMAT_HASHED) == PFORMAT_HASHED )
      /*
       * The `#' flag is in effect...
       * Adjust precision to retain the specified number of significant
       * digits, with the proper number preceding the radix point, and
       * the balance following it...
       */
      stream->precision -= intlen;
    
    else
      /* The `#' flag is not in effect...
       * Here we adjust the precision to accommodate all digits which
       * precede the radix point, but we truncate any balance following
       * it, to suppress output of non-significant trailing zeros...
       */
      if( ((stream->precision = strlen( value ) - intlen) < 0)
        /*
	 * This may require a compensating adjustment to the field
	 * width, to accommodate significant trailing zeros, which
	 * precede the radix point...
	 */
      && (stream->width > 0)  )
	stream->width += stream->precision;

    /* Now, we format the result as any other fixed point value.
     */
    __pformat_emit_float( sign, value, intlen, stream );

    /* If there is any residual field width as yet unfilled, then
     * we must be doing flush left justification, so pad out to the
     * right hand field boundary.
     */
    while( stream->width-- > 0 )
      __pformat_putc( '\x20', stream );
  }

  else
  { /* Value lies outside the acceptable range for fixed point;
     * one significant digit will precede the radix point, so we
     * decrement the precision to retain only the appropriate number
     * of additional digits following it, when we emit the result
     * in floating point format.
     */
    if( (stream->flags & PFORMAT_HASHED) == PFORMAT_HASHED )
      /*
       * The `#' flag is in effect...
       * Adjust precision to emit the specified number of significant
       * digits, with one preceding the radix point, and the balance
       * following it, retaining any non-significant trailing zeros
       * which are required to exactly match the requested precision...
       */
      stream->precision--;

    else
      /* The `#' flag is not in effect...
       * Adjust precision to emit only significant digits, with one
       * preceding the radix point, and any others following it, but
       * suppressing non-significant trailing zeros...
       */
      stream->precision = strlen( value ) - 1;

    /* Now, we format the result as any other floating point value.
     */
    __pformat_emit_efloat( sign, value, intlen, stream );
  }

  /* Clean up `__pformat_ecvt()' memory allocation for `value'.
   */
  __pformat_ecvt_release( value );
}

static
void __pformat_emit_xfloat( __pformat_fpreg_t value, __pformat_t *stream )
{
  /* Helper for emitting floating point data, originating as
   * either `double' or `long double' type, as a hexadecimal
   * representation of the argument value.
   */
  char buf[18 + 6], *p = buf;
  __pformat_intarg_t exponent; short exp_width = 2;

  /* The mantissa field of the argument value representation can
   * accommodate at most 16 hexadecimal digits, of which one will
   * be placed before the radix point, leaving at most 15 digits
   * to satisfy any requested precision; thus...
   */
  if( (stream->precision >= 0) && (stream->precision < 15) )
  {
    /* When the user specifies a precision within this range,
     * we want to adjust the mantissa, to retain just the number
     * of digits required, rounding up when the high bit of the
     * leftmost discarded digit is set; (mask of 0x08 accounts
     * for exactly one digit discarded, shifting 4 bits per
     * digit, with up to 14 additional digits, to consume the
     * full availability of 15 precision digits).
     *
     * However, before we perform the rounding operation, we
     * normalise the mantissa, shifting it to the left by as many
     * bit positions may be necessary, until its highest order bit
     * is set, thus preserving the maximum number of bits in the
     * rounded result as possible.
     */
    while( value.__pformat_fpreg_mantissa < (LLONG_MAX + 1ULL) )
      value.__pformat_fpreg_mantissa <<= 1;

    /* We then shift the mantissa one bit position back to the
     * right, to guard against possible overflow when the rounding
     * adjustment is added.
     */
    value.__pformat_fpreg_mantissa >>= 1;

    /* We now add the rounding adjustment, noting that to keep the
     * 0x08 mask aligned with the shifted mantissa, we also need to
     * shift it right by one bit initially, changing its starting
     * value to 0x04...
     */
    value.__pformat_fpreg_mantissa += 0x04LL << (4 * (14 - stream->precision));
    if( (value.__pformat_fpreg_mantissa & (LLONG_MAX + 1ULL)) == 0ULL )
      /*
       * When the rounding adjustment would not have overflowed,
       * then we shift back to the left again, to fill the vacated
       * bit we reserved to accommodate the carry.
       */
      value.__pformat_fpreg_mantissa <<= 1;

    else
      /* Otherwise the rounding adjustment would have overflowed,
       * so the carry has already filled the vacated bit; the effect
       * of this is equivalent to an increment of the exponent.
       */
      value.__pformat_fpreg_exponent++;

    /* We now complete the rounding to the required precision, by
     * shifting the unwanted digits out, from the right hand end of
     * the mantissa.
     */
    value.__pformat_fpreg_mantissa >>= 4 * (15 - stream->precision);
  }

  /* Encode the significant digits of the mantissa in hexadecimal
   * ASCII notation, ready for transfer to the output stream...
   */
  while( value.__pformat_fpreg_mantissa )
  {
    /* taking the rightmost digit in each pass...
     */
    int c = value.__pformat_fpreg_mantissa & 0xF;
    if( c == (int) value.__pformat_fpreg_mantissa)
    {
      /* inserting the radix point, when we reach the last,
       * (i.e. the most significant digit), unless we found no
       * less significant digits, with no mandatory radix point
       * inclusion, and no additional required precision...
       */
      if( (p > buf)
      ||  (stream->flags & PFORMAT_HASHED) || (stream->precision > 0)  )
      {
	/*
	 * Internally, we represent the radix point as an ASCII '.';
	 * we will replace it with any locale specific alternative,
	 * at the time of transfer to the ultimate destination.
	 */
	*p++ = '.';
      }

      /* If the most significant hexadecimal digit of the encoded
       * output value is greater than one, then the indicated value
       * will appear too large, by an additional binary exponent
       * corresponding to the number of higher order bit positions
       * which it occupies...
       */
      while( value.__pformat_fpreg_mantissa > 1 )
      {
	/* so reduce the exponent value to compensate...
	 */
	value.__pformat_fpreg_exponent--;
	value.__pformat_fpreg_mantissa >>= 1;
      }
    }

    else if( stream->precision > 0 )
      /*
       * we have not yet fulfilled the desired precision,
       * and we have not yet found the most significant digit,
       * so account for the current digit, within the field
       * width required to meet the specified precision.
       */
      stream->precision--;

    if( (c > 0) || (p > buf) || (stream->precision >= 0) )
    {
      /*
       * Ignoring insignificant trailing zeros, (unless required to
       * satisfy specified precision), store the current encoded digit
       * into the pending output buffer, in LIFO order, and using the
       * appropriate case for digits in the `A'..`F' range.
       */
      *p++ = c > 9 ? (c - 10 + 'A') | (stream->flags & PFORMAT_XCASE) : c + '0';
    }
    /* Shift out the current digit, (4-bit logical shift right),
     * to align the next more significant digit to be extracted,
     * and encoded in the next pass.
     */
    value.__pformat_fpreg_mantissa >>= 4;
  }

  if( p == buf )
  {
    /* Nothing has been queued for output...
     * We need at least one zero, and possibly a radix point.
     */
    if( (stream->precision > 0) || (stream->flags & PFORMAT_HASHED) )
      *p++ = '.';

    *p++ = '0';
  }

  if( stream->width > 0 )
  {
  /* Adjust the user specified field width, to account for the
   * number of digits minimally required, to display the encoded
   * value, at the requested precision.
   *
   * FIXME: this uses the minimum number of digits possible for
   * representation of the binary exponent, in strict conformance
   * with C99 and POSIX specifications.  Although there appears to
   * be no Microsoft precedent for doing otherwise, we may wish to
   * relate this to the `_get_output_format()' result, to maintain
   * consistency with `%e', `%f' and `%g' styles.
   */
    int min_width = p - buf;
    int exponent2 = value.__pformat_fpreg_exponent;

    /* If we have not yet queued sufficient digits to fulfil the
     * requested precision, then we must adjust the minimum width
     * specification, to accommodate the additional digits which
     * are required to do so.
     */
    if( stream->precision > 0 )
      min_width += stream->precision;

    /* Adjust the minimum width requirement, to accomodate the
     * sign, radix indicator and at least one exponent digit...
     */
    min_width += stream->flags & PFORMAT_SIGNED ? 6 : 5;
    while( (exponent2 = exponent2 / 10) != 0 )
    {
      /* and increase as required, if additional exponent digits
       * are needed, also saving the exponent field width adjustment,
       * for later use when that is emitted.
       */
      min_width++;
      exp_width++;
    }
  
    if( stream->width > min_width )
    {
      /* When specified field width exceeds the minimum required,
       * adjust to retain only the excess...
       */
      stream->width -= min_width;

      /* and then emit any required left side padding spaces.
       */
      if( (stream->flags & PFORMAT_JUSTIFY) == 0 )
	while( stream->width-- > 0 )
	  __pformat_putc( '\x20', stream );
    }

    else
      /* Specified field width is insufficient; just ignore it!
       */
      stream->width = PFORMAT_IGNORE;
  }

  /* Emit the sign of the encoded value, as required...
   */
  if( stream->flags & PFORMAT_NEGATIVE )
    /*
     * this is mandatory, to indicate a negative value...
     */
    __pformat_putc( '-', stream );

  else if( stream->flags & PFORMAT_POSITIVE )
    /*
     * but this is optional, for a positive value...
     */
    __pformat_putc( '+', stream );

  else if( stream->flags & PFORMAT_ADDSPACE )
    /*
     * with this optional alternative.
     */
    __pformat_putc( '\x20', stream );

  /* Prefix a `0x' or `0X' radix indicator to the encoded value,
   * with case appropriate to the format specification.
   */
  __pformat_putc( '0', stream );
  __pformat_putc( 'X' | (stream->flags & PFORMAT_XCASE), stream );
  
  /* If the `0' flag is in effect...
   * Zero padding, to fill out the field, goes here...
   */
  if( (stream->width > 0) && (stream->flags & PFORMAT_ZEROFILL) )
    while( stream->width-- > 0 )
      __pformat_putc( '0', stream );

  /* Next, we emit the encoded value, without its exponent...
   */
  while( p > buf )
    __pformat_emit_numeric_value( *--p, stream );

  /* followed by any additional zeros needed to satisfy the
   * precision specification...
   */
  while( stream->precision-- > 0 )
    __pformat_putc( '0', stream );

  /* then the exponent prefix, (C99 and POSIX specify `p'),
   * in the case appropriate to the format specification...
   */
  __pformat_putc( 'P' | (stream->flags & PFORMAT_XCASE), stream );

  /* and finally, the decimal representation of the binary exponent,
   * as a signed value with mandatory sign displayed, in a field width
   * adjusted to accommodate it, LEFT justified, with any additional
   * right side padding remaining from the original field width.
   */
  stream->width += exp_width;
  stream->flags |= PFORMAT_SIGNED;
  /* sign extend */
  exponent.__pformat_u128_t.t128.digits[1] = (value.__pformat_fpreg_exponent < 0) ? -1 : 0;
  exponent.__pformat_u128_t.t128.digits[0] = value.__pformat_fpreg_exponent;
  __pformat_int( exponent, stream );
}

static
void __pformat_xldouble( long double x, __pformat_t *stream )
{
  /* Handler for `%La' and `%LA' format specifiers, (with argument
   * value specified as `long double' type).
   */
  unsigned sign_bit = 0;
  __pformat_fpreg_t z; z.__pformat_fpreg_ldouble_t = x;

  /* First check for NaN; it is emitted unsigned...
   */
  if( isnan( x ) )
    __pformat_emit_inf_or_nan( sign_bit, "NaN", stream );

  else
  { /* Capture the sign bit up-front, so we can show it correctly
     * even when the argument value is zero or infinite.
     */
    if( (sign_bit = (z.__pformat_fpreg_exponent & 0x8000)) != 0 )
      stream->flags |= PFORMAT_NEGATIVE;

    /* Check for infinity, (positive or negative)...
     */
    if( isinf( x ) )
      /*
       * displaying the appropriately signed indicator,
       * when appropriate.
       */
      __pformat_emit_inf_or_nan( sign_bit, "Inf", stream );

    else
    { /* The argument value is a representable number...
       * extract the effective value of the biased exponent...
       */
      z.__pformat_fpreg_exponent &= 0x7FFF;
      if( z.__pformat_fpreg_exponent == 0 )
      {
	/* A biased exponent value of zero means either a
	 * true zero value, if the mantissa field also has
	 * a zero value, otherwise...
	 */
	if( z.__pformat_fpreg_mantissa != 0 )
	{
	  /* ...this mantissa represents a subnormal value;
	   * adjust the exponent, while shifting the mantissa
	   * to the left, until its leading bit is 1.
	   */
	  z.__pformat_fpreg_exponent = 1-0x3FFF;
	  while( (z.__pformat_fpreg_mantissa & (LLONG_MAX + 1ULL)) == 0 )
	  {
	    z.__pformat_fpreg_mantissa <<= 1;
	    --z.__pformat_fpreg_exponent;
	  }
	}
      }
      else
	/* This argument represents a non-zero normal number;
	 * eliminate the bias from the exponent...
	 */
	z.__pformat_fpreg_exponent -= 0x3FFF;

      /* Finally, hand the adjusted representation off to the
       * generalised hexadecimal floating point format handler...
       */
      __pformat_emit_xfloat( z, stream );
    }
  }
}

int
__pformat (int flags, void *dest, int max, const APICHAR *fmt, va_list argv)
{
  int c;
  int saved_errno = errno;

  __pformat_t stream =
  {
    /* Create and initialise a format control block
     * for this output request.
     */
    dest,					/* output goes to here        */
    flags &= PFORMAT_TO_FILE | PFORMAT_NOLIMIT,	/* only these valid initially */
    PFORMAT_IGNORE,				/* no field width yet         */
    PFORMAT_IGNORE,				/* nor any precision spec     */
    PFORMAT_RPINIT,				/* radix point uninitialised  */
    (wchar_t)(0),				/* leave it unspecified       */
    0,
    (wchar_t)(0),				/* leave it unspecified	      */
    0,						/* zero output char count     */
    max,					/* establish output limit     */
    PFORMAT_MINEXP				/* exponent chars preferred   */
  };

  format_scan: while( (c = *fmt++) != 0 )
  {
    /* Format string parsing loop...
     * The entry point is labelled, so that we can return to the start state
     * from within the inner `conversion specification' interpretation loop,
     * as soon as a conversion specification has been resolved.
     */
    if( c == '%' )
    {
      /* Initiate parsing of a `conversion specification'...
       */
      __pformat_intarg_t argval;
      __pformat_state_t  state = PFORMAT_INIT;
      __pformat_length_t length = PFORMAT_LENGTH_INT;

      /* Save the current format scan position, so that we can backtrack
       * in the event of encountering an invalid format specification...
       */
      const APICHAR *backtrack = fmt;

      /* Restart capture for dynamic field width and precision specs...
       */
      int *width_spec = &stream.width;

      /* Reset initial state for flags, width and precision specs...
       */
      stream.flags = flags;
      stream.width = stream.precision = PFORMAT_IGNORE;

      while( *fmt )
      {
	switch( c = *fmt++ )
	{
	  /* Data type specifiers...
	   * All are terminal, so exit the conversion spec parsing loop
	   * with a `goto format_scan', thus resuming at the outer level
	   * in the regular format string parser.
	   */
	  case '%':
	    /*
	     * Not strictly a data type specifier...
	     * it simply converts as a literal `%' character.
	     *
	     * FIXME: should we require this to IMMEDIATELY follow the
	     * initial `%' of the "conversion spec"?  (glibc `printf()'
	     * on GNU/Linux does NOT appear to require this, but POSIX
	     * and SUSv3 do seem to demand it).
	     */
	    __pformat_putc( c, &stream );
	    goto format_scan;

	  case 'C':
	    /*
	     * Equivalent to `%lc'; set `length' accordingly,
	     * and simply fall through.
	     */
	    length = PFORMAT_LENGTH_LONG;

	  case 'c':
	    /*
	     * Single, (or single multibyte), character output...
	     *
	     * We handle these by copying the argument into our local
	     * `argval' buffer, and then we pass the address of that to
	     * either `__pformat_putchars()' or `__pformat_wputchars()',
	     * as appropriate, effectively formatting it as a string of
	     * the appropriate type, with a length of one.
	     *
	     * A side effect of this method of handling character data
	     * is that, if the user sets a precision of zero, then no
	     * character is actually emitted; we don't want that, so we
	     * forcibly override any user specified precision.
	     */
	    stream.precision = PFORMAT_IGNORE;

	    /* Now we invoke the appropriate format handler...
	     */
	    if( (length == PFORMAT_LENGTH_LONG)
	    ||  (length == PFORMAT_LENGTH_LLONG)  )
	    {
	      /* considering any `long' type modifier as a reference to
	       * `wchar_t' data, (which is promoted to an `int' argument)...
	       */
	      wchar_t iargval = (wchar_t)(va_arg( argv, int ));
	      __pformat_wputchars( &iargval, 1, &stream );
	    }
	    else
	    { /* while anything else is simply taken as `char', (which
	       * is also promoted to an `int' argument)...
	       */
	      argval.__pformat_uchar_t = (unsigned char)(va_arg( argv, int ));
	      __pformat_putchars( (char *)(&argval), 1, &stream );
	    }
	    goto format_scan;

	  case 'S':
	    /*
	     * Equivalent to `%ls'; set `length' accordingly,
	     * and simply fall through.
	     */
	    length = PFORMAT_LENGTH_LONG;

	  case 's':
	    if( (length == PFORMAT_LENGTH_LONG)
	         || (length == PFORMAT_LENGTH_LLONG))
	    {
	      /* considering any `long' type modifier as a reference to
	       * a `wchar_t' string...
	       */
	      __pformat_wcputs( va_arg( argv, wchar_t * ), &stream );
	    }
	    else
	      /* This is normal string output;
	       * we simply invoke the appropriate handler...
	       */
	      __pformat_puts( va_arg( argv, char * ), &stream );
	    goto format_scan;
	  case 'm': /* strerror (errno)  */
	    __pformat_puts (strerror (saved_errno), &stream);
	    goto format_scan;

	  case 'o':
	  case 'u':
	  case 'x':
	  case 'X':
	    /*
	     * Unsigned integer values; octal, decimal or hexadecimal format...
	     */
#if __ENABLE_PRINTF128
        argval.__pformat_u128_t.t128.digits[1] = 0LL; /* no sign extend needed */
	    if( length == PFORMAT_LENGTH_LLONG128 )
	      argval.__pformat_u128_t.t128 = va_arg( argv, __tI128 );
	    else
#endif
        if( length == PFORMAT_LENGTH_LLONG ) {
	      /*
	       * with an `unsigned long long' argument, which we
	       * process `as is'...
	       */
	      argval.__pformat_ullong_t = va_arg( argv, unsigned long long );

	    } else if( length == PFORMAT_LENGTH_LONG ) {
	      /*
	       * or with an `unsigned long', which we promote to
	       * `unsigned long long'...
	       */
	      argval.__pformat_ullong_t = va_arg( argv, unsigned long );

	    } else
	    { /* or for any other size, which will have been promoted
	       * to `unsigned int', we select only the appropriately sized
	       * least significant segment, and again promote to the same
	       * size as `unsigned long long'...
	       */ 
	      argval.__pformat_ullong_t = va_arg( argv, unsigned int );
	      if( length == PFORMAT_LENGTH_SHORT )
		/*
		 * from `unsigned short'...
		 */
		argval.__pformat_ullong_t = argval.__pformat_ushort_t;

	      else if( length == PFORMAT_LENGTH_CHAR )
		/*
		 * or even from `unsigned char'...
		 */
		argval.__pformat_ullong_t = argval.__pformat_uchar_t;
	    }

	    /* so we can pass any size of argument to either of two
	     * common format handlers...
	     */
	    if( c == 'u' )
	      /*
	       * depending on whether output is to be encoded in
	       * decimal format...
	       */
	      __pformat_int( argval, &stream );

	    else
	      /* or in octal or hexadecimal format...
	       */
	      __pformat_xint( c, argval, &stream );

	    goto format_scan;

	  case 'd':
	  case 'i':
	    /*
	     * Signed integer values; decimal format...
	     * This is similar to `u', but must process `argval' as signed,
	     * and be prepared to handle negative numbers.
	     */
	    stream.flags |= PFORMAT_NEGATIVE;
#if __ENABLE_PRINTF128
	    if( length == PFORMAT_LENGTH_LLONG128 ) {
	      argval.__pformat_u128_t.t128 = va_arg( argv, __tI128 );
          goto skip_sign; /* skip sign extend */
	    } else
#endif
	    if( length == PFORMAT_LENGTH_LLONG ){
	      /*
	       * The argument is a `long long' type...
	       */
	      argval.__pformat_u128_t.t128.digits[0] = va_arg( argv, long long );
	    } else if( length == PFORMAT_LENGTH_LONG ) {
	      /*
	       * or here, a `long' type...
	       */
	      argval.__pformat_u128_t.t128.digits[0] = va_arg( argv, long );
	    } else
	    { /* otherwise, it's an `int' type...
	       */
	      argval.__pformat_u128_t.t128.digits[0] = va_arg( argv, int );
	      if( length == PFORMAT_LENGTH_SHORT )
		/*
		 * but it was promoted from a `short' type...
		 */
		argval.__pformat_u128_t.t128.digits[0] = argval.__pformat_short_t;
	      else if( length == PFORMAT_LENGTH_CHAR )
		/*
		 * or even from a `char' type...
		 */
		argval.__pformat_u128_t.t128.digits[0] = argval.__pformat_char_t;
	    }
	    
	    /* In any case, all share a common handler...
	     */
        argval.__pformat_u128_t.t128.digits[1] = (argval.__pformat_llong_t < 0) ? -1LL : 0LL;
#if __ENABLE_PRINTF128
        skip_sign:
#endif
	    __pformat_int( argval, &stream );
	    goto format_scan;

	  case 'p':
	    /*
	     * Pointer argument; format as hexadecimal, subject to...
	     */
	    if( (state == PFORMAT_INIT) && (stream.flags == flags) )
	    {
	      /* Here, the user didn't specify any particular
	       * formatting attributes.  We must choose a default
	       * which will be compatible with Microsoft's (broken)
	       * scanf() implementation, (i.e. matching the default
	       * used by MSVCRT's printf(), which appears to resemble
	       * "%0.8X" for 32-bit pointers); in particular, we MUST
	       * NOT adopt a GNU-like format resembling "%#x", because
	       * Microsoft's scanf() will choke on the "0x" prefix.
	       */
	      stream.flags |= PFORMAT_ZEROFILL;
	      stream.precision = 2 * sizeof( uintptr_t );
	    }
	    argval.__pformat_u128_t.t128.digits[0] = va_arg( argv, uintptr_t );
	    argval.__pformat_u128_t.t128.digits[1] = 0;
	    __pformat_xint( 'x', argval, &stream );
	    goto format_scan;

	  case 'e':
	    /*
	     * Floating point format, with lower case exponent indicator
	     * and lower case `inf' or `nan' representation when required;
	     * select lower case mode, and simply fall through...
	     */
	    stream.flags |= PFORMAT_XCASE;

	  case 'E':
	    /*
	     * Floating point format, with upper case exponent indicator
	     * and upper case `INF' or `NAN' representation when required,
	     * (or lower case for all of these, on fall through from above);
	     * select lower case mode, and simply fall through...
	     */
#ifdef __ENABLE_DFP
	    if( stream.flags & PFORMAT_DECIM32 )
	      /* Is a 32bit decimal float */
	      __pformat_efloat_decimal((_Decimal128)va_arg( argv, _Decimal32 ), &stream );
	    else if( stream.flags & PFORMAT_DECIM64 )
	      /*
	       * Is a 64bit decimal float
	       */
	      __pformat_efloat_decimal((_Decimal128)va_arg( argv, _Decimal64 ), &stream );
	    else if( stream.flags & PFORMAT_DECIM128 )
	      /*
	       * Is a 128bit decimal float
	       */
	      __pformat_efloat_decimal(va_arg( argv, _Decimal128 ), &stream );
	    else
#endif /* __ENABLE_DFP */
	    if( stream.flags & PFORMAT_LDOUBLE )
	      /*
	       * for a `long double' argument...
	       */
	      __pformat_efloat( va_arg( argv, long double ), &stream );

	    else
	      /* or just a `double', which we promote to `long double',
	       * so the two may share a common format handler.
	       */
	      __pformat_efloat( (long double)(va_arg( argv, double )), &stream );

	    goto format_scan;

	  case 'f':
	    /*
	     * Fixed point format, using lower case for `inf' and
	     * `nan', when appropriate; select lower case mode, and
	     * simply fall through...
	     */
	    stream.flags |= PFORMAT_XCASE;

	  case 'F':
	    /*
	     * Fixed case format using upper case, or lower case on
	     * fall through from above, for `INF' and `NAN'...
	     */
#ifdef __ENABLE_DFP
	    if( stream.flags & PFORMAT_DECIM32 )
	      /* Is a 32bit decimal float */
	      __pformat_float_decimal((_Decimal128)va_arg( argv, _Decimal32 ), &stream );
	    else if( stream.flags & PFORMAT_DECIM64 )
	      /*
	       * Is a 64bit decimal float
	       */
	      __pformat_float_decimal((_Decimal128)va_arg( argv, _Decimal64 ), &stream );
	    else if( stream.flags & PFORMAT_DECIM128 )
	      /*
	       * Is a 128bit decimal float
	       */
	      __pformat_float_decimal(va_arg( argv, _Decimal128 ), &stream );
	    else
#endif /* __ENABLE_DFP */
	    if( stream.flags & PFORMAT_LDOUBLE )
	      /*
	       * for a `long double' argument...
	       */
	      __pformat_float( va_arg( argv, long double ), &stream );

	    else
	      /* or just a `double', which we promote to `long double',
	       * so the two may share a common format handler.
	       */
	      __pformat_float( (long double)(va_arg( argv, double )), &stream );

	    goto format_scan;

	  case 'g':
	    /*
	     * Generalised floating point format, with lower case
	     * exponent indicator when required; select lower case
	     * mode, and simply fall through...
	     */
	    stream.flags |= PFORMAT_XCASE;

	  case 'G':
	    /*
	     * Generalised floating point format, with upper case,
	     * or on fall through from above, with lower case exponent
	     * indicator when required...
	     */
#ifdef __ENABLE_DFP
	    if( stream.flags & PFORMAT_DECIM32 )
	      /* Is a 32bit decimal float */
	      __pformat_gfloat_decimal((_Decimal128)va_arg( argv, _Decimal32 ), &stream );
	    else if( stream.flags & PFORMAT_DECIM64 )
	      /*
	       * Is a 64bit decimal float
	       */
	      __pformat_gfloat_decimal((_Decimal128)va_arg( argv, _Decimal64 ), &stream );
	    else if( stream.flags & PFORMAT_DECIM128 )
	      /*
	       * Is a 128bit decimal float
	       */
	      __pformat_gfloat_decimal(va_arg( argv, _Decimal128 ), &stream );
	    else
#endif /* __ENABLE_DFP */
	   if( stream.flags & PFORMAT_LDOUBLE )
	      /*
	       * for a `long double' argument...
	       */
	      __pformat_gfloat( va_arg( argv, long double ), &stream );

	    else
	      /* or just a `double', which we promote to `long double',
	       * so the two may share a common format handler.
	       */
	      __pformat_gfloat( (long double)(va_arg( argv, double )), &stream );

	    goto format_scan;

	  case 'a':
	    /*
	     * Hexadecimal floating point format, with lower case radix
	     * and exponent indicators; select the lower case mode, and
	     * fall through...
	     */
	    stream.flags |= PFORMAT_XCASE;

	  case 'A':
	    /*
	     * Hexadecimal floating point format; handles radix and
	     * exponent indicators in either upper or lower case...
	     */
	    if( stream.flags & PFORMAT_LDOUBLE )
	      /*
	       * with a `long double' argument...
	       */
	      __pformat_xldouble( va_arg( argv, long double ), &stream );

	    else
	      /* or just a `double'.
	       */
	      __pformat_xldouble( (long double)(va_arg( argv, double )), &stream );

	    goto format_scan;

	  case 'n':
	    /*
	     * Save current output character count...
	     */
	    if( length == PFORMAT_LENGTH_CHAR )
	      /*
	       * to a signed `char' destination...
	       */
	      *va_arg( argv, char * ) = stream.count;

	    else if( length == PFORMAT_LENGTH_SHORT )
	      /*
	       * or to a signed `short'...
	       */
	      *va_arg( argv, short * ) = stream.count;

	    else if( length == PFORMAT_LENGTH_LONG )
	      /*
	       * or to a signed `long'...
	       */
	      *va_arg( argv, long * ) = stream.count;

	    else if( length == PFORMAT_LENGTH_LLONG )
	      /*
	       * or to a signed `long long'...
	       */
	      *va_arg( argv, long long * ) = stream.count;

	    else
	      /*
	       * or, by default, to a signed `int'.
	       */
	      *va_arg( argv, int * ) = stream.count;

	    goto format_scan;

	  /* Argument length modifiers...
	   * These are non-terminal; each sets the format parser
	   * into the PFORMAT_END state, and ends with a `break'.
	   */
	  case 'h':
	    /*
	     * Interpret the argument as explicitly of a `short'
	     * or `char' data type, truncated from the standard
	     * length defined for integer promotion.
	     */
	    if( *fmt == 'h' )
	    {
	      /* Modifier is `hh'; data type is `char' sized...
	       * Skip the second `h', and set length accordingly.
	       */
	      ++fmt;
	      length = PFORMAT_LENGTH_CHAR;
	    }

	    else
	      /* Modifier is `h'; data type is `short' sized...
	       */
	      length = PFORMAT_LENGTH_SHORT;

	    state = PFORMAT_END;
	    break;

	  case 'j':
	    /*
	     * Interpret the argument as being of the same size as
	     * a `intmax_t' entity...
	     */
	    length = __pformat_arg_length( intmax_t );
	    state = PFORMAT_END;
	    break;
	  
#	  ifdef _WIN32

	    case 'I':
	      /*
	       * The MSVCRT implementation of the printf() family of
	       * functions explicitly uses...
	       */
#ifdef __ENABLE_PRINTF128
	      if( (fmt[0] == '1') && (fmt[1] == '2') && (fmt[2] == '8')){
	        length = PFORMAT_LENGTH_LLONG128;
	        fmt += 3;
	      } else
#endif
	      if( (fmt[0] == '6') && (fmt[1] == '4') )
	      {
		/* I64' instead of `ll',
		 * when referring to `long long' integer types...
		 */
		length = PFORMAT_LENGTH_LLONG;
		fmt += 2;
	      } else
	      if( (fmt[0] == '3') && (fmt[1] == '2') )
	      {
		/* and `I32' instead of `l',
		 * when referring to `long' integer types...
		 */
		length = PFORMAT_LENGTH_LONG;
		fmt += 2;
	      }

	      else
		/* or unqualified `I' instead of `t' or `z',
		 * when referring to `ptrdiff_t' or `size_t' entities;
		 * (we will choose to map it to `ptrdiff_t').
		 */
		length = __pformat_arg_length( ptrdiff_t );

	      state = PFORMAT_END;
	      break;

#	  endif
	  
#ifdef __ENABLE_DFP
	  case 'H':
	      stream.flags |= PFORMAT_DECIM32;
	      state = PFORMAT_END;
	      break;

	  case 'D':
	    /*
	     * Interpret the argument as explicitly of a
	     * `_Decimal64' or `_Decimal128' data type.
	     */
	    if( *fmt == 'D' )
	    {
	      /* Modifier is `DD'; data type is `_Decimal128' sized...
	       * Skip the second `D', and set length accordingly.
	       */
	      ++fmt;
	      stream.flags |= PFORMAT_DECIM128;
	    }

	    else
	      /* Modifier is `D'; data type is `_Decimal64' sized...
	       */
	      stream.flags |= PFORMAT_DECIM64;

	      state = PFORMAT_END;
	      break;
#endif /* __ENABLE_DFP */
	  case 'l':
	    /*
	     * Interpret the argument as explicitly of a
	     * `long' or `long long' data type.
	     */
	    if( *fmt == 'l' )
	    {
	      /* Modifier is `ll'; data type is `long long' sized...
	       * Skip the second `l', and set length accordingly.
	       */
	      ++fmt;
	      length = PFORMAT_LENGTH_LLONG;
	    }

	    else
	      /* Modifier is `l'; data type is `long' sized...
	       */
	      length = PFORMAT_LENGTH_LONG;

	      state = PFORMAT_END;
	      break;

	  case 'L':
	    /*
	     * Identify the appropriate argument as a `long double',
	     * when associated with `%a', `%A', `%e', `%E', `%f', `%F',
	     * `%g' or `%G' format specifications.
	     */
	    stream.flags |= PFORMAT_LDOUBLE;
	    state = PFORMAT_END;
	    break;
	  
	  case 't':
	    /*
	     * Interpret the argument as being of the same size as
	     * a `ptrdiff_t' entity...
	     */
	    length = __pformat_arg_length( ptrdiff_t );
	    state = PFORMAT_END;
	    break;
	  
	  case 'z':
	    /*
	     * Interpret the argument as being of the same size as
	     * a `size_t' entity...
	     */
	    length = __pformat_arg_length( size_t );
	    state = PFORMAT_END;
	    break;
	  
	  /* Precision indicator...
	   * May appear once only; it must precede any modifier
	   * for argument length, or any data type specifier.
	   */
	  case '.':
	    if( state < PFORMAT_GET_PRECISION )
	    {
	      /* We haven't seen a precision specification yet,
	       * so initialise it to zero, (in case no digits follow),
	       * and accept any following digits as the precision.
	       */
	      stream.precision = 0;
	      width_spec = &stream.precision;
	      state = PFORMAT_GET_PRECISION;
	    }

	    else
	      /* We've already seen a precision specification,
	       * so this is just junk; proceed to end game.
	       */
	      state = PFORMAT_END;

	    /* Either way, we must not fall through here.
	     */
	    break;

	  /* Variable field width, or precision specification,
	   * derived from the argument list...
	   */
	  case '*':
	    /*
	     * When this appears...
	     */
	    if(   width_spec
	    &&  ((state == PFORMAT_INIT) || (state == PFORMAT_GET_PRECISION)) )
	    {
	      /* in proper context; assign to field width
	       * or precision, as appropriate.
	       */
	      if( (*width_spec = va_arg( argv, int )) < 0 )
	      {
		/* Assigned value was negative...
		 */
		if( state == PFORMAT_INIT )
		{
		  /* For field width, this is equivalent to
		   * a positive value with the `-' flag...
		   */
		  stream.flags |= PFORMAT_LJUSTIFY;
		  stream.width = -stream.width;
		}

		else
		  /* while as a precision specification,
		   * it should simply be ignored.
		   */
		  stream.precision = PFORMAT_IGNORE;
	      }
	    }

	    else
	      /* out of context; give up on width and precision
	       * specifications for this conversion.
	       */
	      state = PFORMAT_END;

	    /* Mark as processed...
	     * we must not see `*' again, in this context.
	     */
	    width_spec = NULL;
	    break;

	  /* Formatting flags...
	   * Must appear while in the PFORMAT_INIT state,
	   * and are non-terminal, so again, end with `break'.
	   */
	  case '#':
	    /*
	     * Select alternate PFORMAT_HASHED output style.
	     */
	    if( state == PFORMAT_INIT )
	      stream.flags |= PFORMAT_HASHED;
	    break;

	  case '+':
	    /*
	     * Print a leading sign with numeric output,
	     * for both positive and negative values.
	     */
	    if( state == PFORMAT_INIT )
	      stream.flags |= PFORMAT_POSITIVE;
	    break;

	  case '-':
	    /*
	     * Select left justification of displayed output
	     * data, within the output field width, instead of
	     * the default flush right justification.
	     */
	    if( state == PFORMAT_INIT )
	      stream.flags |= PFORMAT_LJUSTIFY;
	    break;

	    case '\'':
	      /*
	       * This is an XSI extension to the POSIX standard,
	       * which we do not support, at present.
	       */
	      if (state == PFORMAT_INIT)
	      {
		stream.flags |= PFORMAT_GROUPED; /* $$$$ */
		int len; wchar_t rpchr; mbstate_t cstate;
		memset (&cstate, 0, sizeof(state));
		if ((len = mbrtowc( &rpchr, localeconv()->thousands_sep, 16, &cstate)) > 0)
		    stream.thousands_chr = rpchr;
	  	stream.thousands_chr_len = len;
	      }
	      break;

	  case '\x20':
	    /*
	     * Reserve a single space, within the output field,
	     * for display of the sign of signed data; this will
	     * be occupied by the minus sign, if the data value
	     * is negative, or by a plus sign if the data value
	     * is positive AND the `+' flag is also present, or
	     * by a space otherwise.  (Technically, this flag
	     * is redundant, if the `+' flag is present).
	     */
	    if( state == PFORMAT_INIT )
	      stream.flags |= PFORMAT_ADDSPACE;
	    break;

	  case '0':
	    /*
	     * May represent a flag, to activate the `pad with zeros'
	     * option, or it may simply be a digit in a width or in a
	     * precision specification...
	     */
	    if( state == PFORMAT_INIT )
	    {
	      /* This is the flag usage...
	       */
	      stream.flags |= PFORMAT_ZEROFILL;
	      break;
	    }

	  default:
	    /*
	     * If we didn't match anything above, then we will check
	     * for digits, which we may accumulate to generate field
	     * width or precision specifications...
	     */
	    if( (state < PFORMAT_END) && ('9' >= c) && (c >= '0') )
	    {
	      if( state == PFORMAT_INIT )
		/*
		 * Initial digits explicitly relate to field width...
		 */
		state = PFORMAT_SET_WIDTH;

	      else if( state == PFORMAT_GET_PRECISION )
		/*
		 * while those following a precision indicator
		 * explicitly relate to precision.
		 */
		state = PFORMAT_SET_PRECISION;

	      if( width_spec )
	      {
		/* We are accepting a width or precision specification...
		 */
		if( *width_spec < 0 )
		  /*
		   * and accumulation hasn't started yet; we simply
		   * initialise the accumulator with the current digit
		   * value, converting from ASCII to decimal.
		   */
		  *width_spec = c - '0';

		else
		  /* Accumulation has already started; we perform a
		   * `leftwise decimal digit shift' on the accumulator,
		   * (i.e. multiply it by ten), then add the decimal
		   * equivalent value of the current digit.
		   */ 
		  *width_spec = *width_spec * 10 + c - '0';
	      }
	    }

	    else
	    {
	      /* We found a digit out of context, or some other character
	       * with no designated meaning; reject this format specification,
	       * backtrack, and emit it as literal text...
	       */
	      fmt = backtrack;
	      __pformat_putc( '%', &stream );
	      goto format_scan;
	    }
	}
      }
    }

    else
      /* We just parsed a character which is not included within any format
       * specification; we simply emit it as a literal.
       */
      __pformat_putc( c, &stream );
  }

  /* When we have fully dispatched the format string, the return value is the
   * total number of bytes we transferred to the output destination.
   */
  return stream.count;
}

/* $RCSfile: pformat.c,v $Revision: 1.9 $: end of file */