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@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) */
36static int32_t
37u_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
49static int32_t
50u_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
100U_CAPI int32_t U_EXPORT2
101u_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
115U_CAPI int32_t U_EXPORT2
116u_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
130U_CAPI int32_t U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
131u_vsprintf(UChar       *buffer,
132           const char     *patternSpecification,
133           va_list         ap)
134{
135    return u_vsnprintf(buffer, INT32_MAX, patternSpecification, ap);
136}
137
138U_CAPI int32_t U_EXPORT2
139u_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
154U_CAPI int32_t U_EXPORT2
155u_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
170U_CAPI int32_t  U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
171u_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
204U_CAPI int32_t U_EXPORT2
205u_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
212static const u_printf_stream_handler g_sprintf_stream_handler = {
213    u_sprintf_write,
214    u_sprintf_pad_and_justify
215};
216
217U_CAPI int32_t  U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
218u_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