intl/printf.c

   1 /* Formatted output to strings, using POSIX/XSI format strings with positions.
   2    Copyright (C) 2003 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  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 <stdlib.h>
  51 #include <string.h>
  52
  53 /* When building a DLL, we must export some functions.  Note that because
  54    the functions are only defined for binary backward compatibility, we
  55    don't need to use __declspec(dllimport) in any case.  */
  56 #if defined _MSC_VER && BUILDING_DLL
  57 # define DLL_EXPORTED __declspec(dllexport)
  58 #else
  59 # define DLL_EXPORTED
  60 #endif
  61
  62 #define STATIC static
  63
  64 /* Define auxiliary functions declared in "printf-args.h".  */
  65 #include "printf-args.c"
  66
  67 /* Define auxiliary functions declared in "printf-parse.h".  */
  68 #include "printf-parse.c"
  69
  70 /* Define functions declared in "vasnprintf.h".  */
  71 #define vasnprintf libintl_vasnprintf
  72 #include "vasnprintf.c"
  73 #if 0 /* not needed */
  74 #define asnprintf libintl_asnprintf
  75 #include "asnprintf.c"
  76 #endif
  77
  78 DLL_EXPORTED
  79 int
  80 libintl_vfprintf (FILE *stream, const char *format, va_list args)
  81 {
  82   if (strchr (format, '$') == NULL)
  83     return vfprintf (stream, format, args);
  84   else
  85     {
  86       size_t length;
  87       char *result = libintl_vasnprintf (NULL, &length, format, args);
  88       int retval = -1;
  89       if (result != NULL)
  90         {
  91           if (fwrite (result, 1, length, stream) == length)
  92             retval = length;
  93           free (result);
  94         }
  95       return retval;
  96     }
  97 }
  98
  99 DLL_EXPORTED
 100 int
 101 libintl_fprintf (FILE *stream, const char *format, ...)
 102 {
 103   va_list args;
 104   int retval;
 105
 106   va_start (args, format);
 107   retval = libintl_vfprintf (stream, format, args);
 108   va_end (args);
 109   return retval;
 110 }
 111
 112 DLL_EXPORTED
 113 int
 114 libintl_vprintf (const char *format, va_list args)
 115 {
 116   return libintl_vfprintf (stdout, format, args);
 117 }
 118
 119 DLL_EXPORTED
 120 int
 121 libintl_printf (const char *format, ...)
 122 {
 123   va_list args;
 124   int retval;
 125
 126   va_start (args, format);
 127   retval = libintl_vprintf (format, args);
 128   va_end (args);
 129   return retval;
 130 }
 131
 132 DLL_EXPORTED
 133 int
 134 libintl_vsprintf (char *resultbuf, const char *format, va_list args)
 135 {
 136   if (strchr (format, '$') == NULL)
 137     return vsprintf (resultbuf, format, args);
 138   else
 139     {
 140       size_t length = (size_t) ~0 / (4 * sizeof (char));
 141       char *result = libintl_vasnprintf (resultbuf, &length, format, args);
 142       if (result != resultbuf)
 143         {
 144           free (result);
 145           return -1;
 146         }
 147       else
 148         return length;
 149     }
 150 }
 151
 152 DLL_EXPORTED
 153 int
 154 libintl_sprintf (char *resultbuf, const char *format, ...)
 155 {
 156   va_list args;
 157   int retval;
 158
 159   va_start (args, format);
 160   retval = libintl_vsprintf (resultbuf, format, args);
 161   va_end (args);
 162   return retval;
 163 }
 164
 165 #if HAVE_SNPRINTF
 166
 167 # if HAVE_DECL__SNPRINTF
 168    /* Windows.  */
 169 #  define system_vsnprintf _vsnprintf
 170 # else
 171    /* Unix.  */
 172 #  define system_vsnprintf vsnprintf
 173 # endif
 174
 175 DLL_EXPORTED
 176 int
 177 libintl_vsnprintf (char *resultbuf, size_t length, const char *format, va_list args)
 178 {
 179   if (strchr (format, '$') == NULL)
 180     return system_vsnprintf (resultbuf, length, format, args);
 181   else
 182     {
 183       size_t maxlength = length;
 184       char *result = libintl_vasnprintf (resultbuf, &length, format, args);
 185       if (result != resultbuf)
 186         {
 187           if (maxlength > 0)
 188             {
 189               if (length < maxlength)
 190                 abort ();
 191               memcpy (resultbuf, result, maxlength - 1);
 192               resultbuf[maxlength - 1] = '\0';
 193             }
 194           free (result);
 195           return -1;
 196         }
 197       else
 198         return length;
 199     }
 200 }
 201
 202 DLL_EXPORTED
 203 int
 204 libintl_snprintf (char *resultbuf, size_t length, const char *format, ...)
 205 {
 206   va_list args;
 207   int retval;
 208
 209   va_start (args, format);
 210   retval = libintl_vsnprintf (resultbuf, length, format, args);
 211   va_end (args);
 212   return retval;
 213 }
 214
 215 #endif
 216
 217 #if HAVE_ASPRINTF
 218
 219 DLL_EXPORTED
 220 int
 221 libintl_vasprintf (char **resultp, const char *format, va_list args)
 222 {
 223   size_t length;
 224   char *result = libintl_vasnprintf (NULL, &length, format, args);
 225   if (result == NULL)
 226     return -1;
 227   *resultp = result;
 228   return length;
 229 }
 230
 231 DLL_EXPORTED
 232 int
 233 libintl_asprintf (char **resultp, const char *format, ...)
 234 {
 235   va_list args;
 236   int retval;
 237
 238   va_start (args, format);
 239   retval = libintl_vasprintf (resultp, format, args);
 240   va_end (args);
 241   return retval;
 242 }
 243
 244 #endif
 245
 246 #if HAVE_FWPRINTF
 247
 248 #include <wchar.h>
 249
 250 #define WIDE_CHAR_VERSION 1
 251
 252 /* Define auxiliary functions declared in "wprintf-parse.h".  */
 253 #include "printf-parse.c"
 254
 255 /* Define functions declared in "vasnprintf.h".  */
 256 #define vasnwprintf libintl_vasnwprintf
 257 #include "vasnprintf.c"
 258 #if 0 /* not needed */
 259 #define asnwprintf libintl_asnwprintf
 260 #include "asnprintf.c"
 261 #endif
 262
 263 # if HAVE_DECL__SNWPRINTF
 264    /* Windows.  */
 265 #  define system_vswprintf _vsnwprintf
 266 # else
 267    /* Unix.  */
 268 #  define system_vswprintf vswprintf
 269 # endif
 270
 271 DLL_EXPORTED
 272 int
 273 libintl_vfwprintf (FILE *stream, const wchar_t *format, va_list args)
 274 {
 275   if (wcschr (format, '$') == NULL)
 276     return vfwprintf (stream, format, args);
 277   else
 278     {
 279       size_t length;
 280       wchar_t *result = libintl_vasnwprintf (NULL, &length, format, args);
 281       int retval = -1;
 282       if (result != NULL)
 283         {
 284           size_t i;
 285           for (i = 0; i < length; i++)
 286             if (fputwc (result[i], stream) == WEOF)
 287               break;
 288           if (i == length)
 289             retval = length;
 290           free (result);
 291         }
 292       return retval;
 293     }
 294 }
 295
 296 DLL_EXPORTED
 297 int
 298 libintl_fwprintf (FILE *stream, const wchar_t *format, ...)
 299 {
 300   va_list args;
 301   int retval;
 302
 303   va_start (args, format);
 304   retval = libintl_vfwprintf (stream, format, args);
 305   va_end (args);
 306   return retval;
 307 }
 308
 309 DLL_EXPORTED
 310 int
 311 libintl_vwprintf (const wchar_t *format, va_list args)
 312 {
 313   return libintl_vfwprintf (stdout, format, args);
 314 }
 315
 316 DLL_EXPORTED
 317 int
 318 libintl_wprintf (const wchar_t *format, ...)
 319 {
 320   va_list args;
 321   int retval;
 322
 323   va_start (args, format);
 324   retval = libintl_vwprintf (format, args);
 325   va_end (args);
 326   return retval;
 327 }
 328
 329 DLL_EXPORTED
 330 int
 331 libintl_vswprintf (wchar_t *resultbuf, size_t length, const wchar_t *format, va_list args)
 332 {
 333   if (wcschr (format, '$') == NULL)
 334     return system_vswprintf (resultbuf, length, format, args);
 335   else
 336     {
 337       size_t maxlength = length;
 338       wchar_t *result = libintl_vasnwprintf (resultbuf, &length, format, args);
 339       if (result != resultbuf)
 340         {
 341           if (maxlength > 0)
 342             {
 343               if (length < maxlength)
 344                 abort ();
 345               memcpy (resultbuf, result, (maxlength - 1) * sizeof (wchar_t));
 346               resultbuf[maxlength - 1] = 0;
 347             }
 348           free (result);
 349           return -1;
 350         }
 351       else
 352         return length;
 353     }
 354 }
 355
 356 DLL_EXPORTED
 357 int
 358 libintl_swprintf (wchar_t *resultbuf, size_t length, const wchar_t *format, ...)
 359 {
 360   va_list args;
 361   int retval;
 362
 363   va_start (args, format);
 364   retval = libintl_vswprintf (resultbuf, length, format, args);
 365   va_end (args);
 366   return retval;
 367 }
 368
 369 #endif
 370
 371 #endif