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