A bunch of minor changes for Windows.
[gnupg.git] / intl / printf.c
1 /* Formatted output to strings, using POSIX/XSI format strings with positions.
2    Copyright (C) 2003, 2006 Free Software Foundation, Inc.
3    Written by Bruno Haible <bruno@clisp.org>, 2003.
4
5    This program is free software; you can redistribute it and/or modify it
6    under the terms of the GNU Library General Public License as published
7    by the Free Software Foundation; either version 2, or (at your option)
8    any later version.
9
10    This program is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    Library General Public License for more details.
14
15    You should have received a copy of the GNU Library General Public
16    License along with this program; if not, write to the Free Software
17    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
18    USA.  */
19
20 #ifdef HAVE_CONFIG_H
21 # include <config.h>
22 #endif
23
24 #ifdef __GNUC__
25 # define alloca __builtin_alloca
26 # define HAVE_ALLOCA 1
27 #else
28 # ifdef _MSC_VER
29 #  include <malloc.h>
30 #  define alloca _alloca
31 # else
32 #  if defined HAVE_ALLOCA_H || defined _LIBC
33 #   include <alloca.h>
34 #  else
35 #   ifdef _AIX
36  #pragma alloca
37 #   else
38 #    ifndef alloca
39 char *alloca ();
40 #    endif
41 #   endif
42 #  endif
43 # endif
44 #endif
45
46 #include <stdio.h>
47
48 #if !HAVE_POSIX_PRINTF
49
50 #include <errno.h>
51 #include <limits.h>
52 #include <stdlib.h>
53 #include <string.h>
54
55 /* Some systems, like OSF/1 4.0 and Woe32, don't have EOVERFLOW.  */
56 #ifndef EOVERFLOW
57 # define EOVERFLOW E2BIG
58 #endif
59
60 /* When building a DLL, we must export some functions.  Note that because
61    the functions are only defined for binary backward compatibility, we
62    don't need to use __declspec(dllimport) in any case.  */
63 #if defined _MSC_VER && BUILDING_DLL
64 # define DLL_EXPORTED __declspec(dllexport)
65 #else
66 # define DLL_EXPORTED
67 #endif
68
69 #define STATIC static
70
71 /* This needs to be consistent with libgnuintl.h.in.  */
72 #if defined __NetBSD__ || defined __CYGWIN__ || defined __MINGW32__
73 /* Don't break __attribute__((format(printf,M,N))).
74    This redefinition is only possible because the libc in NetBSD, Cygwin,
75    mingw does not have a function __printf__.  */
76 # define libintl_printf __printf__
77 #endif
78
79 /* Define auxiliary functions declared in "printf-args.h".  */
80 #include "printf-args.c"
81
82 /* Define auxiliary functions declared in "printf-parse.h".  */
83 #include "printf-parse.c"
84
85 /* Define functions declared in "vasnprintf.h".  */
86 #define vasnprintf libintl_vasnprintf
87 #include "vasnprintf.c"
88 #if 0 /* not needed */
89 #define asnprintf libintl_asnprintf
90 #include "asnprintf.c"
91 #endif
92
93 DLL_EXPORTED
94 int
95 libintl_vfprintf (FILE *stream, const char *format, va_list args)
96 {
97   if (strchr (format, '$') == NULL)
98     return vfprintf (stream, format, args);
99   else
100     {
101       size_t length;
102       char *result = libintl_vasnprintf (NULL, &length, format, args);
103       int retval = -1;
104       if (result != NULL)
105         {
106           size_t written = fwrite (result, 1, length, stream);
107           free (result);
108           if (written == length)
109             {
110               if (length > INT_MAX)
111                 errno = EOVERFLOW;
112               else
113                 retval = length;
114             }
115         }
116       return retval;
117     }
118 }
119
120 DLL_EXPORTED
121 int
122 libintl_fprintf (FILE *stream, const char *format, ...)
123 {
124   va_list args;
125   int retval;
126
127   va_start (args, format);
128   retval = libintl_vfprintf (stream, format, args);
129   va_end (args);
130   return retval;
131 }
132
133 DLL_EXPORTED
134 int
135 libintl_vprintf (const char *format, va_list args)
136 {
137   return libintl_vfprintf (stdout, format, args);
138 }
139
140 DLL_EXPORTED
141 int
142 libintl_printf (const char *format, ...)
143 {
144   va_list args;
145   int retval;
146
147   va_start (args, format);
148   retval = libintl_vprintf (format, args);
149   va_end (args);
150   return retval;
151 }
152
153 DLL_EXPORTED
154 int
155 libintl_vsprintf (char *resultbuf, const char *format, va_list args)
156 {
157   if (strchr (format, '$') == NULL)
158     return vsprintf (resultbuf, format, args);
159   else
160     {
161       size_t length = (size_t) ~0 / (4 * sizeof (char));
162       char *result = libintl_vasnprintf (resultbuf, &length, format, args);
163       if (result != resultbuf)
164         {
165           free (result);
166           return -1;
167         }
168       if (length > INT_MAX)
169         {
170           errno = EOVERFLOW;
171           return -1;
172         }
173       else
174         return length;
175     }
176 }
177
178 DLL_EXPORTED
179 int
180 libintl_sprintf (char *resultbuf, const char *format, ...)
181 {
182   va_list args;
183   int retval;
184
185   va_start (args, format);
186   retval = libintl_vsprintf (resultbuf, format, args);
187   va_end (args);
188   return retval;
189 }
190
191 #if HAVE_SNPRINTF
192
193 # if HAVE_DECL__SNPRINTF
194    /* Windows.  */
195 #  define system_vsnprintf _vsnprintf
196 # else
197    /* Unix.  */
198 #  define system_vsnprintf vsnprintf
199 # endif
200
201 DLL_EXPORTED
202 int
203 libintl_vsnprintf (char *resultbuf, size_t length, const char *format, va_list args)
204 {
205   if (strchr (format, '$') == NULL)
206     return system_vsnprintf (resultbuf, length, format, args);
207   else
208     {
209       size_t maxlength = length;
210       char *result = libintl_vasnprintf (resultbuf, &length, format, args);
211       if (result != resultbuf)
212         {
213           if (maxlength > 0)
214             {
215               size_t pruned_length =
216                 (length < maxlength ? length : maxlength - 1);
217               memcpy (resultbuf, result, pruned_length);
218               resultbuf[pruned_length] = '\0';
219             }
220           free (result);
221         }
222       if (length > INT_MAX)
223         {
224           errno = EOVERFLOW;
225           return -1;
226         }
227       else
228         return length;
229     }
230 }
231
232 DLL_EXPORTED
233 int
234 libintl_snprintf (char *resultbuf, size_t length, const char *format, ...)
235 {
236   va_list args;
237   int retval;
238
239   va_start (args, format);
240   retval = libintl_vsnprintf (resultbuf, length, format, args);
241   va_end (args);
242   return retval;
243 }
244
245 #endif
246
247 #if HAVE_ASPRINTF
248
249 DLL_EXPORTED
250 int
251 libintl_vasprintf (char **resultp, const char *format, va_list args)
252 {
253   size_t length;
254   char *result = libintl_vasnprintf (NULL, &length, format, args);
255   if (result == NULL)
256     return -1;
257   if (length > INT_MAX)
258     {
259       free (result);
260       errno = EOVERFLOW;
261       return -1;
262     }
263   *resultp = result;
264   return length;
265 }
266
267 DLL_EXPORTED
268 int
269 libintl_asprintf (char **resultp, const char *format, ...)
270 {
271   va_list args;
272   int retval;
273
274   va_start (args, format);
275   retval = libintl_vasprintf (resultp, format, args);
276   va_end (args);
277   return retval;
278 }
279
280 #endif
281
282 #if HAVE_FWPRINTF
283
284 #include <wchar.h>
285
286 #define WIDE_CHAR_VERSION 1
287
288 /* Define auxiliary functions declared in "wprintf-parse.h".  */
289 #include "printf-parse.c"
290
291 /* Define functions declared in "vasnprintf.h".  */
292 #define vasnwprintf libintl_vasnwprintf
293 #include "vasnprintf.c"
294 #if 0 /* not needed */
295 #define asnwprintf libintl_asnwprintf
296 #include "asnprintf.c"
297 #endif
298
299 # if HAVE_DECL__SNWPRINTF
300    /* Windows.  */
301 #  define system_vswprintf _vsnwprintf
302 # else
303    /* Unix.  */
304 #  define system_vswprintf vswprintf
305 # endif
306
307 DLL_EXPORTED
308 int
309 libintl_vfwprintf (FILE *stream, const wchar_t *format, va_list args)
310 {
311   if (wcschr (format, '$') == NULL)
312     return vfwprintf (stream, format, args);
313   else
314     {
315       size_t length;
316       wchar_t *result = libintl_vasnwprintf (NULL, &length, format, args);
317       int retval = -1;
318       if (result != NULL)
319         {
320           size_t i;
321           for (i = 0; i < length; i++)
322             if (fputwc (result[i], stream) == WEOF)
323               break;
324           free (result);
325           if (i == length)
326             {
327               if (length > INT_MAX)
328                 errno = EOVERFLOW;
329               else
330                 retval = length;
331             }
332         }
333       return retval;
334     }
335 }
336
337 DLL_EXPORTED
338 int
339 libintl_fwprintf (FILE *stream, const wchar_t *format, ...)
340 {
341   va_list args;
342   int retval;
343
344   va_start (args, format);
345   retval = libintl_vfwprintf (stream, format, args);
346   va_end (args);
347   return retval;
348 }
349
350 DLL_EXPORTED
351 int
352 libintl_vwprintf (const wchar_t *format, va_list args)
353 {
354   return libintl_vfwprintf (stdout, format, args);
355 }
356
357 DLL_EXPORTED
358 int
359 libintl_wprintf (const wchar_t *format, ...)
360 {
361   va_list args;
362   int retval;
363
364   va_start (args, format);
365   retval = libintl_vwprintf (format, args);
366   va_end (args);
367   return retval;
368 }
369
370 DLL_EXPORTED
371 int
372 libintl_vswprintf (wchar_t *resultbuf, size_t length, const wchar_t *format, va_list args)
373 {
374   if (wcschr (format, '$') == NULL)
375     return system_vswprintf (resultbuf, length, format, args);
376   else
377     {
378       size_t maxlength = length;
379       wchar_t *result = libintl_vasnwprintf (resultbuf, &length, format, args);
380       if (result != resultbuf)
381         {
382           if (maxlength > 0)
383             {
384               size_t pruned_length =
385                 (length < maxlength ? length : maxlength - 1);
386               memcpy (resultbuf, result, pruned_length * sizeof (wchar_t));
387               resultbuf[pruned_length] = 0;
388             }
389           free (result);
390           /* Unlike vsnprintf, which has to return the number of character that
391              would have been produced if the resultbuf had been sufficiently
392              large, the vswprintf function has to return a negative value if
393              the resultbuf was not sufficiently large.  */
394           if (length >= maxlength)
395             return -1;
396         }
397       if (length > INT_MAX)
398         {
399           errno = EOVERFLOW;
400           return -1;
401         }
402       else
403         return length;
404     }
405 }
406
407 DLL_EXPORTED
408 int
409 libintl_swprintf (wchar_t *resultbuf, size_t length, const wchar_t *format, ...)
410 {
411   va_list args;
412   int retval;
413
414   va_start (args, format);
415   retval = libintl_vswprintf (resultbuf, length, format, args);
416   va_end (args);
417   return retval;
418 }
419
420 #endif
421
422 #endif