diff -up sane-frontends-1.0.14/lib/snprintf.c.OLD sane-frontends-1.0.14/lib/snprintf.c

--- sane-frontends-1.0.14/lib/snprintf.c.OLD	2001-08-03 17:32:56.000000000 -0400

+++ sane-frontends-1.0.14/lib/snprintf.c	2014-05-29 11:09:37.759003520 -0400

@@ -2,180 +2,616 @@

 #ifndef HAVE_SNPRINTF

-/***************************************************************************

- * LPRng - An Extended Print Spooler System

- *

- * Copyright 1988-1997, Patrick Powell, San Diego, CA

- *     papowell@sdsu.edu

- * See below for conditions of use.

- *

- ***************************************************************************

- * MODULE: snprintf.c

- * PURPOSE: LPRng version of printf - absolutely bombproof (hopefully!)

+/**************************************************************************

+ * Copyright 1994-2003 Patrick Powell, San Diego, CA <papowell@lprng.com>

  **************************************************************************/

-#if 0

-

-			 The "Artistic License"

-

-				Preamble

-

-The intent of this document is to state the conditions under which a

-Package may be copied, such that the Copyright Holder maintains some

-semblance of artistic control over the development of the package,

-while giving the users of the package the right to use and distribute

-the Package in a more-or-less customary fashion, plus the right to make

-reasonable modifications.

-

-Definitions:

-

-	"Package" refers to the collection of files distributed by the

-	Copyright Holder, and derivatives of that collection of files

-	created through textual modification.

-

-	"Standard Version" refers to such a Package if it has not been

-	modified, or has been modified in accordance with the wishes

-	of the Copyright Holder as specified below.

-

-	"Copyright Holder" is whoever is named in the copyright or

-	copyrights for the package.

-

-	"You" is you, if you are thinking about copying or distributing

-	this Package.

-

-	"Reasonable copying fee" is whatever you can justify on the

-	basis of media cost, duplication charges, time of people involved,

-	and so on.  (You will not be required to justify it to the

-	Copyright Holder, but only to the computing community at large

-	as a market that must bear the fee.)

-	"Freely Available" means that no fee is charged for the item

-	itself, though there may be fees involved in handling the item.

-	It also means that recipients of the item may redistribute it

-	under the same conditions they received it.

-

-1. You may make and give away verbatim copies of the source form of the

-Standard Version of this Package without restriction, provided that you

-duplicate all of the original copyright notices and associated disclaimers.

-

-2. You may apply bug fixes, portability fixes and other modifications

-derived from the Public Domain or from the Copyright Holder.  A Package

-modified in such a way shall still be considered the Standard Version.

-

-3. You may otherwise modify your copy of this Package in any way, provided

-that you insert a prominent notice in each changed file stating how and

-when you changed that file, and provided that you do at least ONE of the

-following:

-

-    a) place your modifications in the Public Domain or otherwise make them

-    Freely Available, such as by posting said modifications to Usenet or

-    an equivalent medium, or placing the modifications on a major archive

-    site such as uunet.uu.net, or by allowing the Copyright Holder to include

-    your modifications in the Standard Version of the Package.

-

-    b) use the modified Package only within your corporation or organization.

-

-    c) rename any non-standard executables so the names do not conflict

-    with standard executables, which must also be provided, and provide

-    a separate manual page for each non-standard executable that clearly

-    documents how it differs from the Standard Version.

-

-    d) make other distribution arrangements with the Copyright Holder.

-

-4. You may distribute the programs of this Package in object code or

-executable form, provided that you do at least ONE of the following:

+/*

+   Overview:

-    a) distribute a Standard Version of the executables and library files,

-    together with instructions (in the manual page or equivalent) on where

-    to get the Standard Version.

+   snprintf( char *buffer, int len, const char *format,...)

+   plp_unsafe_snprintf( char *buffer, int len, const char *format,...)

+     its horribly unsafe companion that does NOT protect you from

+     the printing of evil control characters,  but may be necessary

+     See the man page documentation below

+   

+   This version of snprintf was developed originally for printing

+   on a motley collection of specialized hardware that had NO IO

+   library.  Due to contractual restrictions,  a clean room implementation

+   of the printf() code had to be developed.

+   

+   The method chosen for printf was to be as paranoid as possible,

+   as these platforms had NO memory protection,  and very small

+   address spaces.  This made it possible to try to print

+   very long strings, i.e. - all of memory, very easily.  To guard

+   against this,  all printing was done via a buffer, generous enough

+   to hold strings,  but small enough to protect against overruns,

+   etc.

+   

+   Strangely enough,  this proved to be of immense importance when

+   SPRINTFing to a buffer on a stack...  The rest,  of course,  is

+   well known,  as buffer overruns in the stack are a common way to

+   do horrible things to operating systems, security, etc etc.

+   

+   This version of snprintf is VERY limited by modern standards.

+

+   Revision History:

+   First Released Version - 1994.  This version had NO comments.

+   First Released Version - 1994.  This version had NO comments.

+   Second Major Released Version - Tue May 23 10:43:44 PDT 2000

+    Configuration and other items changed.  Read this doc.

+    Treat this as a new version.

+   Minor Revision - Mon Apr  1 09:41:28 PST 2002

+     - fixed up some constants and casts 

+   

+   COPYRIGHT AND TERMS OF USE:

+   

+   You may use, copy, distribute, or otherwise incorporate this software

+   and documentation into any product or other item,  provided that

+   the copyright in the documentation and source code as well as the

+   source code generated constant strings in the object, executable

+   or other code remain in place and are present in executable modules

+   or objects.

+   

+   You may modify this code as appropriate to your usage; however the

+   modified version must be identified by changing the various source

+   and object code identification strings as is appropriately noted

+   in the source code.

+   

+   You can use this with the GNU CONFIGURE utility.

+   This should define the following macros appropriately:

+   

+   HAVE_STDARG_H - if the <stdargs.h> include file is available

+   HAVE_VARARG_H - if the <varargs.h> include file is available

+   

+   HAVE_STRERROR - if the strerror() routine is available.

+     If it is not available, then examine the lines containing

+     the tests below.

+

+   HAVE_SYS_ERRLIST  - have sys_errlist available

+   HAVE_DECL_SYS_ERRLIST - sys_errlist declaration in include files

+   HAVE_SYS_NERR - have sys_nerr available

+   HAVE_DECL_SYS_NERR -  sys_nerr declaration in include files

+   

+   HAVE_QUAD_T      - if the quad_t type is defined

+   HAVE_LONG_LONG   - if the long long type is defined

+   HAVE_LONG_DOUBLE - if the long double type is defined

+   

+     If you are using the GNU configure (autoconf) facility, add the

+     following line to the configure.in file, to force checking for the

+     quad_t and long long  data types:

+

+

+    AC_CHECK_HEADERS(stdlib.h,stdio.h,unistd.h,errno.h)

+	AC_CHECK_FUNCS(strerror)

+	AC_CACHE_CHECK(for errno,

+	ac_cv_errno,

+	[

+	AC_TRY_LINK(,[extern int errno; return (errno);],

+		ac_cv_errno=yes, ac_cv_errno=no)

+	])

+	if test "$ac_cv_errno" = yes; then

+		AC_DEFINE(HAVE_ERRNO)

+		AC_CACHE_CHECK(for errno declaration,

+		ac_cv_decl_errno,

+		[

+		AC_TRY_COMPILE([

+		#include <stdio.h>

+		#ifdef HAVE_STDLIB_H

+		#include <stdlib.h>

+		#endif

+		#ifdef HAVE_UNISTD_H

+		#include <unistd.h>

+		#endif

+		#ifdef HAVE_ERRNO_H

+		#include <errno.h>

+		],[return(sys_nerr);],

+			ac_cv_decl_errno=yes, ac_cv_decl_errno=no)

+		])

+		if test "$ac_cv_decl_errno" = yes; then

+			AC_DEFINE(HAVE_DECL_ERRNO)

+		fi;

+	fi

+

+	AC_CACHE_CHECK(for sys_nerr,

+	ac_cv_sys_nerr,

+	[

+	AC_TRY_LINK(,[extern int sys_nerr; return (sys_nerr);],

+		ac_cv_sys_nerr=yes, ac_cv_sys_nerr=no)

+	])

+	if test "$ac_cv_sys_nerr" = yes; then

+		AC_DEFINE(HAVE_SYS_NERR)

+		AC_CACHE_CHECK(for sys_nerr declaration,

+		ac_cv_decl_sys_nerr,

+		[

+		AC_TRY_COMPILE([

+		#include <stdio.h>

+		#ifdef HAVE_STDLIB_H

+		#include <stdlib.h>

+		#endif

+		#ifdef HAVE_UNISTD_H

+		#include <unistd.h>

+		#endif],[return(sys_nerr);],

+		ac_cv_decl_sys_nerr_def=yes, ac_cv_decl_sys_nerr_def=no)

+		])

+		if test "$ac_cv_decl_sys_nerr" = yes; then

+			AC_DEFINE(HAVE_DECL_SYS_NERR)

+		fi

+	fi

+

+

+	AC_CACHE_CHECK(for sys_errlist array,

+	ac_cv_sys_errlist,

+	[AC_TRY_LINK(,[extern char *sys_errlist[];

+		sys_errlist[0];],

+		ac_cv_sys_errlist=yes, ac_cv_sys_errlist=no)

+	])

+	if test "$ac_cv_sys_errlist" = yes; then

+		AC_DEFINE(HAVE_SYS_ERRLIST)

+		AC_CACHE_CHECK(for sys_errlist declaration,

+		ac_cv_sys_errlist_def,

+		[AC_TRY_COMPILE([

+		#include <stdio.h>

+		#include <errno.h>

+		#ifdef HAVE_STDLIB_H

+		#include <stdlib.h>

+		#endif

+		#ifdef HAVE_UNISTD_H

+		#include <unistd.h>

+		#endif],[char *s = sys_errlist[0]; return(*s);],

+		ac_cv_decl_sys_errlist=yes, ac_cv_decl_sys_errlist=no)

+		])

+		if test "$ac_cv_decl_sys_errlist" = yes; then

+			AC_DEFINE(HAVE_DECL_SYS_ERRLIST)

+		fi

+	fi

+

+

+

+	AC_CACHE_CHECK(checking for long long,

+	ac_cv_long_long,

+	[

+	AC_TRY_COMPILE([

+	#include <stdio.h>

+	#include <sys/types.h>

+	], [printf("%d",sizeof(long long));],

+	ac_cv_long_long=yes, ac_cv_long_long=no)

+	])

+	if test $ac_cv_long_long = yes; then

+	  AC_DEFINE(HAVE_LONG_LONG)

+	fi

+

+	AC_CACHE_CHECK(checking for long double,

+	ac_cv_long_double,

+	[

+	AC_TRY_COMPILE([

+	#include <stdio.h>

+	#include <sys/types.h>

+	], [printf("%d",sizeof(long double));],

+	ac_cv_long_double=yes, ac_cv_long_double=no)

+	])

+	if test $ac_cv_long_double = yes; then

+	  AC_DEFINE(HAVE_LONG_DOUBLE)

+	fi

+

+	AC_CACHE_CHECK(checking for quad_t,

+	ac_cv_quad_t,

+	[

+	AC_TRY_COMPILE([

+	#include <stdio.h>

+	#include <sys/types.h>

+	], [printf("%d",sizeof(quad_t));],

+	ac_cv_quad_t=yes, ac_cv_quad_t=no)

+	])

+	if test $ac_cv_quad_t = yes; then

+	  AC_DEFINE(HAVE_QUAD_T)

+	fi

+

+

+

+ NAME

+     snprintf, plp_vsnprintf - formatted output conversion

+

+ SYNOPSIS

+     #include <stdio.h>

+     #include <stdarg.h>

+

+     int

+     snprintf(const char *format, size_t size, va_list ap);

+     int

+     plp_unsafe_snprintf(const char *format, size_t size, va_list ap);

+

+     AKA snprintf and unsafe_snprintf in the documentation below

+

+     int

+     vsnprintf(char *str, size_t size, const char *format, va_list ap);

+     int

+     unsafe_vsnprintf(char *str, size_t size, const char *format, va_list ap);

+

+     AKA vsnprintf and unsafe_vsnprintf in the documentation below

+

+     (Multithreaded Safe)

+

+ DESCRIPTION

+     The printf() family of functions produces output according to

+     a format as described below.  Snprintf(), and vsnprintf()

+     write to the character string str. These functions write the

+     output under the control of a format string that specifies

+     how subsequent arguments (or arguments accessed via the

+     variable-length argument facilities of stdarg(3))  are converted

+     for output.  These functions return the number of characters

+     printed (not including the trailing `\0' used to end output

+     to strings).  Snprintf() and vsnprintf() will write at most

+     size-1 of the characters printed into the output string (the

+     size'th character then gets the terminating `\0'); if the

+     return value is greater than or equal to the size argument,

+     the string was too short and some of the printed characters

+     were discarded.  The size or str may be given as zero to find

+     out how many characters are needed; in this case, the str

+     argument is ignored.

+

+     By default, the snprintf function will not format control

+     characters (except new line and tab) in strings.  This is a

+     safety feature that has proven to be extremely critical when

+     using snprintf for secure applications and when debugging.

+     If you MUST have control characters formatted or printed,

+     then use the unsafe_snprintf() and unsafe_vsnprintf() and on

+     your own head be the consequences.  You have been warned.

+

+     There is one exception to the comments above, and that is

+     the "%c" (character) format.  It brutally assumes that the

+     user will have performed the necessary 'isprint()' or other

+     checks and uses the integer value as a character.

+

+     The format string is composed of zero or more directives:

+     ordinary characters (not %), which are copied unchanged to

+     the output stream; and conversion specifications, each

+     of which results in fetching zero or more subsequent arguments.

+     Each conversion specification is introduced by the character

+     %. The arguments must correspond properly (after type promotion)

+     with the conversion specifier.  After the %, the following

+     appear in sequence:

+

+     o   Zero or more of the following flags:

+

+	   -   A zero `0' character specifying zero padding.  For

+	     all conversions except n, the converted value is padded

+	     on the left with zeros rather than blanks.  If a

+	     precision is given with a numeric conversion (d, i,

+	     o, u, i, x, and X), the `0' flag is ignored.

+

+       -   A negative field width flag `-' indicates the converted

+	     value is to be left adjusted on the field boundary.  Except

+	     for n conversions, the converted value is padded on

+	     the right with blanks, rather than on the left with

+	     blanks or zeros.  A `-' overrides a `0' if both are

+	     given.

+

+	   -   A space, specifying that a blank should be left before

+	     a positive number produced by a signed conversion (d, e, E, f,

+	     g, G, or i).

+

+	   -   A `+' character specifying that a sign always be placed

+	     before a number produced by a signed conversion.  A `+' overrides

+	     a space if both are used.

+

+     o   An optional decimal digit string specifying a minimum

+		 field width.  If the converted value has fewer

+		 characters than the field width, it will be padded

+		 with spaces on the left (or right, if the

+		 left-adjustment flag has been given) to fill out

+		 the field width.

+

+     o   An optional precision, in the form of a period `.' followed

+		 by an optional digit string.  If the digit string

+		 is omitted, the precision is taken as zero.  This

+		 gives the minimum number of digits to appear for

+		 d, i, o, u, x, and X conversions, the number of

+		 digits to appear after the decimal-point for e,

+		 E, and f conversions, the maximum number of

+		 significant digits for g and G conversions, or

+		 the maximum number of characters to be printed

+		 from a string for s conversions.

+

+     o   The optional character h, specifying that a following d,

+		 i, o, u, x, or X conversion corresponds to a short

+		 int or unsigned short int argument, or that a

+		 following n conversion corresponds to a pointer

+		 to a short int argument.

+

+     o   The optional character l (ell) specifying that a following

+		 d, i, o, u, x, or X conversion applies to a pointer

+		 to a long int or unsigned long int argument, or

+		 that a following n conversion corresponds to a

+		 pointer to a long int argument.

+

+     o   The optional character q, specifying that a following d,

+		 i, o, u, x, or X conversion corresponds to a quad_t

+		 or u_quad_t argument, or that a following n

+		 conversion corresponds to a quad_t argument.

+         This value is always printed in HEX notation.  Tough.

+         quad_t's are an OS system implementation, and should

+         not be allowed.

+

+     o   The character L specifying that a following e, E, f, g,

+		 or G conversion corresponds to a long double

+		 argument.

+

+     o   A character that specifies the type of conversion to be applied.

+

+

+     A field width or precision, or both, may be indicated by an asterisk `*'

+     instead of a digit string.  In this case, an int argument supplies the

+     field width or precision.  A negative field width is treated as a left

+     adjustment flag followed by a positive field width; a negative precision

+     is treated as though it were missing.

+

+     The conversion specifiers and their meanings are:

+

+     diouxX  The int (or appropriate variant) argument is converted to signed

+			 decimal (d and i), unsigned octal (o), unsigned decimal

+			 (u), or unsigned hexadecimal (x and X) notation.  The

+			 letters abcdef are used for x conversions; the letters

+			 ABCDEF are used for X conversions.  The precision, if

+			 any, gives the minimum number of digits that must

+			 appear; if the converted value requires fewer digits,

+			 it is padded on the left with zeros.

+

+     eE      The double argument is rounded and converted in the style

+             [-]d.ddde+-dd where there is one digit before the decimal-point

+			 character and the number of digits after it is equal

+			 to the precision; if the precision is missing, it is

+			 taken as 6; if the precision is zero, no decimal-point

+			 character appears.  An E conversion uses the letter

+			 E (rather than e) to introduce the exponent.

+			 The exponent always contains at least two digits; if

+			 the value is zero, the exponent is 00.

+

+     f       The double argument is rounded and converted to decimal notation

+             in the style [-]ddd.ddd, where the number of digits after the

+             decimal-point character is equal to the precision specification.

+             If the precision is missing, it is taken as 6; if the precision

+             is explicitly zero, no decimal-point character appears.  If a

+             decimal point appears, at least one digit appears before it.

+

+     g       The double argument is converted in style f or e (or

+			 E for G conversions).  The precision specifies the

+			 number of significant digits.  If the precision is

+			 missing, 6 digits are given; if the precision is zero,

+			 it is treated as 1.  Style e is used if the exponent

+			 from its conversion is less than -4 or greater than

+			 or equal to the precision.  Trailing zeros are removed

+			 from the fractional part of the result; a decimal

+			 point appears only if it is followed by at least one

+			 digit.

+

+     c       The int argument is converted to an unsigned char,

+             and the resulting character is written.

+

+     s       The ``char *'' argument is expected to be a pointer to an array

+			 of character type (pointer to a string).  Characters

+			 from the array are written up to (but not including)

+			 a terminating NUL character; if a precision is

+			 specified, no more than the number specified are

+			 written.  If a precision is given, no null character

+			 need be present; if the precision is not specified,

+			 or is greater than the size of the array, the array

+			 must contain a terminating NUL character.

+

+     %       A `%' is written. No argument is converted. The complete

+             conversion specification is `%%'.

+

+     In no case does a non-existent or small field width cause truncation of a

+     field; if the result of a conversion is wider than the field width, the

+     field is expanded to contain the conversion result.

+

+ EXAMPLES

+     To print a date and time in the form `Sunday, July 3, 10:02', where

+     weekday and month are pointers to strings:

+

+           #include <stdio.h>

+           fprintf(stdout, "%s, %s %d, %.2d:%.2d\n",

+                   weekday, month, day, hour, min);

+

+     To print pi to five decimal places:

+

+           #include <math.h>

+           #include <stdio.h>

+           fprintf(stdout, "pi = %.5f\n", 4 * atan(1.0));

+

+     To allocate a 128 byte string and print into it:

+

+           #include <stdio.h>

+           #include <stdlib.h>

+           #include <stdarg.h>

+           char *newfmt(const char *fmt, ...)

+           {

+               char *p;

+               va_list ap;

+               if ((p = malloc(128)) == NULL)

+                       return (NULL);

+               va_start(ap, fmt);

+               (void) vsnprintf(p, 128, fmt, ap);

+               va_end(ap);

+               return (p);

+           }

+

+ SEE ALSO

+     printf(1),  scanf(3)

+

+ STANDARDS

+     Turkey C Standardization and wimpy POSIX folks did not define

+     snprintf or vsnprintf().

+

+ BUGS

+     The conversion formats %D, %O, and %U are not standard and are provided

+     only for backward compatibility.  The effect of padding the %p format

+     with zeros (either by the `0' flag or by specifying a precision), and the

+     benign effect (i.e., none) of the `#' flag on %n and %p conversions, as

+     well as other nonsensical combinations such as %Ld, are not standard;

+     such combinations should be avoided.

-    b) accompany the distribution with the machine-readable source of

-    the Package with your modifications.

+     The typedef names quad_t and u_quad_t are infelicitous.

-    c) give non-standard executables non-standard names, and clearly

-    document the differences in manual pages (or equivalent), together

-    with instructions on where to get the Standard Version.

+*/

-    d) make other distribution arrangements with the Copyright Holder.

-5. You may charge a reasonable copying fee for any distribution of this

-Package.  You may charge any fee you choose for support of this

-Package.  You may not charge a fee for this Package itself.  However,

-you may distribute this Package in aggregate with other (possibly

-commercial) programs as part of a larger (possibly commercial) software

-distribution provided that you do not advertise this Package as a

-product of your own. 

+#include <sys/types.h>

+#include <ctype.h>

+#include <stdlib.h>

+#include <stdio.h>

+#if defined(HAVE_STRING_H)

+# include <string.h>

+#endif

+#if defined(HAVE_STRINGS_H)

+# include <strings.h>

+#endif

+#if defined(HAVE_ERRNO_H)

+#include <errno.h>

+#endif

-6. The name of the Copyright Holder may not be used to endorse or promote

-products derived from this software without specific prior written permission.

+/*

+ * For testing, define these values

+ */

+#if 0

+#define HAVE_STDARG_H 1

+#define TEST 1

+#define HAVE_QUAD_T 1

+#endif

-7. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR

-IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED

-WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.

+/**** ENDINCLUDE ****/

-				The End

-#include "lp.h"

+/*************************************************

+ * KEEP THIS STRING - MODIFY AT THE END WITH YOUR REVISIONS

+ * i.e. - the LOCAL REVISIONS part is for your use

+ *************************************************/

+ 

+ 

+ static char *const _id = "plp_snprintf V2000.08.18 Copyright Patrick Powell 1988-2000 "

+ "$Id: plp_snprintf.c,v 1.4 2005/04/14 20:05:19 papowell Exp $"

+ " LOCAL REVISIONS: renamed plp_snprintf to snprintf, conditionalized everything on HAVE_SNPRINTF";

+

+/* varargs declarations: */

+

+# undef HAVE_STDARGS    /* let's hope that works everywhere (mj) */

+# undef VA_LOCAL_DECL

+# undef VA_START

+# undef VA_SHIFT

+# undef VA_END

+

+#if defined(HAVE_STDARG_H)

+# include <stdarg.h>

+# define HAVE_STDARGS    /* let's hope that works everywhere (mj) */

+# define VA_LOCAL_DECL   va_list ap;

+# define VA_START(f)     va_start(ap, f)

+# define VA_SHIFT(v,t)	;	/* no-op for ANSI */

+# define VA_END          va_end(ap)

+#else

+# if defined(HAVE_VARARGS_H)

+#  include <varargs.h>

+#  undef HAVE_STDARGS

+#  define VA_LOCAL_DECL   va_list ap;

+#  define VA_START(f)     va_start(ap)		/* f is ignored! */

+#  define VA_SHIFT(v,t)	v = va_arg(ap,t)

+#  define VA_END		va_end(ap)

+# else

+ XX ** NO VARARGS ** XX

+# endif

 #endif

-#include <stdarg.h>

-#include <errno.h>

-#include <sys/types.h>

-#define HAVE_STDARGS /* let's hope that works everywhere (mj) */

-#define VA_LOCAL_DECL va_list ap;

-#define VA_START(f) va_start(ap, f)

-#define VA_SHIFT(v,t) ; /* no-op for ANSI */

-#define VA_END va_end(ap)

-

-/**** ENDINCLUDE ****/

+ union value {

+#if defined(HAVE_QUAD_T)

+	quad_t qvalue;

+#endif

+#if defined(HAVE_LONG_LONG)

+	long long value;

+#else

+	long value;

+#endif

+	double dvalue;

+};

-static char *const _id = "$Id: snprintf.c,v 1.2 2001/08/03 21:32:56 hmg Exp $";

+#undef CVAL 

+#define CVAL(s) (*((unsigned char *)s))

+#define safestrlen(s) ((s)?strlen(s):0)

-/*

- * dopr(): poor man's version of doprintf

- */

-static char * plp_Errormsg ( int err );

-static void dopr( char *buffer, const char *format, va_list args );

-static void fmtstr(  char *value, int ljust, int len, int zpad, int precision );

-static void fmtnum(  long value, int base, int dosign,

+ static char * plp_Errormsg ( int err, char *buffer );

+ static void dopr( int visible_control, char **buffer, int *left,

+	const char *format, va_list args );

+ static void fmtstr( int visible_control, char **buffer, int *left,

+	char *value, int ljust, int len, int zpad, int precision );

+ static void fmtnum(  char **buffer, int *left,

+	union value *value, int base, int dosign,

+	int ljust, int len, int zpad, int precision );

+#if defined(HAVE_QUAD_T)

+ static void fmtquad(  char **buffer, int *left,

+	union value *value, int base, int dosign,

 	int ljust, int len, int zpad, int precision );

-static void fmtdouble( int fmt, double value,

+#endif

+ static void fmtdouble( char **bufer, int *left,

+	int fmt, double value,

 	int ljust, int len, int zpad, int precision );

-static void dostr( char * );

-static char *output;

-static void dopr_outch( int c );

-static char *end;

-int visible_control = 1;

-

-/**************************************************************

- * Original:

- * Patrick Powell Tue Apr 11 09:48:21 PDT 1995

- * A bombproof version of doprnt (dopr) included.

- * Sigh.  This sort of thing is always nasty do deal with.  Note that

- * the version here does not include floating point...

- *

- * plp_snprintf() is used instead of sprintf() as it does limit checks

- * for string length.  This covers a nasty loophole.

- *

- * The other functions are there to prevent NULL pointers from

- * causing nast effects.

- **************************************************************/

-

-int vsnprintf(char *str, size_t count, const char *fmt, va_list args)

-{

-	str[0] = 0;

-	end = str+count-1;

-	dopr( str, fmt, args );

-	if( count>0 ){

-		end[0] = 0;

+ static void dostr(  char **buffer, int *left, char *str );

+ static void dopr_outch(  char **buffer, int *left, int c );

+/* VARARGS3 */

+#ifdef HAVE_STDARGS

+ int plp_vsnprintf(char *str, size_t count, const char *fmt, va_list args)

+#else

+ int plp_vsnprintf(char *str, size_t count, const char *fmt, va_list args)

+#endif

+

+{

+	int left;

+	char *buffer;