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