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