src/doprnt.c

   1 /* Output like sprintf to a buffer of specified size.
   2    Also takes args differently: pass one pointer to an array of strings
   3    in addition to the format string which is separate.
   4    Copyright (C) 1985, 2001, 2002, 2003, 2004, 2005,
   5                  2006, 2007, 2008, 2009, 2010, 2011  Free Software Foundation, Inc.
   6
   7 This file is part of GNU Emacs.
   8
   9 GNU Emacs is free software: you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation, either version 3 of the License, or
  12 (at your option) any later version.
  13
  14 GNU Emacs is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22
  23 #include <config.h>
  24 #include <stdio.h>
  25 #include <ctype.h>
  26 #include <setjmp.h>
  27
  28 #ifdef STDC_HEADERS
  29 #include <float.h>
  30 #endif
  31
  32 #ifdef HAVE_UNISTD_H
  33 #include <unistd.h>
  34 #endif
  35
  36 #ifdef HAVE_STDLIB_H
  37 #include <stdlib.h>
  38 #endif
  39
  40 #include "lisp.h"
  41
  42 #ifndef DBL_MAX_10_EXP
  43 #define DBL_MAX_10_EXP 308 /* IEEE double */
  44 #endif
  45
  46 /* Since we use the macro CHAR_HEAD_P, we have to include this, but
  47    don't have to include others because CHAR_HEAD_P does not contains
  48    another macro.  */
  49 #include "character.h"
  50
  51 static int doprnt1 ();
  52
  53 /* Generate output from a format-spec FORMAT,
  54    terminated at position FORMAT_END.
  55    Output goes in BUFFER, which has room for BUFSIZE chars.
  56    If the output does not fit, truncate it to fit.
  57    Returns the number of bytes stored into BUFFER.
  58    ARGS points to the vector of arguments, and NARGS says how many.
  59    A double counts as two arguments.
  60    String arguments are passed as C strings.
  61    Integers are passed as C integers.  */
  62
  63 int
  64 doprnt (buffer, bufsize, format, format_end, nargs, args)
  65      char *buffer;
  66      register int bufsize;
  67      char *format;
  68      char *format_end;
  69      int nargs;
  70      char **args;
  71 {
  72   int cnt = 0;                  /* Number of arg to gobble next */
  73   register char *fmt = format;  /* Pointer into format string */
  74   register char *bufptr = buffer; /* Pointer into output buffer.. */
  75
  76   /* Use this for sprintf unless we need something really big.  */
  77   char tembuf[DBL_MAX_10_EXP + 100];
  78
  79   /* Size of sprintf_buffer.  */
  80   unsigned size_allocated = sizeof (tembuf);
  81
  82   /* Buffer to use for sprintf.  Either tembuf or same as BIG_BUFFER.  */
  83   char *sprintf_buffer = tembuf;
  84
  85   /* Buffer we have got with malloc.  */
  86   char *big_buffer = 0;
  87
  88   register int tem;
  89   unsigned char *string;
  90   char fixed_buffer[20];        /* Default buffer for small formatting. */
  91   char *fmtcpy;
  92   int minlen;
  93   unsigned char charbuf[MAX_MULTIBYTE_LENGTH + 1];      /* Used for %c.  */
  94
  95   if (format_end == 0)
  96     format_end = format + strlen (format);
  97
  98   if ((format_end - format + 1) < sizeof (fixed_buffer))
  99     fmtcpy = fixed_buffer;
 100   else
 101     fmtcpy = (char *) alloca (format_end - format + 1);
 102
 103   bufsize--;
 104
 105   /* Loop until end of format string or buffer full. */
 106   while (fmt != format_end && bufsize > 0)
 107     {
 108       if (*fmt == '%')  /* Check for a '%' character */
 109         {
 110           unsigned size_bound = 0;
 111           int width;            /* Columns occupied by STRING.  */
 112
 113           fmt++;
 114           /* Copy this one %-spec into fmtcpy.  */
 115           string = (unsigned char *) fmtcpy;
 116           *string++ = '%';
 117           while (1)
 118             {
 119               *string++ = *fmt;
 120               if ('0' <= *fmt && *fmt <= '9')
 121                 {
 122                   /* Get an idea of how much space we might need.
 123                      This might be a field width or a precision; e.g.
 124                      %1.1000f and %1000.1f both might need 1000+ bytes.
 125                      Parse the width or precision, checking for overflow.  */
 126                   unsigned n = *fmt - '0';
 127                   while ('0' <= fmt[1] && fmt[1] <= '9')
 128                     {
 129                       if (n * 10 + fmt[1] - '0' < n)
 130                         error ("Format width or precision too large");
 131                       n = n * 10 + fmt[1] - '0';
 132                       *string++ = *++fmt;
 133                     }
 134
 135                   if (size_bound < n)
 136                     size_bound = n;
 137                 }
 138               else if (*fmt == '-' || *fmt == ' ' || *fmt == '.' || *fmt == '+')
 139                 ;
 140               else
 141                 break;
 142               fmt++;
 143             }
 144           *string = 0;
 145
 146           /* Make the size bound large enough to handle floating point formats
 147              with large numbers.  */
 148           if (size_bound + DBL_MAX_10_EXP + 50 < size_bound)
 149             error ("Format width or precision too large");
 150           size_bound += DBL_MAX_10_EXP + 50;
 151
 152           /* Make sure we have that much.  */
 153           if (size_bound > size_allocated)
 154             {
 155               if (big_buffer)
 156                 big_buffer = (char *) xrealloc (big_buffer, size_bound);
 157               else
 158                 big_buffer = (char *) xmalloc (size_bound);
 159               sprintf_buffer = big_buffer;
 160               size_allocated = size_bound;
 161             }
 162           minlen = 0;
 163           switch (*fmt++)
 164             {
 165             default:
 166               error ("Invalid format operation %%%c", fmt[-1]);
 167
 168 /*          case 'b': */
 169             case 'd':
 170             case 'o':
 171             case 'x':
 172               if (cnt == nargs)
 173                 error ("Not enough arguments for format string");
 174               if (sizeof (int) == sizeof (EMACS_INT))
 175                 ;
 176               else if (sizeof (long) == sizeof (EMACS_INT))
 177                 /* Insert an `l' the right place.  */
 178                 string[1] = string[0],
 179                 string[0] = string[-1],
 180                 string[-1] = 'l',
 181                 string++;
 182               else
 183                 abort ();
 184               sprintf (sprintf_buffer, fmtcpy, args[cnt++]);
 185               /* Now copy into final output, truncating as nec.  */
 186               string = (unsigned char *) sprintf_buffer;
 187               goto doit;
 188
 189             case 'f':
 190             case 'e':
 191             case 'g':
 192               {
 193                 union { double d; char *half[2]; } u;
 194                 if (cnt + 1 == nargs)
 195                   error ("Not enough arguments for format string");
 196                 u.half[0] = args[cnt++];
 197                 u.half[1] = args[cnt++];
 198                 sprintf (sprintf_buffer, fmtcpy, u.d);
 199                 /* Now copy into final output, truncating as nec.  */
 200                 string = (unsigned char *) sprintf_buffer;
 201                 goto doit;
 202               }
 203
 204             case 'S':
 205               string[-1] = 's';
 206             case 's':
 207               if (cnt == nargs)
 208                 error ("Not enough arguments for format string");
 209               if (fmtcpy[1] != 's')
 210                 minlen = atoi (&fmtcpy[1]);
 211               string = (unsigned char *) args[cnt++];
 212               tem = strlen (string);
 213               width = strwidth (string, tem);
 214               goto doit1;
 215
 216               /* Copy string into final output, truncating if no room.  */
 217             doit:
 218               /* Coming here means STRING contains ASCII only.  */
 219               width = tem = strlen (string);
 220             doit1:
 221               /* We have already calculated:
 222                  TEM -- length of STRING,
 223                  WIDTH -- columns occupied by STRING when displayed, and
 224                  MINLEN -- minimum columns of the output.  */
 225               if (minlen > 0)
 226                 {
 227                   while (minlen > width && bufsize > 0)
 228                     {
 229                       *bufptr++ = ' ';
 230                       bufsize--;
 231                       minlen--;
 232                     }
 233                   minlen = 0;
 234                 }
 235               if (tem > bufsize)
 236                 {
 237                   /* Truncate the string at character boundary.  */
 238                   tem = bufsize;
 239                   while (!CHAR_HEAD_P (string[tem - 1])) tem--;
 240                   bcopy (string, bufptr, tem);
 241                   /* We must calculate WIDTH again.  */
 242                   width = strwidth (bufptr, tem);
 243                 }
 244               else
 245                 bcopy (string, bufptr, tem);
 246               bufptr += tem;
 247               bufsize -= tem;
 248               if (minlen < 0)
 249                 {
 250                   while (minlen < - width && bufsize > 0)
 251                     {
 252                       *bufptr++ = ' ';
 253                       bufsize--;
 254                       minlen++;
 255                     }
 256                   minlen = 0;
 257                 }
 258               continue;
 259
 260             case 'c':
 261               if (cnt == nargs)
 262                 error ("Not enough arguments for format string");
 263               tem = CHAR_STRING ((int) (EMACS_INT) args[cnt], charbuf);
 264               string = charbuf;
 265               cnt++;
 266               string[tem] = 0;
 267               width = strwidth (string, tem);
 268               if (fmtcpy[1] != 'c')
 269                 minlen = atoi (&fmtcpy[1]);
 270               goto doit1;
 271
 272             case '%':
 273               fmt--;    /* Drop thru and this % will be treated as normal */
 274             }
 275         }
 276
 277       {
 278         /* Just some character; Copy it if the whole multi-byte form
 279            fit in the buffer.  */
 280         char *save_bufptr = bufptr;
 281
 282         do { *bufptr++ = *fmt++; }
 283         while (--bufsize > 0 && !CHAR_HEAD_P (*fmt));
 284         if (!CHAR_HEAD_P (*fmt))
 285           {
 286             bufptr = save_bufptr;
 287             break;
 288           }
 289       }
 290     };
 291
 292   /* If we had to malloc something, free it.  */
 293   xfree (big_buffer);
 294
 295   *bufptr = 0;          /* Make sure our string end with a '\0' */
 296   return bufptr - buffer;
 297 }
 298
 299 /* arch-tag: aa0ab528-7c5f-4c73-894c-aa2526a1efb3
 300    (do not change this comment) */