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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  21
  22
  23 #include <config.h>
  24 #include <stdio.h>
  25 #include <ctype.h>
  26
  27 /* Generate output from a format-spec FORMAT,
  28    terminated at position FORMAT_END.
  29    Output goes in BUFFER, which has room for BUFSIZE chars.
  30    If the output does not fit, truncate it to fit.
  31    Returns the number of characters stored into BUFFER.
  32    ARGS points to the vector of arguments, and NARGS says how many.
  33    A double counts as two arguments.  */
  34
  35 doprnt (buffer, bufsize, format, format_end, nargs, args)
  36      char *buffer;
  37      register int bufsize;
  38      char *format;
  39      char *format_end;
  40      int nargs;
  41      char **args;
  42 {
  43   int cnt = 0;                  /* Number of arg to gobble next */
  44   register char *fmt = format;  /* Pointer into format string */
  45   register char *bufptr = buffer; /* Pointer into output buffer.. */
  46
  47   /* Use this for sprintf unless we need something really big.  */
  48   char tembuf[100];
  49
  50   /* Size of sprintf_buffer.  */
  51   int size_allocated = 100;
  52
  53   /* Buffer to use for sprintf.  Either tembuf or same as BIG_BUFFER.  */
  54   char *sprintf_buffer = tembuf;
  55
  56   /* Buffer we have got with malloc.  */
  57   char *big_buffer = 0;
  58
  59   register int tem;
  60   char *string;
  61   char fixed_buffer[20];        /* Default buffer for small formatting. */
  62   char *fmtcpy;
  63   int minlen;
  64   int size;                     /* Field width factor; e.g., %90d */
  65
  66   if (format_end == 0)
  67     format_end = format + strlen (format);
  68
  69   if ((format_end - format + 1) < sizeof (fixed_buffer))
  70     fmtcpy = fixed_buffer;
  71   else
  72     fmtcpy = alloca (format_end - format + 1);
  73
  74   bufsize--;
  75
  76   /* Loop until end of format string or buffer full. */
  77   while (fmt != format_end && bufsize > 0)
  78     {
  79       if (*fmt == '%')  /* Check for a '%' character */
  80         {
  81           int size_bound;
  82
  83           fmt++;
  84           /* Copy this one %-spec into fmtcpy.  */
  85           string = fmtcpy;
  86           *string++ = '%';
  87           while (1)
  88             {
  89               *string++ = *fmt;
  90               if (! (*fmt >= '0' && *fmt <= '9')
  91                   && *fmt != '-' && *fmt != ' '&& *fmt != '.')
  92                 break;
  93               fmt++;
  94             }
  95           *string = 0;
  96           /* Get an idea of how much space we might need.  */
  97           size_bound = atoi (&fmtcpy[1]) + 50;
  98
  99           /* Avoid pitfall of negative "size" parameter ("%-200d"). */
 100           if (size_bound < 0)
 101             size_bound = -size_bound;
 102
 103           /* Make sure we have that much.  */
 104           if (size_bound > size_allocated)
 105             {
 106               if (big_buffer)
 107                 big_buffer = (char *) xrealloc (big_buffer, size_bound);
 108               else
 109                 big_buffer = (char *) xmalloc (size_bound);
 110               sprintf_buffer = big_buffer;
 111               size_allocated = size_bound;
 112             }
 113           minlen = 0;
 114           switch (*fmt++)
 115             {
 116             default:
 117               error ("Invalid format operation %%%c", fmt[-1]);
 118
 119 /*          case 'b': */
 120             case 'd':
 121             case 'o':
 122             case 'x':
 123               if (cnt == nargs)
 124                 error ("Format string wants too many arguments");
 125               sprintf (sprintf_buffer, fmtcpy, args[cnt++]);
 126               /* Now copy into final output, truncating as nec.  */
 127               string = sprintf_buffer;
 128               goto doit;
 129
 130             case 'f':
 131             case 'e':
 132             case 'g':
 133               {
 134                 union { double d; char *half[2]; } u;
 135                 if (cnt + 1 == nargs)
 136                   error ("Format string wants too many arguments");
 137                 u.half[0] = args[cnt++];
 138                 u.half[1] = args[cnt++];
 139                 sprintf (sprintf_buffer, fmtcpy, u.d);
 140                 /* Now copy into final output, truncating as nec.  */
 141                 string = sprintf_buffer;
 142                 goto doit;
 143               }
 144
 145             case 'S':
 146               string[-1] = 's';
 147             case 's':
 148               if (cnt == nargs)
 149                 error ("Format string wants too many arguments");
 150               string = args[cnt++];
 151               if (fmtcpy[1] != 's')
 152                 minlen = atoi (&fmtcpy[1]);
 153               /* Copy string into final output, truncating if no room.  */
 154             doit:
 155               tem = strlen (string);
 156               if (minlen > 0)
 157                 {
 158                   while (minlen > tem && bufsize > 0)
 159                     {
 160                       *bufptr++ = ' ';
 161                       bufsize--;
 162                       minlen--;
 163                     }
 164                   minlen = 0;
 165                 }
 166               if (tem > bufsize)
 167                 tem = bufsize;
 168               strncpy (bufptr, string, tem);
 169               bufptr += tem;
 170               bufsize -= tem;
 171               if (minlen < 0)
 172                 {
 173                   while (minlen < - tem && bufsize > 0)
 174                     {
 175                       *bufptr++ = ' ';
 176                       bufsize--;
 177                       minlen++;
 178                     }
 179                   minlen = 0;
 180                 }
 181               continue;
 182
 183             case 'c':
 184               if (cnt == nargs)
 185                 error ("Format string wants too many arguments");
 186               *bufptr++ = (int) args[cnt++];
 187               bufsize--;
 188               continue;
 189
 190             case '%':
 191               fmt--;    /* Drop thru and this % will be treated as normal */
 192             }
 193         }
 194       *bufptr++ = *fmt++;       /* Just some characters; Copy 'em */
 195       bufsize--;
 196     };
 197
 198   /* If we had to malloc something, free it.  */
 199   if (big_buffer)
 200     xfree (big_buffer);
 201
 202   *bufptr = 0;          /* Make sure our string end with a '\0' */
 203   return bufptr - buffer;
 204 }