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
  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 "charset.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 characters 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   return doprnt1 (0, buffer, bufsize, format, format_end, nargs, args);
  73 }
  74
  75 /* Like doprnt except that strings in ARGS are passed
  76    as Lisp_Object.  */
  77
  78 int
  79 doprnt_lisp (buffer, bufsize, format, format_end, nargs, args)
  80      char *buffer;
  81      register int bufsize;
  82      char *format;
  83      char *format_end;
  84      int nargs;
  85      char **args;
  86 {
  87   return doprnt1 (1, buffer, bufsize, format, format_end, nargs, args);
  88 }
  89
  90 static int
  91 doprnt1 (lispstrings, buffer, bufsize, format, format_end, nargs, args)
  92      int lispstrings;
  93      char *buffer;
  94      register int bufsize;
  95      char *format;
  96      char *format_end;
  97      int nargs;
  98      char **args;
  99 {
 100   int cnt = 0;                  /* Number of arg to gobble next */
 101   register char *fmt = format;  /* Pointer into format string */
 102   register char *bufptr = buffer; /* Pointer into output buffer.. */
 103
 104   /* Use this for sprintf unless we need something really big.  */
 105   char tembuf[DBL_MAX_10_EXP + 100];
 106
 107   /* Size of sprintf_buffer.  */
 108   int size_allocated = sizeof (tembuf);
 109
 110   /* Buffer to use for sprintf.  Either tembuf or same as BIG_BUFFER.  */
 111   char *sprintf_buffer = tembuf;
 112
 113   /* Buffer we have got with malloc.  */
 114   char *big_buffer = 0;
 115
 116   register int tem;
 117   unsigned char *string;
 118   char fixed_buffer[20];        /* Default buffer for small formatting. */
 119   char *fmtcpy;
 120   int minlen;
 121   int size;                     /* Field width factor; e.g., %90d */
 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 = ((struct Lisp_String *)args[cnt])->size;
 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 }