[bpt/emacs.git] / src / doprnt.c

/* Output like sprintf to a buffer of specified size.
   Also takes args differently: pass one pointer to an array of strings
   in addition to the format string which is separate.
   Copyright (C) 1985 Free Software Foundation, Inc.

This file is part of GNU Emacs.

GNU Emacs is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 1, or (at your option)
any later version.

GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING.  If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */


#include <config.h>
#include <stdio.h>
#include <ctype.h>

/* Generate output from a format-spec FORMAT,
   terminated at position FORMAT_END.
   Output goes in BUFFER, which has room for BUFSIZE chars.
   If the output does not fit, truncate it to fit.
   Returns the number of characters stored into BUFFER.
   ARGS points to the vector of arguments, and NARGS says how many.
   A double counts as two arguments.  */

doprnt (buffer, bufsize, format, format_end, nargs, args)
     char *buffer;
     register int bufsize;
     char *format;
     char *format_end;
     int nargs;
     char **args;
{
  int cnt = 0;			/* Number of arg to gobble next */
  register char *fmt = format;	/* Pointer into format string */
  register char *bufptr = buffer; /* Pointer into output buffer.. */

  /* Use this for sprintf unless we need something really big.  */
  char tembuf[100];

  /* Size of sprintf_buffer.  */
  int size_allocated = 100;

  /* Buffer to use for sprintf.  Either tembuf or same as BIG_BUFFER.  */
  char *sprintf_buffer = tembuf;

  /* Buffer we have got with malloc.  */
  char *big_buffer = 0;

  register int tem;
  char *string;
  char fixed_buffer[20];	/* Default buffer for small formatting. */
  char *fmtcpy;
  int minlen;
  int size;			/* Field width factor; e.g., %90d */

  if (format_end == 0)
    format_end = format + strlen (format);

  if ((format_end - format + 1) < sizeof (fixed_buffer))
    fmtcpy = fixed_buffer;
  else
    fmtcpy = (char *) alloca (format_end - format + 1);

  bufsize--;

  /* Loop until end of format string or buffer full. */
  while (fmt != format_end && bufsize > 0)
    {
      if (*fmt == '%')	/* Check for a '%' character */
	{
	  int size_bound;

	  fmt++;
	  /* Copy this one %-spec into fmtcpy.  */
	  string = fmtcpy;
	  *string++ = '%';
	  while (1)
	    {
	      *string++ = *fmt;
	      if (! (*fmt >= '0' && *fmt <= '9')
		  && *fmt != '-' && *fmt != ' '&& *fmt != '.')
		break;
	      fmt++;
	    }
	  *string = 0;
	  /* Get an idea of how much space we might need.  */
	  size_bound = atoi (&fmtcpy[1]);

	  /* Avoid pitfall of negative "size" parameter ("%-200d"). */
	  if (size_bound < 0)
	    size_bound = -size_bound;
	  size_bound += 50;

	  /* Make sure we have that much.  */
	  if (size_bound > size_allocated)
	    {
	      if (big_buffer)
		big_buffer = (char *) xrealloc (big_buffer, size_bound);
	      else
		big_buffer = (char *) xmalloc (size_bound);
	      sprintf_buffer = big_buffer;
	      size_allocated = size_bound;
	    }
	  minlen = 0;
	  switch (*fmt++)
	    {
	    default:
	      error ("Invalid format operation %%%c", fmt[-1]);

/*	    case 'b': */
	    case 'd':
	    case 'o':
	    case 'x':
	      if (cnt == nargs)
		error ("Format string wants too many arguments");
	      sprintf (sprintf_buffer, fmtcpy, args[cnt++]);
	      /* Now copy into final output, truncating as nec.  */
	      string = sprintf_buffer;
	      goto doit;

	    case 'f':
	    case 'e':
	    case 'g':
	      {
		union { double d; char *half[2]; } u;
		if (cnt + 1 == nargs)
		  error ("Format string wants too many arguments");
		u.half[0] = args[cnt++];
		u.half[1] = args[cnt++];
		sprintf (sprintf_buffer, fmtcpy, u.d);
		/* Now copy into final output, truncating as nec.  */
		string = sprintf_buffer;
		goto doit;
	      }

	    case 'S':
	      string[-1] = 's';
	    case 's':
	      if (cnt == nargs)
		error ("Format string wants too many arguments");
	      string = args[cnt++];
	      if (fmtcpy[1] != 's')
		minlen = atoi (&fmtcpy[1]);
	      /* Copy string into final output, truncating if no room.  */
	    doit:
	      tem = strlen (string);
	      if (minlen > 0)
		{
		  while (minlen > tem && bufsize > 0)
		    {
		      *bufptr++ = ' ';
		      bufsize--;
		      minlen--;
		    }
		  minlen = 0;
		}
	      if (tem > bufsize)
		tem = bufsize;
	      strncpy (bufptr, string, tem);
	      bufptr += tem;
	      bufsize -= tem;
	      if (minlen < 0)
		{
		  while (minlen < - tem && bufsize > 0)
		    {
		      *bufptr++ = ' ';
		      bufsize--;
		      minlen++;
		    }
		  minlen = 0;
		}
	      continue;

	    case 'c':
	      if (cnt == nargs)
		error ("Format string wants too many arguments");
	      *bufptr++ = (int) args[cnt++];
	      bufsize--;
	      continue;

	    case '%':
	      fmt--;    /* Drop thru and this % will be treated as normal */
	    }
	}
      *bufptr++ = *fmt++;	/* Just some characters; Copy 'em */
      bufsize--;
    };

  /* If we had to malloc something, free it.  */
  if (big_buffer)
    xfree (big_buffer);

  *bufptr = 0;		/* Make sure our string end with a '\0' */
  return bufptr - buffer;
}
Commit	Line	Data
24f98398 JA	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
6d291527	23	#include <config.h>
24f98398 JA	24	#include <stdio.h>
	25	#include <ctype.h>
	26
f4c730d3 RS	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
24f98398 JA	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.. */
03383aaf	46
f4c730d3 RS	47	/* Use this for sprintf unless we need something really big. */
f4c730d3 RS	48	char tembuf[100];
03383aaf	49
f4c730d3 RS	50	/* Size of sprintf_buffer. */
f4c730d3 RS	51	int size_allocated = 100;
03383aaf	52
f4c730d3 RS	53	/* Buffer to use for sprintf. Either tembuf or same as BIG_BUFFER. */
f4c730d3 RS	54	char *sprintf_buffer = tembuf;
03383aaf	55
f4c730d3 RS	56	/* Buffer we have got with malloc. */
f4c730d3 RS	57	char *big_buffer = 0;
03383aaf	58
24f98398 JA	59	register int tem;
24f98398 JA	60	char *string;
03383aaf BF	61	char fixed_buffer[20]; /* Default buffer for small formatting. */
03383aaf BF	62	char *fmtcpy;
24f98398 JA	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
03383aaf BF	69	if ((format_end - format + 1) < sizeof (fixed_buffer))
	70	fmtcpy = fixed_buffer;
	71	else
91098d38	72	fmtcpy = (char *) alloca (format_end - format + 1);
03383aaf	73
24f98398	74	bufsize--;
03383aaf BF	75
	76	/* Loop until end of format string or buffer full. */
	77	while (fmt != format_end && bufsize > 0)
24f98398 JA	78	{
	79	if (fmt == '%') / Check for a '%' character */
	80	{
f4c730d3 RS	81	int size_bound;
f4c730d3 RS	82
24f98398	83	fmt++;
d427b66a	84	/* Copy this one %-spec into fmtcpy. */
24f98398 JA	85	string = fmtcpy;
24f98398 JA	86	*string++ = '%';
03383aaf	87	while (1)
24f98398 JA	88	{
24f98398 JA	89	string++ = fmt;
03383aaf BF	90	if (! (fmt >= '0' && fmt <= '9')
03383aaf BF	91	&& fmt != '-' && fmt != ' '&& *fmt != '.')
24f98398 JA	92	break;
	93	fmt++;
	94	}
	95	*string = 0;
f4c730d3	96	/* Get an idea of how much space we might need. */
dfd351ef	97	size_bound = atoi (&fmtcpy[1]);
03383aaf BF	98
	99	/* Avoid pitfall of negative "size" parameter ("%-200d"). */
	100	if (size_bound < 0)
	101	size_bound = -size_bound;
dfd351ef	102	size_bound += 50;
03383aaf	103
f4c730d3 RS	104	/* Make sure we have that much. */
	105	if (size_bound > size_allocated)
	106	{
	107	if (big_buffer)
	108	big_buffer = (char *) xrealloc (big_buffer, size_bound);
	109	else
	110	big_buffer = (char *) xmalloc (size_bound);
	111	sprintf_buffer = big_buffer;
	112	size_allocated = size_bound;
	113	}
24f98398 JA	114	minlen = 0;
	115	switch (*fmt++)
	116	{
	117	default:
	118	error ("Invalid format operation %%%c", fmt[-1]);
	119
	120	/* case 'b': */
	121	case 'd':
	122	case 'o':
	123	case 'x':
	124	if (cnt == nargs)
	125	error ("Format string wants too many arguments");
f4c730d3 RS	126	sprintf (sprintf_buffer, fmtcpy, args[cnt++]);
	127	/* Now copy into final output, truncating as nec. */
	128	string = sprintf_buffer;
24f98398 JA	129	goto doit;
24f98398 JA	130
f4c730d3 RS	131	case 'f':
	132	case 'e':
	133	case 'g':
	134	{
	135	union { double d; char *half[2]; } u;
	136	if (cnt + 1 == nargs)
	137	error ("Format string wants too many arguments");
	138	u.half[0] = args[cnt++];
	139	u.half[1] = args[cnt++];
	140	sprintf (sprintf_buffer, fmtcpy, u.d);
	141	/* Now copy into final output, truncating as nec. */
	142	string = sprintf_buffer;
	143	goto doit;
	144	}
	145
24f98398 JA	146	case 'S':
	147	string[-1] = 's';
	148	case 's':
	149	if (cnt == nargs)
	150	error ("Format string wants too many arguments");
	151	string = args[cnt++];
	152	if (fmtcpy[1] != 's')
	153	minlen = atoi (&fmtcpy[1]);
	154	/* Copy string into final output, truncating if no room. */
	155	doit:
	156	tem = strlen (string);
	157	if (minlen > 0)
	158	{
	159	while (minlen > tem && bufsize > 0)
	160	{
	161	*bufptr++ = ' ';
	162	bufsize--;
	163	minlen--;
	164	}
	165	minlen = 0;
	166	}
	167	if (tem > bufsize)
	168	tem = bufsize;
	169	strncpy (bufptr, string, tem);
	170	bufptr += tem;
	171	bufsize -= tem;
	172	if (minlen < 0)
	173	{
	174	while (minlen < - tem && bufsize > 0)
	175	{
	176	*bufptr++ = ' ';
	177	bufsize--;
	178	minlen++;
	179	}
	180	minlen = 0;
	181	}
	182	continue;
	183
	184	case 'c':
	185	if (cnt == nargs)
	186	error ("Format string wants too many arguments");
	187	*bufptr++ = (int) args[cnt++];
	188	bufsize--;
	189	continue;
	190
	191	case '%':
	192	fmt--; /* Drop thru and this % will be treated as normal */
	193	}
	194	}
	195	bufptr++ = fmt++; /* Just some characters; Copy 'em */
	196	bufsize--;
	197	};
	198
f4c730d3 RS	199	/* If we had to malloc something, free it. */
f4c730d3 RS	200	if (big_buffer)
9ac0d9e0	201	xfree (big_buffer);
f4c730d3	202
24f98398 JA	203	bufptr = 0; / Make sure our string end with a '\0' */
	204	return bufptr - buffer;
	205	}