Home | History | Annotate | Download | only in io
      1 /*
      2 ******************************************************************************
      3 *
      4 *   Copyright (C) 2001-2008, International Business Machines
      5 *   Corporation and others.  All Rights Reserved.
      6 *
      7 ******************************************************************************
      8 *
      9 * File sprintf.c
     10 *
     11 * Modification History:
     12 *
     13 *   Date        Name            Description
     14 *   02/08/2001  george          Creation. Copied from uprintf.c
     15 *   03/27/2002  Mark Schneckloth Many fixes regarding alignment, null termination
     16 *       (mschneckloth (at) atomz.com) and other various problems.
     17 *   08/07/2003  george          Reunify printf implementations
     18 *******************************************************************************
     19 */
     20 
     21 #include "unicode/utypes.h"
     22 
     23 #if !UCONFIG_NO_FORMATTING
     24 
     25 #include "unicode/ustdio.h"
     26 #include "unicode/ustring.h"
     27 #include "unicode/putil.h"
     28 
     29 #include "uprintf.h"
     30 #include "locbund.h"
     31 
     32 #include "cmemory.h"
     33 #include <ctype.h>
     34 
     35 /* u_minstrncpy copies the minimum number of code units of (count or output->available) */
     36 static int32_t
     37 u_sprintf_write(void        *context,
     38                 const UChar *str,
     39                 int32_t     count)
     40 {
     41     u_localized_print_string *output = (u_localized_print_string *)context;
     42     int32_t size = ufmt_min(count, output->available);
     43 
     44     u_strncpy(output->str + (output->len - output->available), str, size);
     45     output->available -= size;
     46     return size;
     47 }
     48 
     49 static int32_t
     50 u_sprintf_pad_and_justify(void                        *context,
     51                           const u_printf_spec_info    *info,
     52                           const UChar                 *result,
     53                           int32_t                     resultLen)
     54 {
     55     u_localized_print_string *output = (u_localized_print_string *)context;
     56     int32_t written = 0;
     57     int32_t lengthOfResult = resultLen;
     58 
     59     resultLen = ufmt_min(resultLen, output->available);
     60 
     61     /* pad and justify, if needed */
     62     if(info->fWidth != -1 && resultLen < info->fWidth) {
     63         int32_t paddingLeft = info->fWidth - resultLen;
     64         int32_t outputPos = output->len - output->available;
     65 
     66         if (paddingLeft + resultLen > output->available) {
     67             paddingLeft = output->available - resultLen;
     68             if (paddingLeft < 0) {
     69                 paddingLeft = 0;
     70             }
     71             /* paddingLeft = output->available - resultLen;*/
     72         }
     73         written += paddingLeft;
     74 
     75         /* left justify */
     76         if(info->fLeft) {
     77             written += u_sprintf_write(output, result, resultLen);
     78             u_memset(&output->str[outputPos + resultLen], info->fPadChar, paddingLeft);
     79             output->available -= paddingLeft;
     80         }
     81         /* right justify */
     82         else {
     83             u_memset(&output->str[outputPos], info->fPadChar, paddingLeft);
     84             output->available -= paddingLeft;
     85             written += u_sprintf_write(output, result, resultLen);
     86         }
     87     }
     88     /* just write the formatted output */
     89     else {
     90         written = u_sprintf_write(output, result, resultLen);
     91     }
     92 
     93     if (written >= 0 && lengthOfResult > written) {
     94     	return lengthOfResult;
     95     }
     96 
     97     return written;
     98 }
     99 
    100 U_CAPI int32_t U_EXPORT2
    101 u_sprintf(UChar       *buffer,
    102           const char    *patternSpecification,
    103           ... )
    104 {
    105     va_list ap;
    106     int32_t written;
    107 
    108     va_start(ap, patternSpecification);
    109     written = u_vsnprintf(buffer, INT32_MAX, patternSpecification, ap);
    110     va_end(ap);
    111 
    112     return written;
    113 }
    114 
    115 U_CAPI int32_t U_EXPORT2
    116 u_sprintf_u(UChar     *buffer,
    117             const UChar    *patternSpecification,
    118             ... )
    119 {
    120     va_list ap;
    121     int32_t written;
    122 
    123     va_start(ap, patternSpecification);
    124     written = u_vsnprintf_u(buffer, INT32_MAX, patternSpecification, ap);
    125     va_end(ap);
    126 
    127     return written;
    128 }
    129 
    130 U_CAPI int32_t U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
    131 u_vsprintf(UChar       *buffer,
    132            const char     *patternSpecification,
    133            va_list         ap)
    134 {
    135     return u_vsnprintf(buffer, INT32_MAX, patternSpecification, ap);
    136 }
    137 
    138 U_CAPI int32_t U_EXPORT2
    139 u_snprintf(UChar       *buffer,
    140            int32_t         count,
    141            const char    *patternSpecification,
    142            ... )
    143 {
    144     va_list ap;
    145     int32_t written;
    146 
    147     va_start(ap, patternSpecification);
    148     written = u_vsnprintf(buffer, count, patternSpecification, ap);
    149     va_end(ap);
    150 
    151     return written;
    152 }
    153 
    154 U_CAPI int32_t U_EXPORT2
    155 u_snprintf_u(UChar     *buffer,
    156              int32_t        count,
    157              const UChar    *patternSpecification,
    158              ... )
    159 {
    160     va_list ap;
    161     int32_t written;
    162 
    163     va_start(ap, patternSpecification);
    164     written = u_vsnprintf_u(buffer, count, patternSpecification, ap);
    165     va_end(ap);
    166 
    167     return written;
    168 }
    169 
    170 U_CAPI int32_t  U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
    171 u_vsnprintf(UChar       *buffer,
    172             int32_t         count,
    173             const char     *patternSpecification,
    174             va_list         ap)
    175 {
    176     int32_t written;
    177     UChar *pattern;
    178     UChar patBuffer[UFMT_DEFAULT_BUFFER_SIZE];
    179     int32_t size = (int32_t)strlen(patternSpecification) + 1;
    180 
    181     /* convert from the default codepage to Unicode */
    182     if (size >= MAX_UCHAR_BUFFER_SIZE(patBuffer)) {
    183         pattern = (UChar *)uprv_malloc(size * sizeof(UChar));
    184         if(pattern == 0) {
    185             return 0;
    186         }
    187     }
    188     else {
    189         pattern = patBuffer;
    190     }
    191     u_charsToUChars(patternSpecification, pattern, size);
    192 
    193     /* do the work */
    194     written = u_vsnprintf_u(buffer, count, pattern, ap);
    195 
    196     /* clean up */
    197     if (pattern != patBuffer) {
    198         uprv_free(pattern);
    199     }
    200 
    201     return written;
    202 }
    203 
    204 U_CAPI int32_t U_EXPORT2
    205 u_vsprintf_u(UChar       *buffer,
    206              const UChar *patternSpecification,
    207              va_list     ap)
    208 {
    209     return u_vsnprintf_u(buffer, INT32_MAX, patternSpecification, ap);
    210 }
    211 
    212 static const u_printf_stream_handler g_sprintf_stream_handler = {
    213     u_sprintf_write,
    214     u_sprintf_pad_and_justify
    215 };
    216 
    217 U_CAPI int32_t  U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
    218 u_vsnprintf_u(UChar    *buffer,
    219               int32_t        count,
    220               const UChar    *patternSpecification,
    221               va_list        ap)
    222 {
    223     int32_t          written = 0;   /* haven't written anything yet */
    224     int32_t			 result = 0; /* test the return value of u_printf_parse */
    225 
    226     u_localized_print_string outStr;
    227 
    228     if (count < 0) {
    229         count = INT32_MAX;
    230     }
    231 
    232     outStr.str = buffer;
    233     outStr.len = count;
    234     outStr.available = count;
    235 
    236     if(u_locbund_init(&outStr.fBundle, "en_US_POSIX") == 0) {
    237         return 0;
    238     }
    239 
    240     /* parse and print the whole format string */
    241     result = u_printf_parse(&g_sprintf_stream_handler, patternSpecification, &outStr, &outStr, &outStr.fBundle, &written, ap);
    242 
    243     /* Terminate the buffer, if there's room. */
    244     if (outStr.available > 0) {
    245         buffer[outStr.len - outStr.available] = 0x0000;
    246     }
    247 
    248     /* Release the cloned bundle, if we cloned it. */
    249     u_locbund_close(&outStr.fBundle);
    250 
    251     /* parsing error */
    252     if (result < 0) {
    253     	return result;
    254     }
    255     /* return # of UChars written */
    256     return written;
    257 }
    258 
    259 #endif /* #if !UCONFIG_NO_FORMATTING */
    260 
    261