/*
*******************************************************************************
*
*   Copyright (C) 1998-1999, International Business Machines
*   Corporation and others.  All Rights Reserved.
*
*******************************************************************************
*
* File sprintf.c
*
* Modification History:
*
*   Date        Name        Description
*   02/08/00    george      Creation. Copied from uprintf.c
*******************************************************************************
*/

#include "unicode/utypes.h"
#include "sprintf.h"
#include "sprntf_p.h"
#include "unicode/ustdio.h"
#include "unicode/ustring.h"
#include "locbund.h"
#include "loccache.h"
#include "unicode/unum.h"
#include "unicode/udat.h"
#include "unicode/uloc.h"

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


/* --- Prototypes ---------------------------- */

int32_t
u_sprintf_simple_percent_handler(u_localized_string *output,
                const u_sprintf_spec_info     *info,
                const ufmt_args            *args);

int32_t
u_sprintf_string_handler(u_localized_string *output,
            const u_sprintf_spec_info     *info,
            const ufmt_args            *args);

int32_t
u_sprintf_date_handler(u_localized_string *output,
              const u_sprintf_spec_info     *info,
              const ufmt_args         *args);

int32_t
u_sprintf_scientific_handler(u_localized_string *output,
                const u_sprintf_spec_info     *info,
                const ufmt_args            *args);

int32_t
u_sprintf_scidbl_handler(u_localized_string *output,
            const u_sprintf_spec_info     *info,
            const ufmt_args            *args);

int32_t
u_sprintf_uchar_handler(u_localized_string *output,
               const u_sprintf_spec_info     *info,
               const ufmt_args            *args);

int32_t
u_sprintf_currency_handler(u_localized_string *output,
              const u_sprintf_spec_info     *info,
              const ufmt_args            *args);

int32_t
u_sprintf_ustring_handler(u_localized_string *output,
             const u_sprintf_spec_info     *info,
             const ufmt_args         *args);

int32_t
u_sprintf_percent_handler(u_localized_string *output,
             const u_sprintf_spec_info     *info,
             const ufmt_args            *args);

int32_t
u_sprintf_time_handler(u_localized_string *output,
              const u_sprintf_spec_info     *info,
              const ufmt_args         *args);

int32_t
u_sprintf_spellout_handler(u_localized_string *output,
              const u_sprintf_spec_info     *info,
              const ufmt_args            *args);

int32_t
u_sprintf_hex_handler(u_localized_string *output,
             const u_sprintf_spec_info     *info,
             const ufmt_args            *args);

int32_t
u_sprintf_char_handler(u_localized_string *output,
              const u_sprintf_spec_info         *info,
              const ufmt_args              *args);

int32_t
u_sprintf_integer_handler(u_localized_string *output,
             const u_sprintf_spec_info     *info,
             const ufmt_args            *args);

int32_t
u_sprintf_uinteger_handler(u_localized_string *output,
             const u_sprintf_spec_info     *info,
             const ufmt_args            *args);

int32_t
u_sprintf_double_handler(u_localized_string *output,
            const u_sprintf_spec_info     *info,
            const ufmt_args            *args);

int32_t
u_sprintf_count_handler(u_localized_string *output,
            const u_sprintf_spec_info     *info,
            const ufmt_args            *args);

int32_t
u_sprintf_octal_handler(u_localized_string *output,
            const u_sprintf_spec_info     *info,
            const ufmt_args            *args);

int32_t
u_sprintf_pointer_handler(u_localized_string *output,
            const u_sprintf_spec_info     *info,
            const ufmt_args            *args);

/* ANSI style formatting */
/* Use US-ASCII characters only for formatting */

/* % */
#define UFMT_SIMPLE_PERCENT {ufmt_simple_percent, u_sprintf_simple_percent_handler}
/* s */
#define UFMT_STRING         {ufmt_string, u_sprintf_string_handler}
/* c */
#define UFMT_CHAR           {ufmt_char, u_sprintf_char_handler}
/* d, i */
#define UFMT_INT            {ufmt_int, u_sprintf_integer_handler}
/* u */
#define UFMT_UINT           {ufmt_int, u_sprintf_uinteger_handler}
/* o */
#define UFMT_OCTAL          {ufmt_int, u_sprintf_octal_handler}
/* x, X */
#define UFMT_HEX            {ufmt_int, u_sprintf_hex_handler}
/* f */
#define UFMT_DOUBLE         {ufmt_double, u_sprintf_double_handler}
/* e, E */
#define UFMT_SCIENTIFIC     {ufmt_double, u_sprintf_scientific_handler}
/* g, G */
#define UFMT_SCIDBL         {ufmt_double, u_sprintf_scidbl_handler}
/* n */
#define UFMT_COUNT          {ufmt_count, u_sprintf_count_handler}

/* non-ANSI extensions */
/* Use US-ASCII characters only for formatting */

/* p */
#define UFMT_POINTER        {ufmt_pointer, u_sprintf_pointer_handler}
/* D */
#define UFMT_DATE           {ufmt_date, u_sprintf_date_handler}
/* T */
#define UFMT_TIME           {ufmt_date, u_sprintf_time_handler}
/* V */
#define UFMT_SPELLOUT       {ufmt_double, u_sprintf_spellout_handler}
/* P */
#define UFMT_PERCENT        {ufmt_double, u_sprintf_percent_handler}
/* M */
#define UFMT_CURRENCY       {ufmt_double, u_sprintf_currency_handler}
/* K */
#define UFMT_UCHAR          {ufmt_uchar, u_sprintf_uchar_handler}
/* U */
#define UFMT_USTRING        {ufmt_ustring, u_sprintf_ustring_handler}


#define UFMT_EMPTY {ufmt_empty, NULL}

struct u_sprintf_info {
    enum ufmt_type_info info;
    u_sprintf_handler handler;
};
typedef struct u_sprintf_info u_sprintf_info;

/* Use US-ASCII characters only for formatting. Most codepages have
 characters 20-7F from Unicode. Using any other codepage specific
 characters will make it very difficult to format the string on
 non-Unicode machines */
static const u_sprintf_info g_u_sprintf_infos[108] = {
/* 0x20 */
    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
    UFMT_EMPTY,         UFMT_SIMPLE_PERCENT,UFMT_EMPTY,         UFMT_EMPTY,
    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,

/* 0x30 */
    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,

/* 0x40 */
    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
    UFMT_DATE,          UFMT_SCIENTIFIC,    UFMT_EMPTY,         UFMT_SCIDBL,
    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_UCHAR,
    UFMT_EMPTY,         UFMT_CURRENCY,      UFMT_EMPTY,         UFMT_EMPTY,

/* 0x50 */
    UFMT_PERCENT,       UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
    UFMT_TIME,          UFMT_USTRING,       UFMT_SPELLOUT,      UFMT_EMPTY,
    UFMT_HEX,           UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,

/* 0x60 */
    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_CHAR,
    UFMT_INT,           UFMT_SCIENTIFIC,    UFMT_DOUBLE,        UFMT_SCIDBL,
    UFMT_EMPTY,         UFMT_INT,           UFMT_EMPTY,         UFMT_EMPTY,
    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_COUNT,         UFMT_OCTAL,

/* 0x70 */
    UFMT_POINTER,       UFMT_EMPTY,         UFMT_EMPTY,         UFMT_STRING,
    UFMT_EMPTY,         UFMT_UINT,          UFMT_EMPTY,         UFMT_EMPTY,
    UFMT_HEX,           UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
};

#define USPRINTF_NUM_FMT_HANDLERS sizeof(g_u_sprintf_infos)

/* We do not use handlers for 0-0x1f */
#define USPRINTF_BASE_FMT_HANDLERS 0x20

/* buffer size for formatting */
#define USPRINTF_BUFFER_SIZE 1024

int32_t 
u_sprintf(UChar       *buffer,
        const char    *locale,
        const char    *patternSpecification,
        ... )
{
  va_list ap;
  int32_t written;
  
  va_start(ap, patternSpecification);
  written = u_vsnprintf(buffer, INT32_MAX, locale, patternSpecification, ap);
  va_end(ap);
  
  return written;
}

int32_t 
u_sprintf_u(UChar     *buffer,
        const char     *locale,
        const UChar    *patternSpecification,
        ... )
{
  va_list ap;
  int32_t written;
  
  va_start(ap, patternSpecification);
  written = u_vsnprintf_u(buffer, INT32_MAX, locale, patternSpecification, ap);
  va_end(ap);
  
  return written;
}

int32_t 
u_vsprintf(UChar       *buffer,
        const char     *locale,
        const char     *patternSpecification,
        va_list         ap)
{
  return u_vsnprintf(buffer, INT32_MAX, locale, patternSpecification, ap);
}

int32_t 
u_snprintf(UChar       *buffer,
        int32_t         count,
        const char    *locale,
        const char    *patternSpecification,
        ... )
{
  va_list ap;
  int32_t written;
  
  va_start(ap, patternSpecification);
  written = u_vsnprintf(buffer, count, locale, patternSpecification, ap);
  va_end(ap);
  
  return written;
}

int32_t 
u_snprintf_u(UChar     *buffer,
        int32_t        count,
        const char     *locale,
        const UChar    *patternSpecification,
        ... )
{
  va_list ap;
  int32_t written;
  
  va_start(ap, patternSpecification);
  written = u_vsnprintf_u(buffer, count, locale, patternSpecification, ap);
  va_end(ap);
  
  return written;
}

int32_t 
u_vsnprintf(UChar       *buffer,
        int32_t         count,
        const char     *locale,
        const char     *patternSpecification,
        va_list         ap)
{
  int32_t written;
  UChar *pattern;
  
  /* convert from the default codepage to Unicode */
  pattern = ufmt_defaultCPToUnicode(patternSpecification, 
                    strlen(patternSpecification));
  if(pattern == 0) {
    return 0;
  }

  /* do the work */
  written = u_vsnprintf_u(buffer, count, locale, pattern, ap);

  /* clean up */
  free(pattern);
  
  return written;
}

static UChar *
u_strset(UChar *str, int32_t count, UChar c) {
    int32_t idx;
    for(idx = 0; idx < count; ++idx) {
         str[idx] = c;
    }
    return str;
}

/* copies the minimum number of code units of (count or output->available) */
static int32_t
u_minstrncpy(u_localized_string *output, const UChar *str, int32_t count) {
    int32_t size = ufmt_min(count, output->available);

    u_strncpy(output->str + (output->len - output->available), str, size);
    output->available -= size;
    return size;
}

static int32_t
u_sprintf_pad_and_justify(u_localized_string *output,
                const u_sprintf_spec_info    *info,
                const UChar                 *result,
                int32_t                     resultLen)
{
    int32_t written;

    resultLen = ufmt_min(resultLen, output->available);
    written = resultLen;

    /* pad and justify, if needed */
    if(info->fWidth != -1 && resultLen < info->fWidth) {
        int32_t paddingLeft = info->fWidth - resultLen;
        int32_t outputPos = output->len - output->available;

        if (paddingLeft + resultLen > output->available) {
            paddingLeft = output->available - resultLen;
        }
        written += paddingLeft;

        /* left justify */
        if(info->fLeft) {
            written += u_minstrncpy(output, result, resultLen);
            u_strset(&output->str[outputPos + resultLen], paddingLeft, info->fPadChar);
        }
        /* right justify */
        else {
            u_strset(&output->str[outputPos + resultLen], paddingLeft, info->fPadChar);
            written += u_minstrncpy(output, result, resultLen);
        }
    }
    /* just write the formatted output */
    else {
        written += u_minstrncpy(output, result, resultLen);
    }

    output->available -= written;
    return written;
}

/* handle a '%' */

int32_t
u_sprintf_simple_percent_handler(u_localized_string *output,
                const u_sprintf_spec_info     *info,
                const ufmt_args            *args)
{
    /* put a single '%' on the stream */
    if (output->available >= 1) {
        output->str[output->len - output->available--] = 0x0025;
        /* we wrote one character */
        return 1;
    }
    return 0;
}

/* handle 's' */

int32_t
u_sprintf_string_handler(u_localized_string *output,
            const u_sprintf_spec_info     *info,
            const ufmt_args            *args)
{
  UChar *s;
  int32_t len, written;
  const char *arg = (const char*)(args[0].ptrValue);

  /* convert from the default codepage to Unicode */
  s = ufmt_defaultCPToUnicode(arg, strlen(arg));
  if(s == 0) {
    return 0;
  }
  len = u_strlen(s);
  
  /* width = minimum # of characters to write */
  /* precision = maximum # of characters to write */

  /* precision takes precedence over width */
  /* determine if the string should be truncated */
  if(info->fPrecision != -1 && len > info->fPrecision) {
    written = u_minstrncpy(output, s, info->fPrecision);
  }
  /* determine if the string should be padded */
  else {
    written = u_sprintf_pad_and_justify(output, info, s, len);
  }

  /* clean up */
  free(s);
  
  return written;
}

/* HSYS */
int32_t
u_sprintf_integer_handler(u_localized_string *output,
             const u_sprintf_spec_info     *info,
             const ufmt_args            *args)
{
  long            num         = (long) (args[0].intValue);
  UNumberFormat        *format;
  UChar            result        [USPRINTF_BUFFER_SIZE];
  int32_t        minDigits     = -1;
  UErrorCode        status        = U_ZERO_ERROR;


  /* mask off any necessary bits */
  if(info->fIsShort)
    num &= UINT16_MAX;
  else if(! info->fIsLong || ! info->fIsLongLong)
    num &= UINT32_MAX;

  /* get the formatter */
  format = u_locbund_getNumberFormat(output->fBundle);

  /* handle error */
  if(format == 0)
    return 0;

  /* set the appropriate flags on the formatter */

  /* set the minimum integer digits */
  if(info->fPrecision != -1) {
    /* clone the stream's bundle if it isn't owned */
    if(! output->fOwnBundle) {
      output->fBundle     = u_locbund_clone(output->fBundle);
      output->fOwnBundle = TRUE;
      format           = u_locbund_getNumberFormat(output->fBundle);
    }

    /* set the minimum # of digits */
    minDigits = unum_getAttribute(format, UNUM_MIN_INTEGER_DIGITS);
    unum_setAttribute(format, UNUM_MIN_INTEGER_DIGITS, info->fPrecision);
  }

  /* set whether to show the sign */
  if(info->fShowSign) {
    /* clone the stream's bundle if it isn't owned */
    if(! output->fOwnBundle) {
      output->fBundle     = u_locbund_clone(output->fBundle);
      output->fOwnBundle = TRUE;
      format           = u_locbund_getNumberFormat(output->fBundle);
    }

    /* set whether to show the sign*/
    /* {sfb} TODO */
  }

  /* format the number */
  unum_format(format, num, result, USPRINTF_BUFFER_SIZE, 0, &status);
  
  /* restore the number format */
  if(minDigits != -1)
    unum_setAttribute(format, UNUM_MIN_INTEGER_DIGITS, minDigits);

  return u_sprintf_pad_and_justify(output, info, result, u_strlen(result));
}

int32_t
u_sprintf_hex_handler(u_localized_string *output,
             const u_sprintf_spec_info     *info,
             const ufmt_args            *args)
{
  long            num         = (long) (args[0].intValue);
  UChar            result         [USPRINTF_BUFFER_SIZE];
  int32_t         len        = USPRINTF_BUFFER_SIZE;


  /* mask off any necessary bits */
  if(info->fIsShort)
    num &= UINT16_MAX;
  else if(! info->fIsLong || ! info->fIsLongLong)
    num &= UINT32_MAX;

  /* format the number, preserving the minimum # of digits */
  ufmt_ltou(result, &len, num, 16,
        (UBool)(info->fSpec == 0x0078),
        (info->fPrecision == -1 && info->fZero) ? info->fWidth : info->fPrecision);

  /* convert to alt form, if desired */
  if(num != 0 && info->fAlt && len < USPRINTF_BUFFER_SIZE - 2) {
    /* shift the formatted string right by 2 chars */
    memmove(result + 2, result, len * sizeof(UChar));
    result[0] = 0x0030;
    result[1] = info->fSpec;
    len += 2;
  }

  return u_sprintf_pad_and_justify(output, info, result, len);
}

int32_t
u_sprintf_octal_handler(u_localized_string *output,
               const u_sprintf_spec_info     *info,
               const ufmt_args            *args)
{
  long            num         = (long) (args[0].intValue);
  UChar            result         [USPRINTF_BUFFER_SIZE];
  int32_t         len        = USPRINTF_BUFFER_SIZE;


  /* mask off any necessary bits */
  if(info->fIsShort)
    num &= UINT16_MAX;
  else if(! info->fIsLong || ! info->fIsLongLong)
    num &= UINT32_MAX;

  /* format the number, preserving the minimum # of digits */
  ufmt_ltou(result, &len, num, 8,
        FALSE, /* doesn't matter for octal */
        info->fPrecision == -1 && info->fZero ? info->fWidth : info->fPrecision);

  /* convert to alt form, if desired */
  if(info->fAlt && result[0] != 0x0030 && len < USPRINTF_BUFFER_SIZE - 1) {
    /* shift the formatted string right by 1 char */
    memmove(result + 1, result, len * sizeof(UChar));
    result[0] = 0x0030;
    len += 1;
  }

  return u_sprintf_pad_and_justify(output, info, result, len);
}


int32_t
u_sprintf_uinteger_handler(u_localized_string *output,
             const u_sprintf_spec_info     *info,
             const ufmt_args            *args)
{
    u_sprintf_spec_info uint_info;
    ufmt_args uint_args;

    memcpy(&uint_info, info, sizeof(u_sprintf_spec_info));
    memcpy(&uint_args, args, sizeof(ufmt_args));

    uint_info.fPrecision = 0;
    uint_info.fAlt  = FALSE;

    /* Get around int32_t limitations */
    uint_args.doubleValue = ((double) ((uint32_t) (uint_args.intValue)));

    return u_sprintf_double_handler(output, &uint_info, &uint_args);
}

int32_t
u_sprintf_double_handler(u_localized_string *output,
            const u_sprintf_spec_info     *info,
            const ufmt_args            *args)
{
  double        num         = (double) (args[0].doubleValue);
  UNumberFormat        *format;
  UChar            result        [USPRINTF_BUFFER_SIZE];
  int32_t        minDecimalDigits;
  int32_t        maxDecimalDigits;
  UErrorCode        status        = U_ZERO_ERROR;

  /* mask off any necessary bits */
  /*  if(! info->fIsLongDouble)
      num &= DBL_MAX;*/

  /* get the formatter */
  format = u_locbund_getNumberFormat(output->fBundle);

  /* handle error */
  if(format == 0)
    return 0;

  /* set the appropriate flags on the formatter */

  /* clone the stream's bundle if it isn't owned */
  if(! output->fOwnBundle) {
    output->fBundle     = u_locbund_clone(output->fBundle);
    output->fOwnBundle     = TRUE;
    format           = u_locbund_getNumberFormat(output->fBundle);
  }

  /* set the number of decimal digits */

  /* save the formatter's state */
  minDecimalDigits = unum_getAttribute(format, UNUM_MIN_FRACTION_DIGITS);
  maxDecimalDigits = unum_getAttribute(format, UNUM_MAX_FRACTION_DIGITS);

  if(info->fPrecision != -1) {
    /* set the # of decimal digits */
    unum_setAttribute(format, UNUM_FRACTION_DIGITS, info->fPrecision);
  }
  else if(info->fPrecision == 0 && ! info->fAlt) {
    /* no decimal point in this case */
    unum_setAttribute(format, UNUM_FRACTION_DIGITS, 0);
  }
  else if(info->fAlt) {
    /* '#' means always show decimal point */
    /* copy of printf behavior on Solaris - '#' shows 6 digits */
    unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6);
  }
  else {
    /* # of decimal digits is 6 if precision not specified */
    unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6);
  }

  /* set whether to show the sign */
  if(info->fShowSign) {
    /* set whether to show the sign*/
    /* {sfb} TODO */
  }

  /* format the number */
  unum_formatDouble(format, num, result, USPRINTF_BUFFER_SIZE, 0, &status);
  
  /* restore the number format */
  unum_setAttribute(format, UNUM_MIN_FRACTION_DIGITS, minDecimalDigits);
  unum_setAttribute(format, UNUM_MAX_FRACTION_DIGITS, maxDecimalDigits);

  return u_sprintf_pad_and_justify(output, info, result, u_strlen(result));
}


int32_t
u_sprintf_char_handler(u_localized_string *output,
              const u_sprintf_spec_info         *info,
              const ufmt_args              *args)
{
  UChar *s;
  int32_t len, written;
  unsigned char arg = (unsigned char)(args[0].intValue);

  /* convert from default codepage to Unicode */
  s = ufmt_defaultCPToUnicode((const char *)&arg, 1);
  if(s == 0) {
    return 0;
  }

  /* Remember that this may be a surrogate pair */
  len = u_strlen(s);
  
  /* width = minimum # of characters to write */
  /* precision = maximum # of characters to write */

  /* precision takes precedence over width */
  /* determine if the string should be truncated */
  if(info->fPrecision != -1 && len > info->fPrecision) {
    written = u_minstrncpy(output, s, info->fPrecision);
  }
  else {
    /* determine if the string should be padded */
    written = u_sprintf_pad_and_justify(output, info, s, len);
  }

  /* clean up */
  free(s);

  return written;
}


int32_t
u_sprintf_pointer_handler(u_localized_string *output,
             const u_sprintf_spec_info     *info,
             const ufmt_args            *args)
{
  long            num         = (long) (args[0].intValue);
  UChar            result         [USPRINTF_BUFFER_SIZE];
  int32_t         len        = USPRINTF_BUFFER_SIZE;


  /* format the pointer in hex */
  ufmt_ltou(result, &len, num, 16, TRUE, info->fPrecision);

  return u_sprintf_pad_and_justify(output, info, result, len);
}


int32_t
u_sprintf_scientific_handler(u_localized_string *output,
                const u_sprintf_spec_info     *info,
                const ufmt_args            *args)
{
  double        num         = (double) (args[0].doubleValue);
  UNumberFormat        *format;
  UChar            result        [USPRINTF_BUFFER_SIZE];
  int32_t        minDecimalDigits;
  int32_t        maxDecimalDigits;
  UErrorCode        status        = U_ZERO_ERROR;
  

  /* mask off any necessary bits */
  /*  if(! info->fIsLongDouble)
      num &= DBL_MAX;*/

  /* get the formatter */
  format = u_locbund_getScientificFormat(output->fBundle);

  /* handle error */
  if(format == 0)
    return 0;

  /* set the appropriate flags on the formatter */

  /* clone the stream's bundle if it isn't owned */
  if(! output->fOwnBundle) {
    output->fBundle     = u_locbund_clone(output->fBundle);
    output->fOwnBundle     = TRUE;
    format           = u_locbund_getScientificFormat(output->fBundle);
  }

  /* set the number of decimal digits */

  /* save the formatter's state */
  minDecimalDigits = unum_getAttribute(format, UNUM_MIN_FRACTION_DIGITS);
  maxDecimalDigits = unum_getAttribute(format, UNUM_MAX_FRACTION_DIGITS);

  if(info->fPrecision != -1) {
    /* set the # of decimal digits */
    unum_setAttribute(format, UNUM_FRACTION_DIGITS, info->fPrecision);
  }
  else if(info->fPrecision == 0 && ! info->fAlt) {
    /* no decimal point in this case */
    unum_setAttribute(format, UNUM_FRACTION_DIGITS, 0);
  }
  else if(info->fAlt) {
    /* '#' means always show decimal point */
    /* copy of printf behavior on Solaris - '#' shows 6 digits */
    unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6);
  }
  else {
    /* # of decimal digits is 6 if precision not specified */
    unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6);
  }

  /* set whether to show the sign */
  if(info->fShowSign) {
    /* set whether to show the sign*/
    /* {sfb} TODO */
  }

  /* format the number */
  unum_formatDouble(format, num, result, USPRINTF_BUFFER_SIZE, 0, &status);

  /* restore the number format */
  unum_setAttribute(format, UNUM_MIN_FRACTION_DIGITS, minDecimalDigits);
  unum_setAttribute(format, UNUM_MAX_FRACTION_DIGITS, maxDecimalDigits);

  return u_sprintf_pad_and_justify(output, info, result, u_strlen(result));
}

int32_t
u_sprintf_date_handler(u_localized_string *output,
              const u_sprintf_spec_info     *info,
              const ufmt_args         *args)
{
  UDate            num         = (UDate) (args[0].dateValue);
  UDateFormat        *format;
  UChar            result        [USPRINTF_BUFFER_SIZE];
  UErrorCode        status        = U_ZERO_ERROR;


  /* get the formatter */
  format = u_locbund_getDateFormat(output->fBundle);
  
  /* handle error */
  if(format == 0)
    return 0;

  /* format the date */
  udat_format(format, num, result, USPRINTF_BUFFER_SIZE, 0, &status);

  return u_sprintf_pad_and_justify(output, info, result, u_strlen(result));
}

int32_t
u_sprintf_time_handler(u_localized_string *output,
              const u_sprintf_spec_info     *info,
              const ufmt_args         *args)
{
  UDate            num         = (UDate) (args[0].dateValue);
  UDateFormat        *format;
  UChar            result        [USPRINTF_BUFFER_SIZE];
  UErrorCode        status        = U_ZERO_ERROR;


  /* get the formatter */
  format = u_locbund_getTimeFormat(output->fBundle);
  
  /* handle error */
  if(format == 0)
    return 0;

  /* format the time */
  udat_format(format, num, result, USPRINTF_BUFFER_SIZE, 0, &status);

  return u_sprintf_pad_and_justify(output, info, result, u_strlen(result));
}


int32_t
u_sprintf_percent_handler(u_localized_string *output,
             const u_sprintf_spec_info     *info,
             const ufmt_args            *args)
{
  double        num         = (double) (args[0].doubleValue);
  UNumberFormat        *format;
  UChar            result        [USPRINTF_BUFFER_SIZE];
  int32_t        minDecimalDigits;
  int32_t        maxDecimalDigits;
  UErrorCode        status        = U_ZERO_ERROR;


  /* mask off any necessary bits */
  /*  if(! info->fIsLongDouble)
      num &= DBL_MAX;*/

  /* get the formatter */
  format = u_locbund_getPercentFormat(output->fBundle);

  /* handle error */
  if(format == 0)
    return 0;

  /* set the appropriate flags on the formatter */

  /* clone the stream's bundle if it isn't owned */
  if(! output->fOwnBundle) {
    output->fBundle     = u_locbund_clone(output->fBundle);
    output->fOwnBundle     = TRUE;
    format           = u_locbund_getPercentFormat(output->fBundle);
  }

  /* set the number of decimal digits */

  /* save the formatter's state */
  minDecimalDigits = unum_getAttribute(format, UNUM_MIN_FRACTION_DIGITS);
  maxDecimalDigits = unum_getAttribute(format, UNUM_MAX_FRACTION_DIGITS);

  if(info->fPrecision != -1) {
    /* set the # of decimal digits */
    unum_setAttribute(format, UNUM_FRACTION_DIGITS, info->fPrecision);
  }
  else if(info->fPrecision == 0 && ! info->fAlt) {
    /* no decimal point in this case */
    unum_setAttribute(format, UNUM_FRACTION_DIGITS, 0);
  }
  else if(info->fAlt) {
    /* '#' means always show decimal point */
    /* copy of printf behavior on Solaris - '#' shows 6 digits */
    unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6);
  }
  else {
    /* # of decimal digits is 6 if precision not specified */
    unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6);
  }

  /* set whether to show the sign */
  if(info->fShowSign) {
    /* set whether to show the sign*/
    /* {sfb} TODO */
  }

  /* format the number */
  unum_formatDouble(format, num, result, USPRINTF_BUFFER_SIZE, 0, &status);

  /* restore the number format */
  unum_setAttribute(format, UNUM_MIN_FRACTION_DIGITS, minDecimalDigits);
  unum_setAttribute(format, UNUM_MAX_FRACTION_DIGITS, maxDecimalDigits);

  return u_sprintf_pad_and_justify(output, info, result, u_strlen(result));
}


int32_t
u_sprintf_currency_handler(u_localized_string *output,
              const u_sprintf_spec_info     *info,
              const ufmt_args            *args)
{
  double        num         = (double) (args[0].doubleValue);
  UNumberFormat        *format;
  UChar            result        [USPRINTF_BUFFER_SIZE];
  int32_t        minDecimalDigits;
  int32_t        maxDecimalDigits;
  UErrorCode        status        = U_ZERO_ERROR;


  /* mask off any necessary bits */
  /*  if(! info->fIsLongDouble)
      num &= DBL_MAX;*/

  /* get the formatter */
  format = u_locbund_getCurrencyFormat(output->fBundle);

  /* handle error */
  if(format == 0)
    return 0;

  /* set the appropriate flags on the formatter */

  /* clone the stream's bundle if it isn't owned */
  if(! output->fOwnBundle) {
    output->fBundle     = u_locbund_clone(output->fBundle);
    output->fOwnBundle     = TRUE;
    format           = u_locbund_getCurrencyFormat(output->fBundle);
  }

  /* set the number of decimal digits */

  /* save the formatter's state */
  minDecimalDigits = unum_getAttribute(format, UNUM_MIN_FRACTION_DIGITS);
  maxDecimalDigits = unum_getAttribute(format, UNUM_MAX_FRACTION_DIGITS);

  if(info->fPrecision != -1) {
    /* set the # of decimal digits */
    unum_setAttribute(format, UNUM_FRACTION_DIGITS, info->fPrecision);
  }
  else if(info->fPrecision == 0 && ! info->fAlt) {
    /* no decimal point in this case */
    unum_setAttribute(format, UNUM_FRACTION_DIGITS, 0);
  }
  else if(info->fAlt) {
    /* '#' means always show decimal point */
    /* copy of printf behavior on Solaris - '#' shows 6 digits */
    unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6);
  }
  else {
    /* # of decimal digits is 6 if precision not specified */
    unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6);
  }

  /* set whether to show the sign */
  if(info->fShowSign) {
    /* set whether to show the sign*/
    /* {sfb} TODO */
  }

  /* format the number */
  unum_formatDouble(format, num, result, USPRINTF_BUFFER_SIZE, 0, &status);

  /* restore the number format */
  unum_setAttribute(format, UNUM_MIN_FRACTION_DIGITS, minDecimalDigits);
  unum_setAttribute(format, UNUM_MAX_FRACTION_DIGITS, maxDecimalDigits);

  return u_sprintf_pad_and_justify(output, info, result, u_strlen(result));
}

int32_t
u_sprintf_ustring_handler(u_localized_string *output,
             const u_sprintf_spec_info     *info,
             const ufmt_args         *args)
{
  int32_t len, written;
  const UChar *arg = (const UChar*)(args[0].ptrValue);

  /* allocate enough space for the buffer */
  len = u_strlen(arg);

  /* width = minimum # of characters to write */
  /* precision = maximum # of characters to write */

  /* precision takes precedence over width */
  /* determine if the string should be truncated */
  if(info->fPrecision != -1 && len > info->fPrecision) {
    written = u_minstrncpy(output, arg, info->fPrecision);
  }
  else {
    /* determine if the string should be padded */
    written = u_sprintf_pad_and_justify(output, info, arg, len);
  }

  return written;
}


int32_t
u_sprintf_uchar_handler(u_localized_string *output,
               const u_sprintf_spec_info     *info,
               const ufmt_args            *args)
{
  int32_t written = 0;
  UChar arg = (UChar)(args[0].intValue);
  

  /* width = minimum # of characters to write */
  /* precision = maximum # of characters to write */

  /* precision takes precedence over width */
  /* determine if the char should be printed */
  if(info->fPrecision != -1 && info->fPrecision < 1) {
    /* write nothing */
    written = 0;
  }
  else {
    /* determine if the string should be padded */
    written = u_sprintf_pad_and_justify(output, info, &arg, 1);
  }

  return written;
}

int32_t
u_sprintf_scidbl_handler(u_localized_string *output,
            const u_sprintf_spec_info     *info,
            const ufmt_args            *args)
{
  double     num = (double)(args[0].doubleValue);
  UBool     useE;

  /* a precision of 0 is taken as 1 */
  if(info->fPrecision == 0)
    ((u_sprintf_spec_info*)info)->fPrecision = 1;

  /* determine whether to use 'e' or 'f' */
  useE = (UBool)(num < 0.0001
       || (info->fPrecision != -1 && num > uprv_pow10(info->fPrecision)));
  
  /* use 'e' */
  if(useE) {
    /* adjust the specifier */
    ((u_sprintf_spec_info*)info)->fSpec = 0x0065;
    /* call the scientific handler */
    return u_sprintf_scientific_handler(output, info, args);
  }
  /* use 'f' */
  else {
    /* adjust the specifier */
    ((u_sprintf_spec_info*)info)->fSpec = 0x0066;
    /* call the double handler */
    return u_sprintf_double_handler(output, info, args);
  }
}


int32_t
u_sprintf_count_handler(u_localized_string *output,
               const u_sprintf_spec_info     *info,
               const ufmt_args            *args)
{
  int *count = (int*)(args[0].ptrValue);

  /* in the special case of count, the u_printf_spec_info's width */
  /* will contain the # of chars written thus far */
  *count = info->fWidth;

  return 0;
}


int32_t
u_sprintf_spellout_handler(u_localized_string *output,
              const u_sprintf_spec_info     *info,
              const ufmt_args            *args)
{
  double        num         = (double) (args[0].doubleValue);
  UNumberFormat        *format;
  UChar            result        [USPRINTF_BUFFER_SIZE];
  int32_t        minDecimalDigits;
  int32_t        maxDecimalDigits;
  UErrorCode        status        = U_ZERO_ERROR;


  /* mask off any necessary bits */
  /*  if(! info->fIsLongDouble)
      num &= DBL_MAX;*/

  /* get the formatter */
  format = u_locbund_getSpelloutFormat(output->fBundle);

  /* handle error */
  if(format == 0)
    return 0;

  /* set the appropriate flags on the formatter */

  /* clone the stream's bundle if it isn't owned */
  if(! output->fOwnBundle) {
    output->fBundle     = u_locbund_clone(output->fBundle);
    output->fOwnBundle     = TRUE;
    format           = u_locbund_getSpelloutFormat(output->fBundle);
  }

  /* set the number of decimal digits */

  /* save the formatter's state */
  minDecimalDigits = unum_getAttribute(format, UNUM_MIN_FRACTION_DIGITS);
  maxDecimalDigits = unum_getAttribute(format, UNUM_MAX_FRACTION_DIGITS);

  if(info->fPrecision != -1) {
    /* set the # of decimal digits */
    unum_setAttribute(format, UNUM_FRACTION_DIGITS, info->fPrecision);
  }
  else if(info->fPrecision == 0 && ! info->fAlt) {
    /* no decimal point in this case */
    unum_setAttribute(format, UNUM_FRACTION_DIGITS, 0);
  }
  else if(info->fAlt) {
    /* '#' means always show decimal point */
    /* copy of printf behavior on Solaris - '#' shows 6 digits */
    unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6);
  }
  else {
    /* # of decimal digits is 6 if precision not specified */
    unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6);
  }

  /* set whether to show the sign */
  if(info->fShowSign) {
    /* set whether to show the sign*/
    /* {sfb} TODO */
  }

  /* format the number */
  unum_formatDouble(format, num, result, USPRINTF_BUFFER_SIZE, 0, &status);

  /* restore the number format */
  unum_setAttribute(format, UNUM_MIN_FRACTION_DIGITS, minDecimalDigits);
  unum_setAttribute(format, UNUM_MAX_FRACTION_DIGITS, maxDecimalDigits);

  return u_sprintf_pad_and_justify(output, info, result, u_strlen(result));
}

#define UP_PERCENT 0x0025

int32_t 
u_vsnprintf_u(UChar    *buffer,
        int32_t        count,
        const char     *locale,
        const UChar    *patternSpecification,
        va_list        ap)
{
  const UChar       *alias = patternSpecification;
  const UChar       *lastAlias;
  int32_t           patCount;
  int32_t           written = 0;
  uint16_t          handlerNum;

  ufmt_args         args;  
  u_localized_string outStr;
  u_sprintf_spec    spec;
  ufmt_type_info    info;
  u_sprintf_handler handler;

  if (count < 0) {
    count = INT32_MAX;
  }

  outStr.str = buffer;
  outStr.len = count;
  outStr.available = count;

  /* if locale is 0, use the default */
  if(locale == 0) {
    locale = uloc_getDefault();
  }
  outStr.fBundle = u_loccache_get(locale);

  if(outStr.fBundle == 0) {
    return 0;
  }
  outStr.fOwnBundle     = FALSE;

  /* iterate through the pattern */
  while(outStr.available > 0) {

    /* find the next '%' */
    lastAlias = alias;
    while(*alias != UP_PERCENT && *alias != 0x0000) {
      alias++;
    }

    /* write any characters before the '%' */
    if(alias > lastAlias) {
      written += u_minstrncpy(&outStr, lastAlias, (int32_t)(alias - lastAlias));
    }

    /* break if at end of string */
    if(*alias == 0x0000)
      break;
    
    /* parse the specifier */
    patCount = u_sprintf_parse_spec(alias, &spec);

    /* fill in the precision and width, if specified out of line */

    /* width specified out of line */
    if(spec.fInfo.fWidth == -2) {
      if(spec.fWidthPos == -1) {
        /* read the width from the argument list */
        spec.fInfo.fWidth = va_arg(ap, int);
      }
      else {
        /* handle positional parameter */
      }
    
      /* if it's negative, take the absolute value and set left alignment */
      if(spec.fInfo.fWidth < 0) {
        spec.fInfo.fWidth     *= -1;
        spec.fInfo.fLeft     = TRUE;
      }
    }

    /* precision specified out of line */
    if(spec.fInfo.fPrecision == -2) {
      if(spec.fPrecisionPos == -1) {
        /* read the precision from the argument list */
        spec.fInfo.fPrecision = va_arg(ap, int);
      }
      else {
        /* handle positional parameter */
      }
      
      /* if it's negative, set it to zero */
      if(spec.fInfo.fPrecision < 0)
        spec.fInfo.fPrecision = 0;
    }
    
    handlerNum = (uint16_t)(spec.fInfo.fSpec - USPRINTF_BASE_FMT_HANDLERS);
    if (handlerNum < USPRINTF_NUM_FMT_HANDLERS) {
        /* query the info function for argument information */
        info = g_u_sprintf_infos[ handlerNum ].info;
        if(info > ufmt_simple_percent) { 
          switch(info) {

          case ufmt_count:
            /* set the spec's width to the # of chars written */
            spec.fInfo.fWidth = written;

          case ufmt_char:
          case ufmt_uchar:
          case ufmt_int:
            args.intValue = va_arg(ap, int);
            break;

          case ufmt_wchar:
            args.wcharValue = va_arg(ap, wchar_t);
            break;

          case ufmt_string:
            args.ptrValue = va_arg(ap, char*);
            break;
    
          case ufmt_wstring:
            args.ptrValue = va_arg(ap, wchar_t*);
            break;
    
          case ufmt_ustring:
            args.ptrValue = va_arg(ap, UChar*);
            break;

          case ufmt_pointer:
            args.ptrValue = va_arg(ap, void*);
            break;
    
          case ufmt_float:
            args.floatValue = (float) va_arg(ap, double);
            break;
    
          case ufmt_double:
            args.doubleValue = va_arg(ap, double);
            break;

          case ufmt_date:
            args.dateValue = va_arg(ap, UDate);
            break;

          default:
            break;  /* Should never get here */
          }
        }

        /* call the handler function */
        handler = g_u_sprintf_infos[ handlerNum ].handler;
        if(handler != 0) {
           written += (*handler)(&outStr, &spec.fInfo, &args);
        }
        else {
          /* just echo unknown tags */
          written += u_minstrncpy(&outStr, lastAlias, (int32_t)(alias - lastAlias));
        }
    }
    else {
      /* just echo unknown tags */
      written += u_minstrncpy(&outStr, lastAlias, (int32_t)(alias - lastAlias));
    }
    
    /* update the pointer in pattern and continue */
    alias += patCount;
  }
  
  /* return # of UChars written */
  return written;
}