icuSources/io/sprintf.cpp

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