trunk: changeset 38

Sat, 19 Jan 2002 19:14:36 +0100

author
tuomov
date
Sat, 19 Jan 2002 19:14:36 +0100
changeset 35
5a71d53d0228
parent 34
828f3afd5c76
child 36
63cd573ffbcf

trunk: changeset 38
Warning callbacks (thanks to Lukas Schroeder). libtu now depends on
the asprintf functions and one implementation is included in
snprintf_2.2/.

Makefile file | annotate | diff | comparison | revisions
README file | annotate | diff | comparison | revisions
include/libtu/optparser.h file | annotate | diff | comparison | revisions
include/libtu/output.h file | annotate | diff | comparison | revisions
include/libtu/parser.h file | annotate | diff | comparison | revisions
include/libtu/tokenizer.h file | annotate | diff | comparison | revisions
output.c file | annotate | diff | comparison | revisions
parser.c file | annotate | diff | comparison | revisions
snprintf_2.2/INSTALL file | annotate | diff | comparison | revisions
snprintf_2.2/LICENSE.txt file | annotate | diff | comparison | revisions
snprintf_2.2/Makefile.unused file | annotate | diff | comparison | revisions
snprintf_2.2/README file | annotate | diff | comparison | revisions
snprintf_2.2/README.html file | annotate | diff | comparison | revisions
snprintf_2.2/snprintf-orig.c file | annotate | diff | comparison | revisions
snprintf_2.2/snprintf.c file | annotate | diff | comparison | revisions
snprintf_2.2/snprintf.h file | annotate | diff | comparison | revisions
snprintf_2.2/test.c file | annotate | diff | comparison | revisions
tokenizer.c file | annotate | diff | comparison | revisions
--- a/Makefile	Sun Apr 01 01:43:46 2001 +0200
+++ b/Makefile	Sat Jan 19 19:14:36 2002 +0100
@@ -16,7 +16,7 @@
 DEFINES += -DLIBTU_NO_ERRMSG
 else
 ifndef HAS_SYSTEM_ASPRINTF
-OBJS += ../snprintf_2.2/snprintf.o
+OBJS += snprintf_2.2/snprintf.o
 else
 DEFINES += -DHAS_SYSTEM_ASPRINTF
 endif
--- a/README	Sun Apr 01 01:43:46 2001 +0200
+++ b/README	Sat Jan 19 19:14:36 2002 +0100
@@ -24,8 +24,8 @@
 ---
 
 Libtu needs the functions asprintf and vasprintf. These do not
-exist on most platforms. One implementation is available at
-<http://www.ijs.si/software/snprintf/>, which is used by default
-and is supposed to be found at ../snprintf_2.2. To use the
-system's versions, if available, modify system.mk.
+exist on most platforms. One implementation by Mark Martinec
+is included in snprintf_2.2/ and is used by default. To use the
+system's versions of these functions, if available, modify
+system.mk.
 
--- a/include/libtu/optparser.h	Sun Apr 01 01:43:46 2001 +0200
+++ b/include/libtu/optparser.h	Sat Jan 19 19:14:36 2002 +0100
@@ -57,7 +57,6 @@
 	const char *about;
 } OptParserCommonInfo;
 
-#define END_OPTPARSEROPTS {0, NULL, 0, NULL, NULL}
 
 enum{
 	OPT_ID_END=0,
--- a/include/libtu/output.h	Sun Apr 01 01:43:46 2001 +0200
+++ b/include/libtu/output.h	Sat Jan 19 19:14:36 2002 +0100
@@ -12,6 +12,8 @@
 
 #include "types.h"
 
+typedef void WarnHandler(const char *);
+extern WarnHandler *set_warn_handler(WarnHandler *handler);
 
 extern void verbose(const char *p, ...);
 extern void verbose_v(const char *p, va_list args);
--- a/include/libtu/parser.h	Sun Apr 01 01:43:46 2001 +0200
+++ b/include/libtu/parser.h	Sat Jan 19 19:14:36 2002 +0100
@@ -35,7 +35,6 @@
 	struct _ConfOpt *opts;
 } ConfOpt;
 
-#define END_CONFOPTS {NULL, NULL, NULL, NULL}
 
 extern bool parse_config_tokz(Tokenizer *tokz, const ConfOpt *options);
 extern bool parse_config(const char *fname, const ConfOpt *options, int flags);
--- a/include/libtu/tokenizer.h	Sun Apr 01 01:43:46 2001 +0200
+++ b/include/libtu/tokenizer.h	Sat Jan 19 19:14:36 2002 +0100
@@ -123,7 +123,9 @@
 	TOKZ_IGNORE_NEXTLINE=0x1,
 	TOKZ_READ_COMMENTS=0x2,
 	TOKZ_PARSER_INDENT_MODE=0x04,
-	TOKZ_ERROR_TOLERANT=0x8
+	TOKZ_ERROR_TOLERANT=0x8,
+	TOKZ_READ_FROM_BUFFER=0x10,
+	TOKZ_DEFAULT_OPTION=0x20
 };
 
 
@@ -163,6 +165,12 @@
 	Token ungettok;
 } Tokenizer_FInfo;
 
+typedef struct _Tokenizer_Buffer{
+		char *data;
+		int len;
+		int pos;
+} Tokenizer_Buffer;
+	
 typedef struct _Tokenizer{
 	FILE *file;
 	char *name;
@@ -170,6 +178,8 @@
 	int ungetc;
 	Token ungettok;
 	
+	Tokenizer_Buffer buffer;
+
 	int flags;
 	const struct _ConfOpt **optstack;
 	int nest_lvl;
@@ -184,6 +194,7 @@
 
 extern Tokenizer *tokz_open(const char *fname);
 extern Tokenizer *tokz_open_file(FILE *file, const char *fname);
+extern Tokenizer *tokz_prepare_buffer(char *buffer, int len);
 extern void tokz_close(Tokenizer *tokz);
 extern bool tokz_get_token(Tokenizer *tokz, Token *tok);
 extern void tokz_unget_token(Tokenizer *tokz, Token *tok);
--- a/output.c	Sun Apr 01 01:43:46 2001 +0200
+++ b/output.c	Sat Jan 19 19:14:36 2002 +0100
@@ -15,7 +15,7 @@
 #include <libtu/output.h>
 #include <libtu/util.h>
 
-#if !defined(LIBTU_NO_ERRMSG) && !defined(HAS_SYSTEM_ASPRINTF)
+#if !defined(HAS_SYSTEM_ASPRINTF)
 #include "../snprintf_2.2/snprintf.h"
 #endif
 
@@ -26,11 +26,14 @@
 static bool verbose_mode=FALSE;
 static int verbose_indent_lvl=0;
 static bool progname_enable=TRUE;
+static WarnHandler *current_warn_handler=NULL;
 
 #define INDENTATOR_LENGTH 4
 
 static char indentator[]={' ', ' ', ' ', ' '};
 
+static void do_dispatch_message(const char *message);
+
 
 void verbose(const char *p, ...)
 {
@@ -99,11 +102,29 @@
 /* warn
  */
 
+
+static void fallback_warn()
+{
+	put_prog_name();
+	fprintf(stderr, "Oops. Error string compilation failed: %s",
+			strerror(errno));
+}
+	
+	
 #define CALL_V(NAME, ARGS) \
-	va_list args; va_start(args, p); NAME ARGS; va_end(args);
+	do { va_list args; va_start(args, p); NAME ARGS; va_end(args); } while(0)
 
+#define DO_DISPATCH(NAME, ARGS) \
+	do{ \
+		char *msg; \
+		if((msg=NAME ARGS)!=NULL){ \
+			do_dispatch_message(msg); \
+			free(msg);\
+		}else{ \
+			fallback_warn(); \
+		} \
+	}while(0)
 
-#ifndef LIBTU_NO_ERRMSG
 
 void libtu_asprintf(char **ret, const char *p, ...)
 {
@@ -116,7 +137,6 @@
 	vasprintf(ret, p, args);
 }
 
-#endif
 
 void warn(const char *p, ...)
 {
@@ -144,69 +164,39 @@
 
 void warn_v(const char *p, va_list args)
 {
-	put_prog_name();
-	vfprintf(stderr, p, args);
-	putc('\n', stderr);
+	DO_DISPATCH(errmsg_v, (p, args));
 }
 
 
 void warn_obj_line_v(const char *obj, int line, const char *p, va_list args)
 {
-	put_prog_name();
-	if(obj!=NULL){
-		if(line>0)
-			fprintf(stderr, TR("%s:%d: "), obj, line);
-		else		
-			fprintf(stderr, "%s: ", obj);
-	}else{
-		if(line>0)
-			fprintf(stderr, TR("%d: "), line);
-	}
-	vfprintf(stderr, p, args);
-	putc('\n', stderr);
+	DO_DISPATCH(errmsg_obj_line_v, (obj, line, p, args));
 }
 
 
 void warn_err()
 {
-	put_prog_name();
-	fprintf(stderr, "%s\n", strerror(errno));
+	DO_DISPATCH(errmsg_err, ());
 }
 
 
 void warn_err_obj(const char *obj)
 {
-	put_prog_name();
-	if(obj!=NULL)
-		fprintf(stderr, "%s: %s\n", obj, strerror(errno));
-	else
-		fprintf(stderr, "%s\n", strerror(errno));
+	DO_DISPATCH(errmsg_err_obj, (obj));
 }
 
 void warn_err_obj_line(const char *obj, int line)
 {
-	put_prog_name();
-	if(obj!=NULL){
-		if(line>0)
-			fprintf(stderr, TR("%s:%d: %s\n"), obj, line, strerror(errno));
-		else
-			fprintf(stderr, "%s: %s\n", obj, strerror(errno));
-	}else{
-		if(line>0)
-			fprintf(stderr, TR("%d: %s\n"), line, strerror(errno));
-		else
-			fprintf(stderr, TR("%s\n"), strerror(errno));
-	}
-
+	DO_DISPATCH(errmsg_err_obj_line, (obj, line));
 }
 
 
 /* errmsg
  */
-#ifndef LIBTU_NO_ERRMSG
 
 #define CALL_V_RET(NAME, ARGS) \
-	char *ret; va_list args; va_start(args, p); ret=NAME ARGS; va_end(args); return ret;
+	char *ret; va_list args; va_start(args, p); ret=NAME ARGS; \
+	va_end(args); return ret;
 
 
 char* errmsg(const char *p, ...)
@@ -244,6 +234,7 @@
 char *errmsg_obj_line_v(const char *obj, int line, const char *p, va_list args)
 {
 	char *res1=NULL, *res2, *res3;
+	
 	if(obj!=NULL){
 		if(line>0)
 			asprintf(&res1, TR("%s:%d: "), obj, line);
@@ -253,7 +244,7 @@
 		if(line>0)
 			asprintf(&res1, TR("%d: "), line);
 	}
-	asprintf(&res2, p, args);
+	vasprintf(&res2, p, args);
 	if(res1!=NULL){
 		if(res2==NULL)
 			return NULL;
@@ -302,20 +293,21 @@
 	return res;
 }
 
-#endif /* LIBTU_NO_ERRMSG */
-
 
 /* die
  */
 
+
 void die(const char *p, ...)
 {
+	set_warn_handler(NULL);
 	CALL_V(die_v, (p, args));
 }
 
 
 void die_v(const char *p, va_list args)
 {
+	set_warn_handler(NULL);
 	warn_v(p, args);
 	exit(EXIT_FAILURE);
 }
@@ -323,18 +315,21 @@
 
 void die_obj(const char *obj, const char *p, ...)
 {
+	set_warn_handler(NULL);
 	CALL_V(die_obj_v, (obj, p, args));
 }
 
 
 void die_obj_line(const char *obj, int line, const char *p, ...)
 {
+	set_warn_handler(NULL);
 	CALL_V(die_obj_line_v, (obj, line, p, args));
 }
 
 
 void die_obj_v(const char *obj, const char *p, va_list args)
 {
+	set_warn_handler(NULL);
 	warn_obj_v(obj, p, args);
 	exit(EXIT_FAILURE);
 }
@@ -342,6 +337,7 @@
 
 void die_obj_line_v(const char *obj, int line, const char *p, va_list args)
 {
+	set_warn_handler(NULL);
 	warn_obj_line_v(obj, line, p, args);
 	exit(EXIT_FAILURE);
 }
@@ -349,6 +345,7 @@
 
 void die_err()
 {
+	set_warn_handler(NULL);
 	warn_err();
 	exit(EXIT_FAILURE);
 }
@@ -356,6 +353,7 @@
 
 void die_err_obj(const char *obj)
 {
+	set_warn_handler(NULL);
 	warn_err_obj(obj);
 	exit(EXIT_FAILURE);
 }
@@ -363,6 +361,32 @@
 
 void die_err_obj_line(const char *obj, int line)
 {
+	set_warn_handler(NULL);
 	warn_err_obj_line(obj, line);
 	exit(EXIT_FAILURE);
 }
+
+
+static void default_warn_handler(const char *message)
+{
+	put_prog_name();
+	fprintf(stderr, "%s", message);
+	putc('\n', stderr);
+}
+
+
+static void do_dispatch_message(const char *message)
+{
+	if(current_warn_handler!=NULL)
+		current_warn_handler(message);
+	else
+		default_warn_handler(message);
+}
+
+
+WarnHandler *set_warn_handler(WarnHandler *handler)
+{
+	WarnHandler *old=current_warn_handler;
+	current_warn_handler=handler;
+	return old;
+}
--- a/parser.c	Sun Apr 01 01:43:46 2001 +0200
+++ b/parser.c	Sat Jan 19 19:14:36 2002 +0100
@@ -216,6 +216,7 @@
 	int init_nest_lvl;
 	bool had_error;
 	int errornest=0;
+	bool is_default=FALSE;
 
 	/* Allocate tokz->optstack if it does not yet exist (if it does,
 	 * we have been called from an option handler)
@@ -283,11 +284,15 @@
 								  TOK_IDENT_VAL(tokens+0));
 			if(options==NULL)
 				options=lookup_option(common_opts, TOK_IDENT_VAL(tokens+0));
+			if(options==NULL && (tokz->flags&TOKZ_DEFAULT_OPTION)){
+				options=lookup_option(tokz->optstack[tokz->nest_lvl], "#default");
+				is_default=(options!=NULL);
+			}
 
 			if(options==NULL){
 				had_error=TRUE;
 				tokz_warn_error(tokz, tokens->line, E_TOKZ_UNKNOWN_OPTION);
-			}else{			
+			}else if(!is_default) {			
 				had_error=!check_args(tokz, tokens, ntokens, options->argfmt);
 			}
 			
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/snprintf_2.2/INSTALL	Sat Jan 19 19:14:36 2002 +0100
@@ -0,0 +1,24 @@
+HOW TO INSTALL - manually:
+
+  1. Read the description of macros that control the bahaviour
+     of the program at the beginning of the file snprintf.c,
+     change the definitions in snprintf.c or in Makefile if necessary.
+
+  2. make
+
+  3. move the file snprintf.o where your programs will find it
+
+
+
+HOW TO INSTALL - with autoconf:
+
+Contributed by Caolan McNamara <Caolan.McNamara@ul.ie>:
+
+  Though it might be overkill for snprintf I also have
+  an autoconf and automaked version which works out the need
+  for long long support and makes snprintf optionally into
+  a dynamic library on libtool supported platforms.
+
+  1. cd with_autoconf
+
+  2. follow instructions in the file INSTALL there.
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/snprintf_2.2/LICENSE.txt	Sat Jan 19 19:14:36 2002 +0100
@@ -0,0 +1,121 @@
+The Frontier Artistic License Version 1.0
+Derived from the Artistic License at OpenSource.org.
+Submitted to OpenSource.org for Open Source Initiative certification.
+   
+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 script, suite, file, or collection of
+  scripts, suites, and/or files distributed by the Copyright Holder,
+  and to derivatives of that Package 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.
+
+  "Copyright Holder" is whoever is named in the copyright statement
+  or statements for the package.
+
+  "You" is you, if you're 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.
+       
+
+Terms
+
+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 script,
+suite, or file stating how and when you changed that script, suite,
+or file, and provided that you do at least ONE of the following:
+   
+  a) Use the modified Package only within your corporation or
+  organization, or retain the modified Package solely for personal use.
+     
+  b) 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 ftp.uu.net, or by allowing the Copyright Holder to include
+  your modifications in the Standard Version of the Package.
+     
+  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 (or equivalent) 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:
+   
+  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.
+     
+  b) Accompany the distribution with the machine-readable source of
+  the Package with your modifications.
+     
+  c) Accompany any non-standard executables with their corresponding
+  Standard Version executables, give the 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.
+   
+6. The scripts and library files supplied as input to or produced as
+output from the programs of this Package do not automatically fall
+under the copyright of this Package, but belong to whomever generated
+them, and may be sold commercially, and may be aggregated with this
+Package.
+   
+7. Scripts, suites, or programs supplied by you that depend on or
+otherwise make use of this Package shall not be considered part of
+this Package.
+   
+8. The name of the Copyright Holder may not be used to endorse or
+promote products derived from this software without specific prior
+written permission.
+   
+9. 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.
+   
+                        The End
+
+
+http://www.spinwardstars.com/frontier/fal.html
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/snprintf_2.2/Makefile.unused	Sat Jan 19 19:14:36 2002 +0100
@@ -0,0 +1,43 @@
+# Make sure you include -DHAVE_SNPRINTF in CFLAGS if your system
+# does have snprintf!
+
+# If you need (long long int) support and you sprintf supports it,
+# define -DSNPRINTF_LONGLONG_SUPPORT
+
+CC      = gcc
+
+CFLAGS  = -DPREFER_PORTABLE_SNPRINTF -O3 \
+	  -Wall -Wpointer-arith -Wwrite-strings \
+	  -Wcast-qual -Wcast-align -Waggregate-return \
+	  -Wmissing-prototypes -Wmissing-declarations \
+	  -Wshadow -Wstrict-prototypes
+
+#	  -DNEED_ASPRINTF -DNEED_ASNPRINTF -DNEED_VASPRINTF -DNEED_VASNPRINTF
+#	  -DNEED_SNPRINTF_ONLY
+
+# Digital Unix: native compiler usually produces better code than gcc
+#CC     = cc
+#CFLAGS = -DPREFER_PORTABLE_SNPRINTF -O4 -std1 -arch host
+
+# Recommend to leave COMPATIBILITY empty for normal use.
+# Should be set for bug compatibility when running tests
+# too keep them less chatty.
+COMPATIBILITY =
+
+#COMPATIBILITY = -DSOLARIS_BUG_COMPATIBLE
+#COMPATIBILITY = -DHPUX_BUG_COMPATIBLE
+#COMPATIBILITY = -DDIGITAL_UNIX_BUG_COMPATIBLE
+#COMPATIBILITY = -DPERL_BUG_COMPATIBLE
+#COMPATIBILITY = -DLINUX_COMPATIBLE
+
+.c.o:
+	rm -f $@
+	$(CC) $(CFLAGS) $(COMPATIBILITY) -c $*.c
+
+all:snprintf.o Makefile
+
+test::snprintf.o test.c Makefile
+	$(CC) $(CFLAGS) $(COMPATIBILITY) snprintf.o -o $@ test.c
+
+clean:
+	/usr/bin/rm -f *.o test core
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/snprintf_2.2/README	Sat Jan 19 19:14:36 2002 +0100
@@ -0,0 +1,283 @@
+
+                                  snprintf.c
+                   - a portable implementation of snprintf,
+       including vsnprintf.c, asnprintf, vasnprintf, asprintf, vasprintf
+                                       
+   snprintf is a routine to convert numeric and string arguments to
+   formatted strings. It is similar to sprintf(3) provided in a system's
+   C library, yet it requires an additional argument - the buffer size -
+   and it guarantees never to store anything beyond the given buffer,
+   regardless of the format or arguments to be formatted. Some newer
+   operating systems do provide snprintf in their C library, but many do
+   not or do provide an inadequate (slow or idiosyncratic) version, which
+   calls for a portable implementation of this routine.
+   
+Author
+
+   Mark Martinec <mark.martinec@ijs.si>, April 1999, June 2000
+   Copyright © 1999, Mark Martinec
+   
+Terms and conditions ...
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the Frontier Artistic License which comes with
+   this Kit.
+   
+Features
+
+     * careful adherence to specs regarding flags, field width and
+       precision;
+     * good performance for large string handling (large format, large
+       argument or large paddings). Performance is similar to system's
+       sprintf and in several cases significantly better (make sure you
+       compile with optimizations turned on, tell the compiler the code
+       is strict ANSI if necessary to give it more freedom for
+       optimizations);
+     * return value semantics per ISO/IEC 9899:1999 ("ISO C99");
+     * written in standard ISO/ANSI C - requires an ANSI C compiler.
+       
+Supported conversion specifiers and data types
+
+   This snprintf only supports the following conversion specifiers: s, c,
+   d, o, u, x, X, p (and synonyms: i, D, U, O - see below) with flags:
+   '-', '+', ' ', '0' and '#'. An asterisk is supported for field width
+   as well as precision.
+   
+   Length modifiers 'h' (short int), 'l' (long int), and 'll' (long long
+   int) are supported.
+   
+   NOTE:
+   
+     If macro SNPRINTF_LONGLONG_SUPPORT is not defined (default) the
+     length modifier 'll' is recognized but treated the same as 'l',
+     which may cause argument value truncation! Defining
+     SNPRINTF_LONGLONG_SUPPORT requires that your system's sprintf also
+     handles length modifier 'll'. long long int is a language extension
+     which may not be portable.
+     
+   Conversion of numeric data (conversion specifiers d, o, u, x, X, p)
+   with length modifiers (none or h, l, ll) is left to the system routine
+   sprintf, but all handling of flags, field width and precision as well
+   as c and s conversions is done very carefully by this portable
+   routine. If a string precision (truncation) is specified (e.g. %.8s)
+   it is guaranteed the string beyond the specified precision will not be
+   referenced.
+   
+   Length modifiers h, l and ll are ignored for c and s conversions (data
+   types wint_t and wchar_t are not supported).
+   
+   The following common synonyms for conversion characters are supported:
+     * i is a synonym for d
+     * D is a synonym for ld, explicit length modifiers are ignored
+     * U is a synonym for lu, explicit length modifiers are ignored
+     * O is a synonym for lo, explicit length modifiers are ignored
+       
+   The D, O and U conversion characters are nonstandard, they are
+   supported for backward compatibility only, and should not be used for
+   new code.
+   
+   The following is specifically not supported:
+     * flag ' (thousands' grouping character) is recognized but ignored
+     * numeric conversion specifiers: f, e, E, g, G and synonym F, as
+       well as the new a and A conversion specifiers
+     * length modifier 'L' (long double) and 'q' (quad - use 'll'
+       instead)
+     * wide character/string conversions: lc, ls, and nonstandard
+       synonyms C and S
+     * writeback of converted string length: conversion character n
+     * the n$ specification for direct reference to n-th argument
+     * locales
+       
+   It is permitted for str_m to be zero, and it is permitted to specify
+   NULL pointer for resulting string argument if str_m is zero (as per
+   ISO C99).
+   
+   The return value is the number of characters which would be generated
+   for the given input, excluding the trailing null. If this value is
+   greater or equal to str_m, not all characters from the result have
+   been stored in str, output bytes beyond the (str_m-1) -th character
+   are discarded. If str_m is greater than zero it is guaranteed the
+   resulting string will be null-terminated.
+   
+   NOTE that this matches the ISO C99, OpenBSD, and GNU C library 2.1,
+   but is different from some older and vendor implementations, and is
+   also different from XPG, XSH5, SUSv2 specifications. For historical
+   discussion on changes in the semantics and standards of snprintf see
+   printf(3) man page in the Linux programmers manual.
+   
+   Routines asprintf and vasprintf return a pointer (in the ptr argument)
+   to a buffer sufficiently large to hold the resulting string. This
+   pointer should be passed to free(3) to release the allocated storage
+   when it is no longer needed. If sufficient space cannot be allocated,
+   these functions will return -1 and set ptr to be a NULL pointer. These
+   two routines are a GNU C library extensions (glibc).
+   
+   Routines asnprintf and vasnprintf are similar to asprintf and
+   vasprintf, yet, like snprintf and vsnprintf counterparts, will write
+   at most str_m-1 characters into the allocated output string, the last
+   character in the allocated buffer then gets the terminating null. If
+   the formatted string length (the return value) is greater than or
+   equal to the str_m argument, the resulting string was truncated and
+   some of the formatted characters were discarded. These routines
+   present a handy way to limit the amount of allocated memory to some
+   sane value.
+   
+Availability
+
+   http://www.ijs.si/software/snprintf/
+     * snprintf_1.3.tar.gz (1999-06-30), md5 sum: snprintf_1.3.tar.gz.md5
+     * snprintf_2.1.tar.gz (2000-07-14), md5 sum: snprintf_2.1.tar.gz.md5
+     * snprintf_2.2.tar.gz (2000-10-18), md5 sum: snprintf_2.2.tar.gz.md5
+       
+Mailing list
+
+   There is a very low-traffic mailing list snprintf-announce@ijs.si
+   where announcements about new versions will be posted as well as
+   warnings about threatening bugs if discovered. The posting is
+   restricted to snprintf developer(s).
+   
+   To subscribe to (or unsubscribe from) the mailing list please visit
+   the list server's web page
+   http://mailman.ijs.si/listinfo/snprintf-announce
+   
+   You can also subscribe to the list by mailing the command SUBSCRIBE
+   either in the subject or in the message body to the address
+   snprintf-announce-request@ijs.si . You will be asked for confirmation
+   before subscription will be effective.
+   
+   The list of members is only accessible to the list administrator, so
+   there is no need for concern about automatic e-mail address gatherers.
+   
+   Questions about the mailing list and concerns for the attention of a
+   person should be sent to snprintf-announce-admin@ijs.si
+   
+   There is no general discussion list about portable snprintf at the
+   moment. Please send comments and suggestion to the author.
+   
+Revision history
+
+   Version 1.3 fixes a runaway loop problem from 1.2. Please upgrade.
+   
+   1999-06-30 V1.3 Mark Martinec <mark.martinec@ijs.si>
+          
+          + fixed runaway loop (eventually crashing when str_l wraps
+            beyond 2^31) while copying format string without conversion
+            specifiers to a buffer that is too short (thanks to Edwin
+            Young <edwiny@autonomy.com> for spotting the problem);
+          + added macros PORTABLE_SNPRINTF_VERSION_(MAJOR|MINOR) to
+            snprintf.h
+            
+   2000-02-14 V2.0 (never released) Mark Martinec <mark.martinec@ijs.si>
+          
+          + relaxed license terms: The Artistic License now applies. You
+            may still apply the GNU GENERAL PUBLIC LICENSE as was
+            distributed with previous versions, if you prefer;
+          + changed REVISION HISTORY dates to use ISO 8601 date format;
+          + added vsnprintf (patch also independently proposed by Caolán
+            McNamara 2000-05-04, and Keith M Willenson 2000-06-01)
+            
+   2000-06-27 V2.1 Mark Martinec <mark.martinec@ijs.si>
+          
+          + removed POSIX check for str_m < 1; value 0 for str_m is
+            allowed by ISO C99 (and GNU C library 2.1) (pointed out on
+            2000-05-04 by Caolán McNamara, caolan@ csn dot ul dot ie).
+            Besides relaxed license this change in standards adherence is
+            the main reason to bump up the major version number;
+          + added nonstandard routines asnprintf, vasnprintf, asprintf,
+            vasprintf that dynamically allocate storage for the resulting
+            string; these routines are not compiled by default, see
+            comments where NEED_V?ASN?PRINTF macros are defined;
+          + autoconf contributed by Caolán McNamara
+            
+   2000-10-06 V2.2 Mark Martinec <mark.martinec@ijs.si>
+          
+          + BUG FIX: the %c conversion used a temporary variable that was
+            no longer in scope when referenced, possibly causing
+            incorrect resulting character;
+          + BUG FIX: make precision and minimal field width unsigned to
+            handle huge values (2^31 <= n < 2^32) correctly; also be more
+            careful in the use of signed/unsigned/size_t internal
+            variables -- probably more careful than many vendor
+            implementations, but there may still be a case where huge
+            values of str_m, precision or minimal field could cause
+            incorrect behaviour;
+          + use separate variables for signed/unsigned arguments, and for
+            short/int, long, and long long argument lengths to avoid
+            possible incompatibilities on certain computer architectures.
+            Also use separate variable arg_sign to hold sign of a numeric
+            argument, to make code more transparent;
+          + some fiddling with zero padding and "0x" to make it Linux
+            compatible;
+          + systematically use macros fast_memcpy and fast_memset instead
+            of case-by-case hand optimization; determine some breakeven
+            string lengths for different architectures;
+          + terminology change: format -> conversion specifier, C9x ->
+            ISO/IEC 9899:1999 ("ISO C99"), alternative form -> alternate
+            form, data type modifier -> length modifier;
+          + several comments rephrased and new ones added;
+          + make compiler not complain about 'credits' defined but not
+            used;
+            
+Other implementations of snprintf
+
+   I am aware of some other (more or less) portable implementations of
+   snprintf. I do not claim they are free software - please refer to
+   their respective copyright and licensing terms. If you know of other
+   versions please let me know.
+     * a very thorough implementation (src/util_snprintf.c) by the Apache
+       Group distributed with the Apache web server -
+       http://www.apache.org/ . Does its own floating point conversions
+       using routines ecvt(3), fcvt(3) and gcvt(3) from the standard C
+       library or from the GNU libc.
+       This is from the code:
+       
+     This software [...] was originally based on public domain software
+     written at the National Center for Supercomputing Applications,
+     University of Illinois, Urbana-Champaign.
+     [...] This code is based on, and used with the permission of, the
+     SIO stdio-replacement strx_* functions by Panos Tsirigotis
+     <panos@alumni.cs.colorado.edu> for xinetd.
+     * QCI Utilities use a modified version of snprintf from the Apache
+       group.
+     * implementations as distributed with OpenBSD, FreeBSD, and NetBSD
+       are all wrappers to vfprintf.c, which is derived from software
+       contributed to Berkeley by Chris Torek.
+     * implementation from Prof. Patrick Powell <papowell@sdsu.edu>,
+       Dept. Electrical and Computer Engineering, San Diego State
+       University, San Diego, CA 92182-1309, published in Bugtraq
+       archives for 3rd quarter (Jul-Aug) 1995. No floating point
+       conversions.
+     * Brandon Long's <blong@fiction.net> modified version of Prof.
+       Patrick Powell's snprintf with contributions from others. With
+       minimal floating point support.
+     * implementation (src/snprintf.c) as distributed with sendmail -
+       http://www.sendmail.org/ is a cleaned up Prof. Patrick Powell's
+       version to compile properly and to support .precision and %lx.
+     * implementation from Caolán McNamara available at
+       http://www.csn.ul.ie/~caolan/publink/snprintf-1.1.tar.gz, handles
+       floating point.
+     * implementation used by newlog (a replacement for syslog(3)) made
+       available by the SOS Corporation. Enabling floating point support
+       is a compile-time option.
+     * implementation by Michael Richardson <mcr@metis.milkyway.com> is
+       available at http://sandelman.ottawa.on.ca/SSW/snp/snp.html. It is
+       based on BSD44-lite's vfprintf() call, modified to function on
+       SunOS. Needs internal routines from the 4.4 strtod (included),
+       requires GCC to compile the long long (aka quad_t) portions.
+     * implementation from Tomi Salo <ttsalo@ssh.fi> distributed with SSH
+       2.0 Unix Server. Not in public domain. Floating point conversions
+       done by system's sprintf.
+     * and for completeness: my portable version described in this very
+       document available at http://www.ijs.si/software/snprintf/ .
+       
+   In retrospect, it appears that a lot of effort was wasted by many
+   people for not being aware of what others are doing. Sigh.
+   
+   Also of interest: The Approved Base Working Group Resolution for XSH5,
+   Ref: bwg98-006, Topic: snprintf.
+     _________________________________________________________________
+   
+   mm
+   Last updated: 2000-10-18
+   
+   Valid HTML 4.0! 
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/snprintf_2.2/README.html	Sat Jan 19 19:14:36 2002 +0100
@@ -0,0 +1,382 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<html>
+<head>
+<link rev="made" href="mailto:mark.martinec@ijs.si">
+<title>
+snprintf.c - a portable implementation of snprintf
+(including vsnprintf.c, asnprintf, vasnprintf, asprintf, vasprintf)
+</title>
+<meta http-equiv="Content-Language" content="en">
+<meta name="author"    content="Mark Martinec">
+<meta name="copyright" content="Copyright 2000 Mark Martinec, All Rights Reserved">
+<meta name="date"      content="2000-10-18">
+<meta name="keywords" lang="en"
+ content="snprintf,portable,vsnprintf,asnprintf,vasnprintf,asprintf,vasprintf
+          ISO/IEC 9899:1999,ISO C99,ISO C9x,POSIX">
+<style type="text/css">
+<!--
+  body { background: white; color: black }
+ -->
+</style>
+</head>
+<body>
+<h1><b>snprintf.c</b>
+<br> - a portable implementation of snprintf,
+<br><font size="+1">including
+vsnprintf.c, asnprintf, vasnprintf, asprintf, vasprintf</font>
+</h1>
+
+<p><b>snprintf</b> is a routine to convert numeric and string arguments
+to formatted strings. It is similar to sprintf(3) provided in a
+system's C library, yet it requires an additional argument - the buffer
+size - and it guarantees never to store anything beyond the given buffer,
+regardless of the format or arguments to be formatted. Some newer
+operating systems do provide <b>snprintf</b> in their C library,
+but many do not or do provide an inadequate (slow or idiosyncratic)
+version, which calls for a portable implementation of this routine.
+
+<h2>Author</h2>
+
+<p><a href="http://www.ijs.si/people/mark/">Mark Martinec</a>
+&lt;<a href="mailto:mark.martinec@ijs.si">mark.martinec@ijs.si</a>&gt;,
+April 1999, June 2000
+<br>Copyright &copy; 1999, Mark Martinec
+
+<h2>Terms and conditions ...</h2>
+
+<p>This program is free software; you can redistribute it
+and/or modify it under the terms of the
+<i><a href="./LICENSE.txt">Frontier Artistic License</a></i>
+which comes with this Kit.
+
+<h2>Features</h2>
+
+<ul>
+<li>careful adherence to specs regarding flags, field width and precision;
+<li>good performance for large string handling (large format, large argument
+or large paddings). Performance is similar to system's <b>sprintf</b>
+and in several cases significantly better (make sure you compile with
+optimizations turned on, tell the compiler the code is strict ANSI
+if necessary to give it more freedom for optimizations);
+<li>return value semantics per ISO/IEC 9899:1999 ("ISO C99");
+<li>written in standard ISO/ANSI C - requires an ANSI C compiler.
+</ul>
+
+<h2>Supported conversion specifiers and data types</h2>
+
+<p>This <b>snprintf</b> only supports the following conversion specifiers:
+s, c, d, o, u, x, X, p  (and synonyms: i, D, U, O - see below)
+with flags: '-', '+', '&nbsp;', '0' and '#'.
+An asterisk is supported for field width as well as precision.
+
+<p>Length modifiers 'h' (<i>short int</i>), 'l' (<i>long int</i>),
+and 'll' (<i>long long int</i>) are supported.
+
+<p>NOTE:
+<blockquote>
+If macro SNPRINTF_LONGLONG_SUPPORT is not defined (default)
+the length modifier 'll' is recognized but treated the same as 'l',
+which may cause argument value truncation!
+Defining SNPRINTF_LONGLONG_SUPPORT requires that your system's
+<b>sprintf</b> also handles length modifier 'll'.
+<i>long long int</i> is a language extension which may not be portable.
+</blockquote>
+
+<p>Conversion of numeric data (conversion specifiers d, o, u, x, X, p)
+with length modifiers (none or h, l, ll) is left to the system
+routine <b>sprintf</b>, but all handling of flags, field width and precision
+as well as c and s conversions is done very carefully by this portable routine.
+If a string precision (truncation) is specified (e.g. %.8s) it is
+guaranteed the string beyond the specified precision will not be referenced.
+
+<p>Length modifiers h, l and ll are ignored for c and s conversions
+(data types <i>wint_t</i> and <i>wchar_t</i> are not supported).
+
+<p>The following common synonyms for conversion characters are supported:
+<ul>
+<li>i is a synonym for d
+<li>D is a synonym for ld, explicit length modifiers are ignored
+<li>U is a synonym for lu, explicit length modifiers are ignored
+<li>O is a synonym for lo, explicit length modifiers are ignored
+</ul>
+The D, O and U conversion characters are nonstandard, they are supported
+for backward compatibility only, and should not be used for new code.
+
+<p>The following is specifically <b>not</b> supported:
+<ul>
+<li>flag ' (thousands' grouping character) is recognized but ignored
+<li>numeric conversion specifiers: f, e, E, g, G and synonym F,
+as well as the new a and A conversion specifiers
+<li>length modifier 'L' (<i>long double</i>)
+and 'q' (<i>quad</i> - use 'll' instead)
+<li>wide character/string conversions: lc, ls, and nonstandard
+synonyms C and S
+<li>writeback of converted string length: conversion character n
+<li>the n$ specification for direct reference to n-th argument
+<li>locales
+</ul>
+
+<p>It is permitted for str_m to be zero, and it is permitted to specify NULL
+pointer for resulting string argument if str_m is zero (as per ISO C99).
+
+<p>The return value is the number of characters which would be generated
+for the given input, <i>excluding</i> the trailing null. If this value
+is greater or equal to str_m, not all characters from the result
+have been stored in str, output bytes beyond the (str_m-1) -th character
+are discarded. If str_m is greater than zero it is guaranteed
+the resulting string will be null-terminated.
+
+<p>NOTE that this matches the ISO C99, OpenBSD, and GNU C library 2.1,
+but is different from some older and vendor implementations,
+and is also different from XPG, XSH5, SUSv2 specifications.
+For historical discussion on changes in the semantics and standards
+of snprintf see printf(3) man page in the Linux programmers manual.
+
+<p>Routines asprintf and vasprintf return a pointer (in the ptr argument)
+to a buffer sufficiently large to hold the resulting string. This pointer
+should be passed to free(3) to release the allocated storage when it is
+no longer needed. If sufficient space cannot be allocated, these functions
+will return -1 and set ptr to be a NULL pointer. These two routines are a
+GNU C library extensions (glibc).
+
+<p>Routines asnprintf and vasnprintf are similar to asprintf and vasprintf,
+yet, like snprintf and vsnprintf counterparts, will write at most str_m-1
+characters into the allocated output string, the last character in the
+allocated buffer then gets the terminating null. If the formatted string
+length (the return value) is greater than or equal to the str_m argument,
+the resulting string was truncated and some of the formatted characters
+were discarded. These routines present a handy way to limit the amount
+of allocated memory to some sane value.
+
+<h2>Availability</h2>
+
+<p><a href="http://www.ijs.si/software/snprintf/"
+>http://www.ijs.si/software/snprintf/</a>
+
+<ul>
+<li>
+<a href="./snprintf_1.3.tar.gz">snprintf_1.3.tar.gz</a> (1999-06-30),
+md5 sum: <a href="./snprintf_1.3.tar.gz.md5">snprintf_1.3.tar.gz.md5</a>
+
+<li>
+<a href="./snprintf_2.1.tar.gz">snprintf_2.1.tar.gz</a> (2000-07-14),
+md5 sum: <a href="./snprintf_2.1.tar.gz.md5">snprintf_2.1.tar.gz.md5</a>
+
+<li>
+<a href="./snprintf_2.2.tar.gz">snprintf_2.2.tar.gz</a> (2000-10-18),
+md5 sum: <a href="./snprintf_2.2.tar.gz.md5">snprintf_2.2.tar.gz.md5</a>
+</ul>
+
+
+<h2>Mailing list</h2>
+
+<p>There is a very low-traffic mailing list <i>snprintf-announce@ijs.si</i>
+where announcements about new versions will be posted
+as well as warnings about threatening bugs if discovered.
+The posting is restricted to snprintf developer(s).
+
+<p>To subscribe to (or unsubscribe from) the mailing list
+please visit the list server's web page
+<a href="http://mailman.ijs.si/listinfo/snprintf-announce"
+>http://mailman.ijs.si/listinfo/snprintf-announce</a>
+
+<p>You can also subscribe to the list by mailing
+the command SUBSCRIBE either in the subject or in the message body
+to the address <a href="mailto:snprintf-announce-request@ijs.si"
+>snprintf-announce-request@ijs.si</a> . You will be asked for
+confirmation before subscription will be effective.
+
+<p>The list of members is only accessible to the list administrator,
+so there is no need for concern about automatic e-mail address gatherers.
+
+<p>Questions about the mailing list and concerns for the attention
+of a person should be sent to <a href="mailto:snprintf-announce-admin@ijs.si"
+>snprintf-announce-admin@ijs.si</a>
+
+<p>There is no <i>general</i> discussion list about portable snprintf
+at the moment. Please send comments and suggestion to the author.
+
+
+<h2>Revision history</h2>
+
+<p><b>Version 1.3 fixes a runaway loop problem from 1.2. Please upgrade.</b>
+
+<dl>
+<dt>1999-06-30	V1.3  Mark Martinec &lt;mark.martinec@ijs.si&gt;
+<dd><ul>
+<li>fixed runaway loop (eventually crashing when str_l wraps
+  beyond 2^31) while copying format string without
+  conversion specifiers to a buffer that is too short
+  (thanks to Edwin Young &lt;edwiny@autonomy.com&gt; for spotting the problem);
+<li>added macros PORTABLE_SNPRINTF_VERSION_(MAJOR|MINOR) to snprintf.h
+</ul>
+
+<dt>2000-02-14	V2.0 (never released) Mark Martinec &lt;mark.martinec@ijs.si&gt;
+<dd><ul>
+<li>relaxed license terms:
+  <a href="./LICENSE.txt">The Artistic License</a> now applies.
+  You may still apply the GNU GENERAL PUBLIC LICENSE
+  as was distributed with previous versions, if you prefer;
+<li>changed REVISION HISTORY dates to use
+  <a href="http://www.cl.cam.ac.uk/~mgk25/iso-time.html">ISO 8601
+  date format</a>;
+<li>added vsnprintf (patch also independently proposed by
+  Caol&aacute;n McNamara 2000-05-04, and Keith M Willenson 2000-06-01)
+</ul>
+
+<dt>2000-06-27	V2.1  Mark Martinec &lt;mark.martinec@ijs.si&gt;
+<dd><ul>
+<li>removed POSIX check for str_m &lt; 1; value 0 for str_m is
+  allowed by ISO C99 (and GNU C library 2.1) (pointed out
+  on 2000-05-04 by Caol&aacute;n McNamara, caolan@ csn dot ul dot ie).
+  Besides relaxed license this change in standards adherence
+  is the main reason to bump up the major version number;
+<li>added nonstandard routines asnprintf, vasnprintf, asprintf,
+  vasprintf that dynamically allocate storage for the
+  resulting string; these routines are not compiled by default,
+  see comments where NEED_V?ASN?PRINTF macros are defined;
+<li>autoconf contributed by Caol&aacute;n McNamara
+</ul>
+
+<dt>2000-10-06	V2.2  Mark Martinec &lt;mark.martinec@ijs.si&gt;
+<dd><ul>
+<li><b>BUG FIX</b>: the %c conversion used a temporary variable
+  that was no longer in scope when referenced,
+  possibly causing incorrect resulting character;
+<li>BUG FIX: make precision and minimal field width unsigned
+  to handle huge values (2^31 &lt;= n &lt; 2^32) correctly;
+  also be more careful in the use of signed/unsigned/size_t
+  internal variables -- probably more careful than many
+  vendor implementations, but there may still be a case
+  where huge values of str_m, precision or minimal field
+  could cause incorrect behaviour;
+<li>use separate variables for signed/unsigned arguments,
+  and for short/int, long, and long long argument lengths
+  to avoid possible incompatibilities on certain
+  computer architectures. Also use separate variable
+  arg_sign to hold sign of a numeric argument,
+  to make code more transparent;
+<li>some fiddling with zero padding and "0x" to make it
+  Linux compatible;
+<li>systematically use macros fast_memcpy and fast_memset
+  instead of case-by-case hand optimization; determine some
+  breakeven string lengths for different architectures;
+<li>terminology change: <i>format</i> -&gt; <i>conversion specifier</i>,
+  <i>C9x</i> -&gt; <i>ISO/IEC 9899:1999 ("ISO C99")</i>,
+  <i>alternative form</i> -&gt; <i>alternate form</i>,
+  <i>data type modifier</i> -&gt; <i>length modifier</i>;
+<li>several comments rephrased and new ones added;
+<li>make compiler not complain about 'credits' defined but
+  not used;
+</ul>
+</dl>
+
+<h2>Other implementations of snprintf</h2>
+
+<p>I am aware of some other (more or less) portable implementations
+of <b>snprintf</b>. I do not claim they are free software - please refer
+to their respective copyright and licensing terms.
+If you know of other versions please let
+<a href="http://www.ijs.si/people/mark/">me</a> know.
+
+<ul>
+<li>a very thorough implementation (src/util_snprintf.c)
+by the Apache Group distributed with the
+<a href="http://www.apache.org/">Apache web server
+- http://www.apache.org/</a> .
+Does its own floating point conversions using routines
+ecvt(3), fcvt(3) and gcvt(3) from the standard C library
+or from the GNU libc.
+
+<br>This is from the code:
+<blockquote>
+This software [...] was originally based
+on public domain software written at the
+<a href="http://www.ncsa.uiuc.edu/ncsa.html">National Center
+for Supercomputing Applications</a>, University of Illinois,
+Urbana-Champaign.<br>
+[...] This code is based on, and used with the permission of,
+the SIO stdio-replacement strx_* functions by Panos Tsirigotis
+&lt;<a href="mailto:panos@alumni.cs.colorado.edu">panos@alumni.cs.colorado.edu</a>&gt; for xinetd.
+</blockquote>
+
+<li><a href="http://www.qlue.com/downloads/c_utils_README.html">QCI
+Utilities</a> use a modified version of snprintf from the Apache group.
+
+<li>implementations as distributed with
+<a href="http://www.openbsd.org/cgi-bin/cvsweb/src/lib/libc/stdio/">OpenBSD</a>,
+<a href="http://www.freebsd.org/cgi/cvsweb.cgi/src/lib/libc/stdio/">FreeBSD</a>, and
+<a href="http://cvsweb.netbsd.org/cgi-bin/cvsweb.cgi/basesrc/lib/libc/stdio/">NetBSD</a>
+are all wrappers to vfprintf.c, which is derived from software
+contributed to Berkeley by Chris Torek.
+
+<li>implementation from Prof. Patrick Powell
+&lt;<a href="mailto:papowell@sdsu.edu">papowell@sdsu.edu</a>&gt;,
+Dept. Electrical and Computer Engineering, San Diego State University,
+San Diego, CA 92182-1309, published in
+<a href="http://www.geek-girl.com/bugtraq/1995_3/0217.html">Bugtraq
+archives for 3rd quarter (Jul-Aug) 1995</a>.
+No floating point conversions.
+
+<li>Brandon Long's
+&lt;<a href="mailto:blong@fiction.net">blong@fiction.net</a>&gt;
+<a href="http://www.fiction.net/~blong/programs/">modified version</a>
+of Prof. Patrick Powell's snprintf with contributions from others.
+With minimal floating point support.
+
+<li>implementation (src/snprintf.c) as distributed with
+<a href="http://www.sendmail.org/">sendmail - http://www.sendmail.org/</a>
+is a cleaned up Prof. Patrick Powell's version
+to compile properly and to support .precision and %lx.
+
+<li>implementation from <a href="http://www.csn.ul.ie/~caolan/"
+>Caol&aacute;n McNamara</a> available at
+<a href="http://www.csn.ul.ie/~caolan/publink/snprintf-1.1.tar.gz"
+>http://www.csn.ul.ie/~caolan/publink/snprintf-1.1.tar.gz</a>,
+handles floating point.
+
+<li>implementation used by
+<a href="ftp://ftp.soscorp.com/pub/sos/lib">newlog</a>
+(a replacement for syslog(3)) made available by
+the <a href="http://www.soscorp.com">SOS Corporation</a>.
+Enabling floating point support is a compile-time option.
+
+<li>implementation by Michael Richardson
+&lt;<a href="mailto:mcr@metis.milkyway.com">mcr@metis.milkyway.com</a>&gt;
+is available at
+<a href="http://sandelman.ottawa.on.ca/SSW/snp/snp.html"
+>http://sandelman.ottawa.on.ca/SSW/snp/snp.html</a>.
+It is based on BSD44-lite's vfprintf() call, modified to function
+on SunOS. Needs internal routines from the 4.4 strtod (included),
+requires GCC to compile the long long (aka quad_t) portions. 
+
+<li>implementation from Tomi Salo
+&lt;<a href="mailto:ttsalo@ssh.fi">ttsalo@ssh.fi</a>&gt;
+distributed with
+<a href="http://www.Europe.DataFellows.com/f-secure/ssh/">SSH 2.0
+Unix Server</a>. Not in public domain.
+Floating point conversions done by system's sprintf.
+
+<li>and for completeness: <a href="http://www.ijs.si/people/mark/">my</a>
+portable version described in this very document available at
+<a href="http://www.ijs.si/software/snprintf/"
+>http://www.ijs.si/software/snprintf/</a> .
+</ul>
+
+In retrospect, it appears that a lot of effort was wasted by many
+people for not being aware of what others are doing. Sigh.
+
+<p>Also of interest:
+<a href="http://www.opengroup.org/platform/resolutions/bwg98-006.html"
+>The Approved Base Working Group Resolution for XSH5,
+Ref: bwg98-006, Topic: snprintf</a>.
+
+<p><hr> 
+<i><a href="http://www.ijs.si/people/mark/">mm</a></i>
+<br>Last updated: 2000-10-18
+
+<p><a href="http://validator.w3.org/check/referer"
+><img src="/images/vh40.gif" alt="Valid HTML 4.0!"
+  border="0" width="88" height="31"></a>
+</body>
+</html>
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/snprintf_2.2/snprintf-orig.c	Sat Jan 19 19:14:36 2002 +0100
@@ -0,0 +1,1025 @@
+/*
+ * snprintf.c - a portable implementation of snprintf
+ *
+ * AUTHOR
+ *   Mark Martinec <mark.martinec@ijs.si>, April 1999.
+ *
+ *   Copyright 1999, Mark Martinec. All rights reserved.
+ *
+ * TERMS AND CONDITIONS
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the "Frontier Artistic License" which comes
+ *   with this Kit.
+ *
+ *   This program 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 Frontier Artistic License for more details.
+ *
+ *   You should have received a copy of the Frontier Artistic License
+ *   with this Kit in the file named LICENSE.txt .
+ *   If not, I'll be glad to provide one.
+ *
+ * FEATURES
+ * - careful adherence to specs regarding flags, field width and precision;
+ * - good performance for large string handling (large format, large
+ *   argument or large paddings). Performance is similar to system's sprintf
+ *   and in several cases significantly better (make sure you compile with
+ *   optimizations turned on, tell the compiler the code is strict ANSI
+ *   if necessary to give it more freedom for optimizations);
+ * - return value semantics per ISO/IEC 9899:1999 ("ISO C99");
+ * - written in standard ISO/ANSI C - requires an ANSI C compiler.
+ *
+ * SUPPORTED CONVERSION SPECIFIERS AND DATA TYPES
+ *
+ * This snprintf only supports the following conversion specifiers:
+ * s, c, d, u, o, x, X, p  (and synonyms: i, D, U, O - see below)
+ * with flags: '-', '+', ' ', '0' and '#'.
+ * An asterisk is supported for field width as well as precision.
+ *
+ * Length modifiers 'h' (short int), 'l' (long int),
+ * and 'll' (long long int) are supported.
+ * NOTE:
+ *   If macro SNPRINTF_LONGLONG_SUPPORT is not defined (default) the
+ *   length modifier 'll' is recognized but treated the same as 'l',
+ *   which may cause argument value truncation! Defining
+ *   SNPRINTF_LONGLONG_SUPPORT requires that your system's sprintf also
+ *   handles length modifier 'll'.  long long int is a language extension
+ *   which may not be portable.
+ *
+ * Conversion of numeric data (conversion specifiers d, u, o, x, X, p)
+ * with length modifiers (none or h, l, ll) is left to the system routine
+ * sprintf, but all handling of flags, field width and precision as well as
+ * c and s conversions is done very carefully by this portable routine.
+ * If a string precision (truncation) is specified (e.g. %.8s) it is
+ * guaranteed the string beyond the specified precision will not be referenced.
+ *
+ * Length modifiers h, l and ll are ignored for c and s conversions (data
+ * types wint_t and wchar_t are not supported).
+ *
+ * The following common synonyms for conversion characters are supported:
+ *   - i is a synonym for d
+ *   - D is a synonym for ld, explicit length modifiers are ignored
+ *   - U is a synonym for lu, explicit length modifiers are ignored
+ *   - O is a synonym for lo, explicit length modifiers are ignored
+ * The D, O and U conversion characters are nonstandard, they are supported
+ * for backward compatibility only, and should not be used for new code.
+ *
+ * The following is specifically NOT supported:
+ *   - flag ' (thousands' grouping character) is recognized but ignored
+ *   - numeric conversion specifiers: f, e, E, g, G and synonym F,
+ *     as well as the new a and A conversion specifiers
+ *   - length modifier 'L' (long double) and 'q' (quad - use 'll' instead)
+ *   - wide character/string conversions: lc, ls, and nonstandard
+ *     synonyms C and S
+ *   - writeback of converted string length: conversion character n
+ *   - the n$ specification for direct reference to n-th argument
+ *   - locales
+ *
+ * It is permitted for str_m to be zero, and it is permitted to specify NULL
+ * pointer for resulting string argument if str_m is zero (as per ISO C99).
+ *
+ * The return value is the number of characters which would be generated
+ * for the given input, excluding the trailing null. If this value
+ * is greater or equal to str_m, not all characters from the result
+ * have been stored in str, output bytes beyond the (str_m-1) -th character
+ * are discarded. If str_m is greater than zero it is guaranteed
+ * the resulting string will be null-terminated.
+ *
+ * NOTE that this matches the ISO C99, OpenBSD, and GNU C library 2.1,
+ * but is different from some older and vendor implementations,
+ * and is also different from XPG, XSH5, SUSv2 specifications.
+ * For historical discussion on changes in the semantics and standards
+ * of snprintf see printf(3) man page in the Linux programmers manual.
+ *
+ * Routines asprintf and vasprintf return a pointer (in the ptr argument)
+ * to a buffer sufficiently large to hold the resulting string. This pointer
+ * should be passed to free(3) to release the allocated storage when it is
+ * no longer needed. If sufficient space cannot be allocated, these functions
+ * will return -1 and set ptr to be a NULL pointer. These two routines are a
+ * GNU C library extensions (glibc).
+ *
+ * Routines asnprintf and vasnprintf are similar to asprintf and vasprintf,
+ * yet, like snprintf and vsnprintf counterparts, will write at most str_m-1
+ * characters into the allocated output string, the last character in the
+ * allocated buffer then gets the terminating null. If the formatted string
+ * length (the return value) is greater than or equal to the str_m argument,
+ * the resulting string was truncated and some of the formatted characters
+ * were discarded. These routines present a handy way to limit the amount
+ * of allocated memory to some sane value.
+ *
+ * AVAILABILITY
+ *   http://www.ijs.si/software/snprintf/
+ *
+ * REVISION HISTORY
+ * 1999-04	V0.9  Mark Martinec
+ *		- initial version, some modifications after comparing printf
+ *		  man pages for Digital Unix 4.0, Solaris 2.6 and HPUX 10,
+ *		  and checking how Perl handles sprintf (differently!);
+ * 1999-04-09	V1.0  Mark Martinec <mark.martinec@ijs.si>
+ *		- added main test program, fixed remaining inconsistencies,
+ *		  added optional (long long int) support;
+ * 1999-04-12	V1.1  Mark Martinec <mark.martinec@ijs.si>
+ *		- support the 'p' conversion (pointer to void);
+ *		- if a string precision is specified
+ *		  make sure the string beyond the specified precision
+ *		  will not be referenced (e.g. by strlen);
+ * 1999-04-13	V1.2  Mark Martinec <mark.martinec@ijs.si>
+ *		- support synonyms %D=%ld, %U=%lu, %O=%lo;
+ *		- speed up the case of long format string with few conversions;
+ * 1999-06-30	V1.3  Mark Martinec <mark.martinec@ijs.si>
+ *		- fixed runaway loop (eventually crashing when str_l wraps
+ *		  beyond 2^31) while copying format string without
+ *		  conversion specifiers to a buffer that is too short
+ *		  (thanks to Edwin Young <edwiny@autonomy.com> for
+ *		  spotting the problem);
+ *		- added macros PORTABLE_SNPRINTF_VERSION_(MAJOR|MINOR)
+ *		  to snprintf.h
+ * 2000-02-14	V2.0 (never released) Mark Martinec <mark.martinec@ijs.si>
+ *		- relaxed license terms: The Artistic License now applies.
+ *		  You may still apply the GNU GENERAL PUBLIC LICENSE
+ *		  as was distributed with previous versions, if you prefer;
+ *		- changed REVISION HISTORY dates to use ISO 8601 date format;
+ *		- added vsnprintf (patch also independently proposed by
+ *		  Caolan McNamara 2000-05-04, and Keith M Willenson 2000-06-01)
+ * 2000-06-27	V2.1  Mark Martinec <mark.martinec@ijs.si>
+ *		- removed POSIX check for str_m<1; value 0 for str_m is
+ *		  allowed by ISO C99 (and GNU C library 2.1) - (pointed out
+ *		  on 2000-05-04 by Caolan McNamara, caolan@ csn dot ul dot ie).
+ *		  Besides relaxed license this change in standards adherence
+ *		  is the main reason to bump up the major version number;
+ *		- added nonstandard routines asnprintf, vasnprintf, asprintf,
+ *		  vasprintf that dynamically allocate storage for the
+ *		  resulting string; these routines are not compiled by default,
+ *		  see comments where NEED_V?ASN?PRINTF macros are defined;
+ *		- autoconf contributed by Caolan McNamara
+ * 2000-10-06	V2.2  Mark Martinec <mark.martinec@ijs.si>
+ *		- BUG FIX: the %c conversion used a temporary variable
+ *		  that was no longer in scope when referenced,
+ *		  possibly causing incorrect resulting character;
+ *		- BUG FIX: make precision and minimal field width unsigned
+ *		  to handle huge values (2^31 <= n < 2^32) correctly;
+ *		  also be more careful in the use of signed/unsigned/size_t
+ *		  internal variables - probably more careful than many
+ *		  vendor implementations, but there may still be a case
+ *		  where huge values of str_m, precision or minimal field
+ *		  could cause incorrect behaviour;
+ *		- use separate variables for signed/unsigned arguments,
+ *		  and for short/int, long, and long long argument lengths
+ *		  to avoid possible incompatibilities on certain
+ *		  computer architectures. Also use separate variable
+ *		  arg_sign to hold sign of a numeric argument,
+ *		  to make code more transparent;
+ *		- some fiddling with zero padding and "0x" to make it
+ *		  Linux compatible;
+ *		- systematically use macros fast_memcpy and fast_memset
+ *		  instead of case-by-case hand optimization; determine some
+ *		  breakeven string lengths for different architectures;
+ *		- terminology change: 'format' -> 'conversion specifier',
+ *		  'C9x' -> 'ISO/IEC 9899:1999 ("ISO C99")',
+ *		  'alternative form' -> 'alternate form',
+ *		  'data type modifier' -> 'length modifier';
+ *		- several comments rephrased and new ones added;
+ *		- make compiler not complain about 'credits' defined but
+ *		  not used;
+ */
+
+
+/* Define HAVE_SNPRINTF if your system already has snprintf and vsnprintf.
+ *
+ * If HAVE_SNPRINTF is defined this module will not produce code for
+ * snprintf and vsnprintf, unless PREFER_PORTABLE_SNPRINTF is defined as well,
+ * causing this portable version of snprintf to be called portable_snprintf
+ * (and portable_vsnprintf).
+ */
+/* #define HAVE_SNPRINTF */
+
+/* Define PREFER_PORTABLE_SNPRINTF if your system does have snprintf and
+ * vsnprintf but you would prefer to use the portable routine(s) instead.
+ * In this case the portable routine is declared as portable_snprintf
+ * (and portable_vsnprintf) and a macro 'snprintf' (and 'vsnprintf')
+ * is defined to expand to 'portable_v?snprintf' - see file snprintf.h .
+ * Defining this macro is only useful if HAVE_SNPRINTF is also defined,
+ * but does does no harm if defined nevertheless.
+ */
+/* #define PREFER_PORTABLE_SNPRINTF */
+
+/* Define SNPRINTF_LONGLONG_SUPPORT if you want to support
+ * data type (long long int) and length modifier 'll' (e.g. %lld).
+ * If undefined, 'll' is recognized but treated as a single 'l'.
+ *
+ * If the system's sprintf does not handle 'll'
+ * the SNPRINTF_LONGLONG_SUPPORT must not be defined!
+ *
+ * This is off by default as (long long int) is a language extension.
+ */
+/* #define SNPRINTF_LONGLONG_SUPPORT */
+
+/* Define NEED_SNPRINTF_ONLY if you only need snprintf, and not vsnprintf.
+ * If NEED_SNPRINTF_ONLY is defined, the snprintf will be defined directly,
+ * otherwise both snprintf and vsnprintf routines will be defined
+ * and snprintf will be a simple wrapper around vsnprintf, at the expense
+ * of an extra procedure call.
+ */
+/* #define NEED_SNPRINTF_ONLY */
+
+/* Define NEED_V?ASN?PRINTF macros if you need library extension
+ * routines asprintf, vasprintf, asnprintf, vasnprintf respectively,
+ * and your system library does not provide them. They are all small
+ * wrapper routines around portable_vsnprintf. Defining any of the four
+ * NEED_V?ASN?PRINTF macros automatically turns off NEED_SNPRINTF_ONLY
+ * and turns on PREFER_PORTABLE_SNPRINTF.
+ *
+ * Watch for name conflicts with the system library if these routines
+ * are already present there.
+ *
+ * NOTE: vasprintf and vasnprintf routines need va_copy() from stdarg.h, as
+ * specified by C99, to be able to traverse the same list of arguments twice.
+ * I don't know of any other standard and portable way of achieving the same.
+ * With some versions of gcc you may use __va_copy(). You might even get away
+ * with "ap2 = ap", in this case you must not call va_end(ap2) !
+ *   #define va_copy(ap2,ap) ap2 = ap
+ */
+/* #define NEED_ASPRINTF   */
+/* #define NEED_ASNPRINTF  */
+/* #define NEED_VASPRINTF  */
+/* #define NEED_VASNPRINTF */
+
+
+/* Define the following macros if desired:
+ *   SOLARIS_COMPATIBLE, SOLARIS_BUG_COMPATIBLE,
+ *   HPUX_COMPATIBLE, HPUX_BUG_COMPATIBLE, LINUX_COMPATIBLE,
+ *   DIGITAL_UNIX_COMPATIBLE, DIGITAL_UNIX_BUG_COMPATIBLE,
+ *   PERL_COMPATIBLE, PERL_BUG_COMPATIBLE,
+ *
+ * - For portable applications it is best not to rely on peculiarities
+ *   of a given implementation so it may be best not to define any
+ *   of the macros that select compatibility and to avoid features
+ *   that vary among the systems.
+ *
+ * - Selecting compatibility with more than one operating system
+ *   is not strictly forbidden but is not recommended.
+ *
+ * - 'x'_BUG_COMPATIBLE implies 'x'_COMPATIBLE .
+ *
+ * - 'x'_COMPATIBLE refers to (and enables) a behaviour that is
+ *   documented in a sprintf man page on a given operating system
+ *   and actually adhered to by the system's sprintf (but not on
+ *   most other operating systems). It may also refer to and enable
+ *   a behaviour that is declared 'undefined' or 'implementation specific'
+ *   in the man page but a given implementation behaves predictably
+ *   in a certain way.
+ *
+ * - 'x'_BUG_COMPATIBLE refers to (and enables) a behaviour of system's sprintf
+ *   that contradicts the sprintf man page on the same operating system.
+ *
+ * - I do not claim that the 'x'_COMPATIBLE and 'x'_BUG_COMPATIBLE
+ *   conditionals take into account all idiosyncrasies of a particular
+ *   implementation, there may be other incompatibilities.
+ */
+
+
+
+/* ============================================= */
+/* NO USER SERVICABLE PARTS FOLLOWING THIS POINT */
+/* ============================================= */
+
+#define PORTABLE_SNPRINTF_VERSION_MAJOR 2
+#define PORTABLE_SNPRINTF_VERSION_MINOR 2
+
+#if defined(NEED_ASPRINTF) || defined(NEED_ASNPRINTF) || defined(NEED_VASPRINTF) || defined(NEED_VASNPRINTF)
+# if defined(NEED_SNPRINTF_ONLY)
+# undef NEED_SNPRINTF_ONLY
+# endif
+# if !defined(PREFER_PORTABLE_SNPRINTF)
+# define PREFER_PORTABLE_SNPRINTF
+# endif
+#endif
+
+#if defined(SOLARIS_BUG_COMPATIBLE) && !defined(SOLARIS_COMPATIBLE)
+#define SOLARIS_COMPATIBLE
+#endif
+
+#if defined(HPUX_BUG_COMPATIBLE) && !defined(HPUX_COMPATIBLE)
+#define HPUX_COMPATIBLE
+#endif
+
+#if defined(DIGITAL_UNIX_BUG_COMPATIBLE) && !defined(DIGITAL_UNIX_COMPATIBLE)
+#define DIGITAL_UNIX_COMPATIBLE
+#endif
+
+#if defined(PERL_BUG_COMPATIBLE) && !defined(PERL_COMPATIBLE)
+#define PERL_COMPATIBLE
+#endif
+
+#if defined(LINUX_BUG_COMPATIBLE) && !defined(LINUX_COMPATIBLE)
+#define LINUX_COMPATIBLE
+#endif
+
+#include <sys/types.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <errno.h>
+
+#ifdef isdigit
+#undef isdigit
+#endif
+#define isdigit(c) ((c) >= '0' && (c) <= '9')
+
+/* For copying strings longer or equal to 'breakeven_point'
+ * it is more efficient to call memcpy() than to do it inline.
+ * The value depends mostly on the processor architecture,
+ * but also on the compiler and its optimization capabilities.
+ * The value is not critical, some small value greater than zero
+ * will be just fine if you don't care to squeeze every drop
+ * of performance out of the code.
+ *
+ * Small values favor memcpy, large values favor inline code.
+ */
+#if defined(__alpha__) || defined(__alpha)
+#  define breakeven_point   2	/* AXP (DEC Alpha)     - gcc or cc or egcs */
+#endif
+#if defined(__i386__)  || defined(__i386)
+#  define breakeven_point  12	/* Intel Pentium/Linux - gcc 2.96 */
+#endif
+#if defined(__hppa)
+#  define breakeven_point  10	/* HP-PA               - gcc */
+#endif
+#if defined(__sparc__) || defined(__sparc)
+#  define breakeven_point  33	/* Sun Sparc 5         - gcc 2.8.1 */
+#endif
+
+/* some other values of possible interest: */
+/* #define breakeven_point  8 */  /* VAX 4000          - vaxc */
+/* #define breakeven_point 19 */  /* VAX 4000          - gcc 2.7.0 */
+
+#ifndef breakeven_point
+#  define breakeven_point   6	/* some reasonable one-size-fits-all value */
+#endif
+
+#define fast_memcpy(d,s,n) \
+  { register size_t nn = (size_t)(n); \
+    if (nn >= breakeven_point) memcpy((d), (s), nn); \
+    else if (nn > 0) { /* proc call overhead is worth only for large strings*/\
+      register char *dd; register const char *ss; \
+      for (ss=(s), dd=(d); nn>0; nn--) *dd++ = *ss++; } }
+
+#define fast_memset(d,c,n) \
+  { register size_t nn = (size_t)(n); \
+    if (nn >= breakeven_point) memset((d), (int)(c), nn); \
+    else if (nn > 0) { /* proc call overhead is worth only for large strings*/\
+      register char *dd; register const int cc=(int)(c); \
+      for (dd=(d); nn>0; nn--) *dd++ = cc; } }
+
+/* prototypes */
+
+#if defined(NEED_ASPRINTF)
+int asprintf   (char **ptr, const char *fmt, /*args*/ ...);
+#endif
+#if defined(NEED_VASPRINTF)
+int vasprintf  (char **ptr, const char *fmt, va_list ap);
+#endif
+#if defined(NEED_ASNPRINTF)
+int asnprintf  (char **ptr, size_t str_m, const char *fmt, /*args*/ ...);
+#endif
+#if defined(NEED_VASNPRINTF)
+int vasnprintf (char **ptr, size_t str_m, const char *fmt, va_list ap);
+#endif
+
+#if defined(HAVE_SNPRINTF)
+/* declare our portable snprintf  routine under name portable_snprintf  */
+/* declare our portable vsnprintf routine under name portable_vsnprintf */
+#else
+/* declare our portable routines under names snprintf and vsnprintf */
+#define portable_snprintf snprintf
+#if !defined(NEED_SNPRINTF_ONLY)
+#define portable_vsnprintf vsnprintf
+#endif
+#endif
+
+#if !defined(HAVE_SNPRINTF) || defined(PREFER_PORTABLE_SNPRINTF)
+int portable_snprintf(char *str, size_t str_m, const char *fmt, /*args*/ ...);
+#if !defined(NEED_SNPRINTF_ONLY)
+int portable_vsnprintf(char *str, size_t str_m, const char *fmt, va_list ap);
+#endif
+#endif
+
+/* declarations */
+
+static char credits[] = "\n\
+@(#)snprintf.c, v2.2: Mark Martinec, <mark.martinec@ijs.si>\n\
+@(#)snprintf.c, v2.2: Copyright 1999, Mark Martinec. Frontier Artistic License applies.\n\
+@(#)snprintf.c, v2.2: http://www.ijs.si/software/snprintf/\n";
+
+#if defined(NEED_ASPRINTF)
+int asprintf(char **ptr, const char *fmt, /*args*/ ...) {
+  va_list ap;
+  size_t str_m;
+  int str_l;
+
+  *ptr = NULL;
+  va_start(ap, fmt);                            /* measure the required size */
+  str_l = portable_vsnprintf(NULL, (size_t)0, fmt, ap);
+  va_end(ap);
+  assert(str_l >= 0);        /* possible integer overflow if str_m > INT_MAX */
+  *ptr = (char *) malloc(str_m = (size_t)str_l + 1);
+  if (*ptr == NULL) { errno = ENOMEM; str_l = -1; }
+  else {
+    int str_l2;
+    va_start(ap, fmt);
+    str_l2 = portable_vsnprintf(*ptr, str_m, fmt, ap);
+    va_end(ap);
+    assert(str_l2 == str_l);
+  }
+  return str_l;
+}
+#endif
+
+#if defined(NEED_VASPRINTF)
+int vasprintf(char **ptr, const char *fmt, va_list ap) {
+  size_t str_m;
+  int str_l;
+
+  *ptr = NULL;
+  { va_list ap2;
+    va_copy(ap2, ap);  /* don't consume the original ap, we'll need it again */
+    str_l = portable_vsnprintf(NULL, (size_t)0, fmt, ap2);/*get required size*/
+    va_end(ap2);
+  }
+  assert(str_l >= 0);        /* possible integer overflow if str_m > INT_MAX */
+  *ptr = (char *) malloc(str_m = (size_t)str_l + 1);
+  if (*ptr == NULL) { errno = ENOMEM; str_l = -1; }
+  else {
+    int str_l2 = portable_vsnprintf(*ptr, str_m, fmt, ap);
+    assert(str_l2 == str_l);
+  }
+  return str_l;
+}
+#endif
+
+#if defined(NEED_ASNPRINTF)
+int asnprintf (char **ptr, size_t str_m, const char *fmt, /*args*/ ...) {
+  va_list ap;
+  int str_l;
+
+  *ptr = NULL;
+  va_start(ap, fmt);                            /* measure the required size */
+  str_l = portable_vsnprintf(NULL, (size_t)0, fmt, ap);
+  va_end(ap);
+  assert(str_l >= 0);        /* possible integer overflow if str_m > INT_MAX */
+  if ((size_t)str_l + 1 < str_m) str_m = (size_t)str_l + 1;      /* truncate */
+  /* if str_m is 0, no buffer is allocated, just set *ptr to NULL */
+  if (str_m == 0) {  /* not interested in resulting string, just return size */
+  } else {
+    *ptr = (char *) malloc(str_m);
+    if (*ptr == NULL) { errno = ENOMEM; str_l = -1; }
+    else {
+      int str_l2;
+      va_start(ap, fmt);
+      str_l2 = portable_vsnprintf(*ptr, str_m, fmt, ap);
+      va_end(ap);
+      assert(str_l2 == str_l);
+    }
+  }
+  return str_l;
+}
+#endif
+
+#if defined(NEED_VASNPRINTF)
+int vasnprintf (char **ptr, size_t str_m, const char *fmt, va_list ap) {
+  int str_l;
+
+  *ptr = NULL;
+  { va_list ap2;
+    va_copy(ap2, ap);  /* don't consume the original ap, we'll need it again */
+    str_l = portable_vsnprintf(NULL, (size_t)0, fmt, ap2);/*get required size*/
+    va_end(ap2);
+  }
+  assert(str_l >= 0);        /* possible integer overflow if str_m > INT_MAX */
+  if ((size_t)str_l + 1 < str_m) str_m = (size_t)str_l + 1;      /* truncate */
+  /* if str_m is 0, no buffer is allocated, just set *ptr to NULL */
+  if (str_m == 0) {  /* not interested in resulting string, just return size */
+  } else {
+    *ptr = (char *) malloc(str_m);
+    if (*ptr == NULL) { errno = ENOMEM; str_l = -1; }
+    else {
+      int str_l2 = portable_vsnprintf(*ptr, str_m, fmt, ap);
+      assert(str_l2 == str_l);
+    }
+  }
+  return str_l;
+}
+#endif
+
+/*
+ * If the system does have snprintf and the portable routine is not
+ * specifically required, this module produces no code for snprintf/vsnprintf.
+ */
+#if !defined(HAVE_SNPRINTF) || defined(PREFER_PORTABLE_SNPRINTF)
+
+#if !defined(NEED_SNPRINTF_ONLY)
+int portable_snprintf(char *str, size_t str_m, const char *fmt, /*args*/ ...) {
+  va_list ap;
+  int str_l;
+
+  va_start(ap, fmt);
+  str_l = portable_vsnprintf(str, str_m, fmt, ap);
+  va_end(ap);
+  return str_l;
+}
+#endif
+
+#if defined(NEED_SNPRINTF_ONLY)
+int portable_snprintf(char *str, size_t str_m, const char *fmt, /*args*/ ...) {
+#else
+int portable_vsnprintf(char *str, size_t str_m, const char *fmt, va_list ap) {
+#endif
+
+#if defined(NEED_SNPRINTF_ONLY)
+  va_list ap;
+#endif
+  size_t str_l = 0;
+  const char *p = fmt;
+
+/* In contrast with POSIX, the ISO C99 now says
+ * that str can be NULL and str_m can be 0.
+ * This is more useful than the old:  if (str_m < 1) return -1; */
+
+#if defined(NEED_SNPRINTF_ONLY)
+  va_start(ap, fmt);
+#endif
+  if (!p) p = "";
+  while (*p) {
+    if (*p != '%') {
+   /* if (str_l < str_m) str[str_l++] = *p++;    -- this would be sufficient */
+   /* but the following code achieves better performance for cases
+    * where format string is long and contains few conversions */
+      const char *q = strchr(p+1,'%');
+      size_t n = !q ? strlen(p) : (q-p);
+      if (str_l < str_m) {
+        size_t avail = str_m-str_l;
+        fast_memcpy(str+str_l, p, (n>avail?avail:n));
+      }
+      p += n; str_l += n;
+    } else {
+      const char *starting_p;
+      size_t min_field_width = 0, precision = 0;
+      int zero_padding = 0, precision_specified = 0, justify_left = 0;
+      int alternate_form = 0, force_sign = 0;
+      int space_for_positive = 1; /* If both the ' ' and '+' flags appear,
+                                     the ' ' flag should be ignored. */
+      char length_modifier = '\0';            /* allowed values: \0, h, l, L */
+      char tmp[32];/* temporary buffer for simple numeric->string conversion */
+
+      const char *str_arg;      /* string address in case of string argument */
+      size_t str_arg_l;         /* natural field width of arg without padding
+                                   and sign */
+      unsigned char uchar_arg;
+        /* unsigned char argument value - only defined for c conversion.
+           N.B. standard explicitly states the char argument for
+           the c conversion is unsigned */
+
+      size_t number_of_zeros_to_pad = 0;
+        /* number of zeros to be inserted for numeric conversions
+           as required by the precision or minimal field width */
+
+      size_t zero_padding_insertion_ind = 0;
+        /* index into tmp where zero padding is to be inserted */
+
+      char fmt_spec = '\0';
+        /* current conversion specifier character */
+
+      str_arg = credits;/* just to make compiler happy (defined but not used)*/
+      str_arg = NULL;
+      starting_p = p; p++;  /* skip '%' */
+   /* parse flags */
+      while (*p == '0' || *p == '-' || *p == '+' ||
+             *p == ' ' || *p == '#' || *p == '\'') {
+        switch (*p) {
+        case '0': zero_padding = 1; break;
+        case '-': justify_left = 1; break;
+        case '+': force_sign = 1; space_for_positive = 0; break;
+        case ' ': force_sign = 1;
+     /* If both the ' ' and '+' flags appear, the ' ' flag should be ignored */
+#ifdef PERL_COMPATIBLE
+     /* ... but in Perl the last of ' ' and '+' applies */
+                  space_for_positive = 1;
+#endif
+                  break;
+        case '#': alternate_form = 1; break;
+        case '\'': break;
+        }
+        p++;
+      }
+   /* If the '0' and '-' flags both appear, the '0' flag should be ignored. */
+
+   /* parse field width */
+      if (*p == '*') {
+        int j;
+        p++; j = va_arg(ap, int);
+        if (j >= 0) min_field_width = j;
+        else { min_field_width = -j; justify_left = 1; }
+      } else if (isdigit((int)(*p))) {
+        /* size_t could be wider than unsigned int;
+           make sure we treat argument like common implementations do */
+        unsigned int uj = *p++ - '0';
+        while (isdigit((int)(*p))) uj = 10*uj + (unsigned int)(*p++ - '0');
+        min_field_width = uj;
+      }
+   /* parse precision */
+      if (*p == '.') {
+        p++; precision_specified = 1;
+        if (*p == '*') {
+          int j = va_arg(ap, int);
+          p++;
+          if (j >= 0) precision = j;
+          else {
+            precision_specified = 0; precision = 0;
+         /* NOTE:
+          *   Solaris 2.6 man page claims that in this case the precision
+          *   should be set to 0.  Digital Unix 4.0, HPUX 10 and BSD man page
+          *   claim that this case should be treated as unspecified precision,
+          *   which is what we do here.
+          */
+          }
+        } else if (isdigit((int)(*p))) {
+          /* size_t could be wider than unsigned int;
+             make sure we treat argument like common implementations do */
+          unsigned int uj = *p++ - '0';
+          while (isdigit((int)(*p))) uj = 10*uj + (unsigned int)(*p++ - '0');
+          precision = uj;
+        }
+      }
+   /* parse 'h', 'l' and 'll' length modifiers */
+      if (*p == 'h' || *p == 'l') {
+        length_modifier = *p; p++;
+        if (length_modifier == 'l' && *p == 'l') {   /* double l = long long */
+#ifdef SNPRINTF_LONGLONG_SUPPORT
+          length_modifier = '2';                  /* double l encoded as '2' */
+#else
+          length_modifier = 'l';                 /* treat it as a single 'l' */
+#endif
+          p++;
+        }
+      }
+      fmt_spec = *p;
+   /* common synonyms: */
+      switch (fmt_spec) {
+      case 'i': fmt_spec = 'd'; break;
+      case 'D': fmt_spec = 'd'; length_modifier = 'l'; break;
+      case 'U': fmt_spec = 'u'; length_modifier = 'l'; break;
+      case 'O': fmt_spec = 'o'; length_modifier = 'l'; break;
+      default: break;
+      }
+   /* get parameter value, do initial processing */
+      switch (fmt_spec) {
+      case '%': /* % behaves similar to 's' regarding flags and field widths */
+      case 'c': /* c behaves similar to 's' regarding flags and field widths */
+      case 's':
+        length_modifier = '\0';          /* wint_t and wchar_t not supported */
+     /* the result of zero padding flag with non-numeric conversion specifier*/
+     /* is undefined. Solaris and HPUX 10 does zero padding in this case,    */
+     /* Digital Unix and Linux does not. */
+#if !defined(SOLARIS_COMPATIBLE) && !defined(HPUX_COMPATIBLE)
+        zero_padding = 0;    /* turn zero padding off for string conversions */
+#endif
+        str_arg_l = 1;
+        switch (fmt_spec) {
+        case '%':
+          str_arg = p; break;
+        case 'c': {
+          int j = va_arg(ap, int);
+          uchar_arg = (unsigned char) j;   /* standard demands unsigned char */
+          str_arg = (const char *) &uchar_arg;
+          break;
+        }
+        case 's':
+          str_arg = va_arg(ap, const char *);
+          if (!str_arg) str_arg_l = 0;
+       /* make sure not to address string beyond the specified precision !!! */
+          else if (!precision_specified) str_arg_l = strlen(str_arg);
+       /* truncate string if necessary as requested by precision */
+          else if (precision == 0) str_arg_l = 0;
+          else {
+       /* memchr on HP does not like n > 2^31  !!! */
+            const char *q = memchr(str_arg, '\0',
+                             precision <= 0x7fffffff ? precision : 0x7fffffff);
+            str_arg_l = !q ? precision : (q-str_arg);
+          }
+          break;
+        default: break;
+        }
+        break;
+      case 'd': case 'u': case 'o': case 'x': case 'X': case 'p': {
+        /* NOTE: the u, o, x, X and p conversion specifiers imply
+                 the value is unsigned;  d implies a signed value */
+
+        int arg_sign = 0;
+          /* 0 if numeric argument is zero (or if pointer is NULL for 'p'),
+            +1 if greater than zero (or nonzero for unsigned arguments),
+            -1 if negative (unsigned argument is never negative) */
+
+        int int_arg = 0;  unsigned int uint_arg = 0;
+          /* only defined for length modifier h, or for no length modifiers */
+
+        long int long_arg = 0;  unsigned long int ulong_arg = 0;
+          /* only defined for length modifier l */
+
+        void *ptr_arg = NULL;
+          /* pointer argument value -only defined for p conversion */
+
+#ifdef SNPRINTF_LONGLONG_SUPPORT
+        long long int long_long_arg = 0;
+        unsigned long long int ulong_long_arg = 0;
+          /* only defined for length modifier ll */
+#endif
+        if (fmt_spec == 'p') {
+        /* HPUX 10: An l, h, ll or L before any other conversion character
+         *   (other than d, i, u, o, x, or X) is ignored.
+         * Digital Unix:
+         *   not specified, but seems to behave as HPUX does.
+         * Solaris: If an h, l, or L appears before any other conversion
+         *   specifier (other than d, i, u, o, x, or X), the behavior
+         *   is undefined. (Actually %hp converts only 16-bits of address
+         *   and %llp treats address as 64-bit data which is incompatible
+         *   with (void *) argument on a 32-bit system).
+         */
+#ifdef SOLARIS_COMPATIBLE
+#  ifdef SOLARIS_BUG_COMPATIBLE
+          /* keep length modifiers even if it represents 'll' */
+#  else
+          if (length_modifier == '2') length_modifier = '\0';
+#  endif
+#else
+          length_modifier = '\0';
+#endif
+          ptr_arg = va_arg(ap, void *);
+          if (ptr_arg != NULL) arg_sign = 1;
+        } else if (fmt_spec == 'd') {  /* signed */
+          switch (length_modifier) {
+          case '\0':
+          case 'h':
+         /* It is non-portable to specify a second argument of char or short
+          * to va_arg, because arguments seen by the called function
+          * are not char or short.  C converts char and short arguments
+          * to int before passing them to a function.
+          */
+            int_arg = va_arg(ap, int);
+            if      (int_arg > 0) arg_sign =  1;
+            else if (int_arg < 0) arg_sign = -1;
+            break;
+          case 'l':
+            long_arg = va_arg(ap, long int);
+            if      (long_arg > 0) arg_sign =  1;
+            else if (long_arg < 0) arg_sign = -1;
+            break;
+#ifdef SNPRINTF_LONGLONG_SUPPORT
+          case '2':
+            long_long_arg = va_arg(ap, long long int);
+            if      (long_long_arg > 0) arg_sign =  1;
+            else if (long_long_arg < 0) arg_sign = -1;
+            break;
+#endif
+          }
+        } else {  /* unsigned */
+          switch (length_modifier) {
+          case '\0':
+          case 'h':
+            uint_arg = va_arg(ap, unsigned int);
+            if (uint_arg) arg_sign = 1;
+            break;
+          case 'l':
+            ulong_arg = va_arg(ap, unsigned long int);
+            if (ulong_arg) arg_sign = 1;
+            break;
+#ifdef SNPRINTF_LONGLONG_SUPPORT
+          case '2':
+            ulong_long_arg = va_arg(ap, unsigned long long int);
+            if (ulong_long_arg) arg_sign = 1;
+            break;
+#endif
+          }
+        }
+        str_arg = tmp; str_arg_l = 0;
+     /* NOTE:
+      *   For d, i, u, o, x, and X conversions, if precision is specified,
+      *   the '0' flag should be ignored. This is so with Solaris 2.6,
+      *   Digital UNIX 4.0, HPUX 10, Linux, FreeBSD, NetBSD; but not with Perl.
+      */
+#ifndef PERL_COMPATIBLE
+        if (precision_specified) zero_padding = 0;
+#endif
+        if (fmt_spec == 'd') {
+          if (force_sign && arg_sign >= 0)
+            tmp[str_arg_l++] = space_for_positive ? ' ' : '+';
+         /* leave negative numbers for sprintf to handle,
+            to avoid handling tricky cases like (short int)(-32768) */
+#ifdef LINUX_COMPATIBLE
+        } else if (fmt_spec == 'p' && force_sign && arg_sign > 0) {
+          tmp[str_arg_l++] = space_for_positive ? ' ' : '+';
+#endif
+        } else if (alternate_form) {
+          if (arg_sign != 0 && (fmt_spec == 'x' || fmt_spec == 'X') )
+            { tmp[str_arg_l++] = '0'; tmp[str_arg_l++] = fmt_spec; }
+         /* alternate form should have no effect for p conversion, but ... */
+#ifdef HPUX_COMPATIBLE
+          else if (fmt_spec == 'p'
+         /* HPUX 10: for an alternate form of p conversion,
+          *          a nonzero result is prefixed by 0x. */
+#ifndef HPUX_BUG_COMPATIBLE
+         /* Actually it uses 0x prefix even for a zero value. */
+                   && arg_sign != 0
+#endif
+                  ) { tmp[str_arg_l++] = '0'; tmp[str_arg_l++] = 'x'; }
+#endif
+        }
+        zero_padding_insertion_ind = str_arg_l;
+        if (!precision_specified) precision = 1;   /* default precision is 1 */
+        if (precision == 0 && arg_sign == 0
+#if defined(HPUX_BUG_COMPATIBLE) || defined(LINUX_COMPATIBLE)
+            && fmt_spec != 'p'
+         /* HPUX 10 man page claims: With conversion character p the result of
+          * converting a zero value with a precision of zero is a null string.
+          * Actually HP returns all zeroes, and Linux returns "(nil)". */
+#endif
+        ) {
+         /* converted to null string */
+         /* When zero value is formatted with an explicit precision 0,
+            the resulting formatted string is empty (d, i, u, o, x, X, p).   */
+        } else {
+          char f[5]; int f_l = 0;
+          f[f_l++] = '%';    /* construct a simple format string for sprintf */
+          if (!length_modifier) { }
+          else if (length_modifier=='2') { f[f_l++] = 'l'; f[f_l++] = 'l'; }
+          else f[f_l++] = length_modifier;
+          f[f_l++] = fmt_spec; f[f_l++] = '\0';
+          if (fmt_spec == 'p') str_arg_l += sprintf(tmp+str_arg_l, f, ptr_arg);
+          else if (fmt_spec == 'd') {  /* signed */
+            switch (length_modifier) {
+            case '\0':
+            case 'h': str_arg_l+=sprintf(tmp+str_arg_l, f, int_arg);  break;
+            case 'l': str_arg_l+=sprintf(tmp+str_arg_l, f, long_arg); break;
+#ifdef SNPRINTF_LONGLONG_SUPPORT
+            case '2': str_arg_l+=sprintf(tmp+str_arg_l,f,long_long_arg); break;
+#endif
+            }
+          } else {  /* unsigned */
+            switch (length_modifier) {
+            case '\0':
+            case 'h': str_arg_l+=sprintf(tmp+str_arg_l, f, uint_arg);  break;
+            case 'l': str_arg_l+=sprintf(tmp+str_arg_l, f, ulong_arg); break;
+#ifdef SNPRINTF_LONGLONG_SUPPORT
+            case '2': str_arg_l+=sprintf(tmp+str_arg_l,f,ulong_long_arg);break;
+#endif
+            }
+          }
+         /* include the optional minus sign and possible "0x"
+            in the region before the zero padding insertion point */
+          if (zero_padding_insertion_ind < str_arg_l &&
+              tmp[zero_padding_insertion_ind] == '-') {
+            zero_padding_insertion_ind++;
+          }
+          if (zero_padding_insertion_ind+1 < str_arg_l &&
+              tmp[zero_padding_insertion_ind]   == '0' &&
+             (tmp[zero_padding_insertion_ind+1] == 'x' ||
+              tmp[zero_padding_insertion_ind+1] == 'X') ) {
+            zero_padding_insertion_ind += 2;
+          }
+        }
+        { size_t num_of_digits = str_arg_l - zero_padding_insertion_ind;
+          if (alternate_form && fmt_spec == 'o'
+#ifdef HPUX_COMPATIBLE                                  /* ("%#.o",0) -> ""  */
+              && (str_arg_l > 0)
+#endif
+#ifdef DIGITAL_UNIX_BUG_COMPATIBLE                      /* ("%#o",0) -> "00" */
+#else
+              /* unless zero is already the first character */
+              && !(zero_padding_insertion_ind < str_arg_l
+                   && tmp[zero_padding_insertion_ind] == '0')
+#endif
+          ) {        /* assure leading zero for alternate-form octal numbers */
+            if (!precision_specified || precision < num_of_digits+1) {
+             /* precision is increased to force the first character to be zero,
+                except if a zero value is formatted with an explicit precision
+                of zero */
+              precision = num_of_digits+1; precision_specified = 1;
+            }
+          }
+       /* zero padding to specified precision? */
+          if (num_of_digits < precision) 
+            number_of_zeros_to_pad = precision - num_of_digits;
+        }
+     /* zero padding to specified minimal field width? */
+        if (!justify_left && zero_padding) {
+          int n = min_field_width - (str_arg_l+number_of_zeros_to_pad);
+          if (n > 0) number_of_zeros_to_pad += n;
+        }
+        break;
+      }
+      default: /* unrecognized conversion specifier, keep format string as-is*/
+        zero_padding = 0;  /* turn zero padding off for non-numeric convers. */
+#ifndef DIGITAL_UNIX_COMPATIBLE
+        justify_left = 1; min_field_width = 0;                /* reset flags */
+#endif
+#if defined(PERL_COMPATIBLE) || defined(LINUX_COMPATIBLE)
+     /* keep the entire format string unchanged */
+        str_arg = starting_p; str_arg_l = p - starting_p;
+     /* well, not exactly so for Linux, which does something inbetween,
+      * and I don't feel an urge to imitate it: "%+++++hy" -> "%+y"  */
+#else
+     /* discard the unrecognized conversion, just keep *
+      * the unrecognized conversion character          */
+        str_arg = p; str_arg_l = 0;
+#endif
+        if (*p) str_arg_l++;  /* include invalid conversion specifier unchanged
+                                 if not at end-of-string */
+        break;
+      }
+      if (*p) p++;      /* step over the just processed conversion specifier */
+   /* insert padding to the left as requested by min_field_width;
+      this does not include the zero padding in case of numerical conversions*/
+      if (!justify_left) {                /* left padding with blank or zero */
+        int n = min_field_width - (str_arg_l+number_of_zeros_to_pad);
+        if (n > 0) {
+          if (str_l < str_m) {
+            size_t avail = str_m-str_l;
+            fast_memset(str+str_l, (zero_padding?'0':' '), (n>avail?avail:n));
+          }
+          str_l += n;
+        }
+      }
+   /* zero padding as requested by the precision or by the minimal field width
+    * for numeric conversions required? */
+      if (number_of_zeros_to_pad <= 0) {
+     /* will not copy first part of numeric right now, *
+      * force it to be copied later in its entirety    */
+        zero_padding_insertion_ind = 0;
+      } else {
+     /* insert first part of numerics (sign or '0x') before zero padding */
+        int n = zero_padding_insertion_ind;
+        if (n > 0) {
+          if (str_l < str_m) {
+            size_t avail = str_m-str_l;
+            fast_memcpy(str+str_l, str_arg, (n>avail?avail:n));
+          }
+          str_l += n;
+        }
+     /* insert zero padding as requested by the precision or min field width */
+        n = number_of_zeros_to_pad;
+        if (n > 0) {
+          if (str_l < str_m) {
+            size_t avail = str_m-str_l;
+            fast_memset(str+str_l, '0', (n>avail?avail:n));
+          }
+          str_l += n;
+        }
+      }
+   /* insert formatted string
+    * (or as-is conversion specifier for unknown conversions) */
+      { int n = str_arg_l - zero_padding_insertion_ind;
+        if (n > 0) {
+          if (str_l < str_m) {
+            size_t avail = str_m-str_l;
+            fast_memcpy(str+str_l, str_arg+zero_padding_insertion_ind,
+                        (n>avail?avail:n));
+          }
+          str_l += n;
+        }
+      }
+   /* insert right padding */
+      if (justify_left) {          /* right blank padding to the field width */
+        int n = min_field_width - (str_arg_l+number_of_zeros_to_pad);
+        if (n > 0) {
+          if (str_l < str_m) {
+            size_t avail = str_m-str_l;
+            fast_memset(str+str_l, ' ', (n>avail?avail:n));
+          }
+          str_l += n;
+        }
+      }
+    }
+  }
+#if defined(NEED_SNPRINTF_ONLY)
+  va_end(ap);
+#endif
+  if (str_m > 0) { /* make sure the string is null-terminated
+                      even at the expense of overwriting the last character
+                      (shouldn't happen, but just in case) */
+    str[str_l <= str_m-1 ? str_l : str_m-1] = '\0';
+  }
+  /* Return the number of characters formatted (excluding trailing null
+   * character), that is, the number of characters that would have been
+   * written to the buffer if it were large enough.
+   *
+   * The value of str_l should be returned, but str_l is of unsigned type
+   * size_t, and snprintf is int, possibly leading to an undetected
+   * integer overflow, resulting in a negative return value, which is illegal.
+   * Both XSH5 and ISO C99 (at least the draft) are silent on this issue.
+   * Should errno be set to EOVERFLOW and EOF returned in this case???
+   */
+  return (int) str_l;
+}
+#endif
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/snprintf_2.2/snprintf.c	Sat Jan 19 19:14:36 2002 +0100
@@ -0,0 +1,1032 @@
+#include <stdarg.h>
+#define NEED_ASPRINTF
+#define NEED_VASPRINTF
+/*
+ * snprintf.c - a portable implementation of snprintf
+ *
+ * AUTHOR
+ *   Mark Martinec <mark.martinec@ijs.si>, April 1999.
+ *
+ *   Copyright 1999, Mark Martinec. All rights reserved.
+ *
+ * TERMS AND CONDITIONS
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the "Frontier Artistic License" which comes
+ *   with this Kit.
+ *
+ *   This program 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 Frontier Artistic License for more details.
+ *
+ *   You should have received a copy of the Frontier Artistic License
+ *   with this Kit in the file named LICENSE.txt .
+ *   If not, I'll be glad to provide one.
+ *
+ * FEATURES
+ * - careful adherence to specs regarding flags, field width and precision;
+ * - good performance for large string handling (large format, large
+ *   argument or large paddings). Performance is similar to system's sprintf
+ *   and in several cases significantly better (make sure you compile with
+ *   optimizations turned on, tell the compiler the code is strict ANSI
+ *   if necessary to give it more freedom for optimizations);
+ * - return value semantics per ISO/IEC 9899:1999 ("ISO C99");
+ * - written in standard ISO/ANSI C - requires an ANSI C compiler.
+ *
+ * SUPPORTED CONVERSION SPECIFIERS AND DATA TYPES
+ *
+ * This snprintf only supports the following conversion specifiers:
+ * s, c, d, u, o, x, X, p  (and synonyms: i, D, U, O - see below)
+ * with flags: '-', '+', ' ', '0' and '#'.
+ * An asterisk is supported for field width as well as precision.
+ *
+ * Length modifiers 'h' (short int), 'l' (long int),
+ * and 'll' (long long int) are supported.
+ * NOTE:
+ *   If macro SNPRINTF_LONGLONG_SUPPORT is not defined (default) the
+ *   length modifier 'll' is recognized but treated the same as 'l',
+ *   which may cause argument value truncation! Defining
+ *   SNPRINTF_LONGLONG_SUPPORT requires that your system's sprintf also
+ *   handles length modifier 'll'.  long long int is a language extension
+ *   which may not be portable.
+ *
+ * Conversion of numeric data (conversion specifiers d, u, o, x, X, p)
+ * with length modifiers (none or h, l, ll) is left to the system routine
+ * sprintf, but all handling of flags, field width and precision as well as
+ * c and s conversions is done very carefully by this portable routine.
+ * If a string precision (truncation) is specified (e.g. %.8s) it is
+ * guaranteed the string beyond the specified precision will not be referenced.
+ *
+ * Length modifiers h, l and ll are ignored for c and s conversions (data
+ * types wint_t and wchar_t are not supported).
+ *
+ * The following common synonyms for conversion characters are supported:
+ *   - i is a synonym for d
+ *   - D is a synonym for ld, explicit length modifiers are ignored
+ *   - U is a synonym for lu, explicit length modifiers are ignored
+ *   - O is a synonym for lo, explicit length modifiers are ignored
+ * The D, O and U conversion characters are nonstandard, they are supported
+ * for backward compatibility only, and should not be used for new code.
+ *
+ * The following is specifically NOT supported:
+ *   - flag ' (thousands' grouping character) is recognized but ignored
+ *   - numeric conversion specifiers: f, e, E, g, G and synonym F,
+ *     as well as the new a and A conversion specifiers
+ *   - length modifier 'L' (long double) and 'q' (quad - use 'll' instead)
+ *   - wide character/string conversions: lc, ls, and nonstandard
+ *     synonyms C and S
+ *   - writeback of converted string length: conversion character n
+ *   - the n$ specification for direct reference to n-th argument
+ *   - locales
+ *
+ * It is permitted for str_m to be zero, and it is permitted to specify NULL
+ * pointer for resulting string argument if str_m is zero (as per ISO C99).
+ *
+ * The return value is the number of characters which would be generated
+ * for the given input, excluding the trailing null. If this value
+ * is greater or equal to str_m, not all characters from the result
+ * have been stored in str, output bytes beyond the (str_m-1) -th character
+ * are discarded. If str_m is greater than zero it is guaranteed
+ * the resulting string will be null-terminated.
+ *
+ * NOTE that this matches the ISO C99, OpenBSD, and GNU C library 2.1,
+ * but is different from some older and vendor implementations,
+ * and is also different from XPG, XSH5, SUSv2 specifications.
+ * For historical discussion on changes in the semantics and standards
+ * of snprintf see printf(3) man page in the Linux programmers manual.
+ *
+ * Routines asprintf and vasprintf return a pointer (in the ptr argument)
+ * to a buffer sufficiently large to hold the resulting string. This pointer
+ * should be passed to free(3) to release the allocated storage when it is
+ * no longer needed. If sufficient space cannot be allocated, these functions
+ * will return -1 and set ptr to be a NULL pointer. These two routines are a
+ * GNU C library extensions (glibc).
+ *
+ * Routines asnprintf and vasnprintf are similar to asprintf and vasprintf,
+ * yet, like snprintf and vsnprintf counterparts, will write at most str_m-1
+ * characters into the allocated output string, the last character in the
+ * allocated buffer then gets the terminating null. If the formatted string
+ * length (the return value) is greater than or equal to the str_m argument,
+ * the resulting string was truncated and some of the formatted characters
+ * were discarded. These routines present a handy way to limit the amount
+ * of allocated memory to some sane value.
+ *
+ * AVAILABILITY
+ *   http://www.ijs.si/software/snprintf/
+ *
+ * REVISION HISTORY
+ * 1999-04	V0.9  Mark Martinec
+ *		- initial version, some modifications after comparing printf
+ *		  man pages for Digital Unix 4.0, Solaris 2.6 and HPUX 10,
+ *		  and checking how Perl handles sprintf (differently!);
+ * 1999-04-09	V1.0  Mark Martinec <mark.martinec@ijs.si>
+ *		- added main test program, fixed remaining inconsistencies,
+ *		  added optional (long long int) support;
+ * 1999-04-12	V1.1  Mark Martinec <mark.martinec@ijs.si>
+ *		- support the 'p' conversion (pointer to void);
+ *		- if a string precision is specified
+ *		  make sure the string beyond the specified precision
+ *		  will not be referenced (e.g. by strlen);
+ * 1999-04-13	V1.2  Mark Martinec <mark.martinec@ijs.si>
+ *		- support synonyms %D=%ld, %U=%lu, %O=%lo;
+ *		- speed up the case of long format string with few conversions;
+ * 1999-06-30	V1.3  Mark Martinec <mark.martinec@ijs.si>
+ *		- fixed runaway loop (eventually crashing when str_l wraps
+ *		  beyond 2^31) while copying format string without
+ *		  conversion specifiers to a buffer that is too short
+ *		  (thanks to Edwin Young <edwiny@autonomy.com> for
+ *		  spotting the problem);
+ *		- added macros PORTABLE_SNPRINTF_VERSION_(MAJOR|MINOR)
+ *		  to snprintf.h
+ * 2000-02-14	V2.0 (never released) Mark Martinec <mark.martinec@ijs.si>
+ *		- relaxed license terms: The Artistic License now applies.
+ *		  You may still apply the GNU GENERAL PUBLIC LICENSE
+ *		  as was distributed with previous versions, if you prefer;
+ *		- changed REVISION HISTORY dates to use ISO 8601 date format;
+ *		- added vsnprintf (patch also independently proposed by
+ *		  Caolan McNamara 2000-05-04, and Keith M Willenson 2000-06-01)
+ * 2000-06-27	V2.1  Mark Martinec <mark.martinec@ijs.si>
+ *		- removed POSIX check for str_m<1; value 0 for str_m is
+ *		  allowed by ISO C99 (and GNU C library 2.1) - (pointed out
+ *		  on 2000-05-04 by Caolan McNamara, caolan@ csn dot ul dot ie).
+ *		  Besides relaxed license this change in standards adherence
+ *		  is the main reason to bump up the major version number;
+ *		- added nonstandard routines asnprintf, vasnprintf, asprintf,
+ *		  vasprintf that dynamically allocate storage for the
+ *		  resulting string; these routines are not compiled by default,
+ *		  see comments where NEED_V?ASN?PRINTF macros are defined;
+ *		- autoconf contributed by Caolan McNamara
+ * 2000-10-06	V2.2  Mark Martinec <mark.martinec@ijs.si>
+ *		- BUG FIX: the %c conversion used a temporary variable
+ *		  that was no longer in scope when referenced,
+ *		  possibly causing incorrect resulting character;
+ *		- BUG FIX: make precision and minimal field width unsigned
+ *		  to handle huge values (2^31 <= n < 2^32) correctly;
+ *		  also be more careful in the use of signed/unsigned/size_t
+ *		  internal variables - probably more careful than many
+ *		  vendor implementations, but there may still be a case
+ *		  where huge values of str_m, precision or minimal field
+ *		  could cause incorrect behaviour;
+ *		- use separate variables for signed/unsigned arguments,
+ *		  and for short/int, long, and long long argument lengths
+ *		  to avoid possible incompatibilities on certain
+ *		  computer architectures. Also use separate variable
+ *		  arg_sign to hold sign of a numeric argument,
+ *		  to make code more transparent;
+ *		- some fiddling with zero padding and "0x" to make it
+ *		  Linux compatible;
+ *		- systematically use macros fast_memcpy and fast_memset
+ *		  instead of case-by-case hand optimization; determine some
+ *		  breakeven string lengths for different architectures;
+ *		- terminology change: 'format' -> 'conversion specifier',
+ *		  'C9x' -> 'ISO/IEC 9899:1999 ("ISO C99")',
+ *		  'alternative form' -> 'alternate form',
+ *		  'data type modifier' -> 'length modifier';
+ *		- several comments rephrased and new ones added;
+ *		- make compiler not complain about 'credits' defined but
+ *		  not used;
+ */
+
+
+/* Define HAVE_SNPRINTF if your system already has snprintf and vsnprintf.
+ *
+ * If HAVE_SNPRINTF is defined this module will not produce code for
+ * snprintf and vsnprintf, unless PREFER_PORTABLE_SNPRINTF is defined as well,
+ * causing this portable version of snprintf to be called portable_snprintf
+ * (and portable_vsnprintf).
+ */
+/* #define HAVE_SNPRINTF */
+
+/* Define PREFER_PORTABLE_SNPRINTF if your system does have snprintf and
+ * vsnprintf but you would prefer to use the portable routine(s) instead.
+ * In this case the portable routine is declared as portable_snprintf
+ * (and portable_vsnprintf) and a macro 'snprintf' (and 'vsnprintf')
+ * is defined to expand to 'portable_v?snprintf' - see file snprintf.h .
+ * Defining this macro is only useful if HAVE_SNPRINTF is also defined,
+ * but does does no harm if defined nevertheless.
+ */
+/* #define PREFER_PORTABLE_SNPRINTF */
+
+/* Define SNPRINTF_LONGLONG_SUPPORT if you want to support
+ * data type (long long int) and length modifier 'll' (e.g. %lld).
+ * If undefined, 'll' is recognized but treated as a single 'l'.
+ *
+ * If the system's sprintf does not handle 'll'
+ * the SNPRINTF_LONGLONG_SUPPORT must not be defined!
+ *
+ * This is off by default as (long long int) is a language extension.
+ */
+/* #define SNPRINTF_LONGLONG_SUPPORT */
+
+/* Define NEED_SNPRINTF_ONLY if you only need snprintf, and not vsnprintf.
+ * If NEED_SNPRINTF_ONLY is defined, the snprintf will be defined directly,
+ * otherwise both snprintf and vsnprintf routines will be defined
+ * and snprintf will be a simple wrapper around vsnprintf, at the expense
+ * of an extra procedure call.
+ */
+/* #define NEED_SNPRINTF_ONLY */
+
+/* Define NEED_V?ASN?PRINTF macros if you need library extension
+ * routines asprintf, vasprintf, asnprintf, vasnprintf respectively,
+ * and your system library does not provide them. They are all small
+ * wrapper routines around portable_vsnprintf. Defining any of the four
+ * NEED_V?ASN?PRINTF macros automatically turns off NEED_SNPRINTF_ONLY
+ * and turns on PREFER_PORTABLE_SNPRINTF.
+ *
+ * Watch for name conflicts with the system library if these routines
+ * are already present there.
+ *
+ * NOTE: vasprintf and vasnprintf routines need va_copy() from stdarg.h, as
+ * specified by C99, to be able to traverse the same list of arguments twice.
+ * I don't know of any other standard and portable way of achieving the same.
+ * With some versions of gcc you may use __va_copy(). You might even get away
+ * with "ap2 = ap", in this case you must not call va_end(ap2) !
+ *   #define va_copy(ap2,ap) ap2 = ap
+ */
+#ifndef va_copy
+#define va_copy(ap2,ap) ap2 = ap 
+#endif
+
+/* #define NEED_ASPRINTF   */
+/* #define NEED_ASNPRINTF  */
+/* #define NEED_VASPRINTF  */
+/* #define NEED_VASNPRINTF */
+
+
+/* Define the following macros if desired:
+ *   SOLARIS_COMPATIBLE, SOLARIS_BUG_COMPATIBLE,
+ *   HPUX_COMPATIBLE, HPUX_BUG_COMPATIBLE, LINUX_COMPATIBLE,
+ *   DIGITAL_UNIX_COMPATIBLE, DIGITAL_UNIX_BUG_COMPATIBLE,
+ *   PERL_COMPATIBLE, PERL_BUG_COMPATIBLE,
+ *
+ * - For portable applications it is best not to rely on peculiarities
+ *   of a given implementation so it may be best not to define any
+ *   of the macros that select compatibility and to avoid features
+ *   that vary among the systems.
+ *
+ * - Selecting compatibility with more than one operating system
+ *   is not strictly forbidden but is not recommended.
+ *
+ * - 'x'_BUG_COMPATIBLE implies 'x'_COMPATIBLE .
+ *
+ * - 'x'_COMPATIBLE refers to (and enables) a behaviour that is
+ *   documented in a sprintf man page on a given operating system
+ *   and actually adhered to by the system's sprintf (but not on
+ *   most other operating systems). It may also refer to and enable
+ *   a behaviour that is declared 'undefined' or 'implementation specific'
+ *   in the man page but a given implementation behaves predictably
+ *   in a certain way.
+ *
+ * - 'x'_BUG_COMPATIBLE refers to (and enables) a behaviour of system's sprintf
+ *   that contradicts the sprintf man page on the same operating system.
+ *
+ * - I do not claim that the 'x'_COMPATIBLE and 'x'_BUG_COMPATIBLE
+ *   conditionals take into account all idiosyncrasies of a particular
+ *   implementation, there may be other incompatibilities.
+ */
+
+
+
+/* ============================================= */
+/* NO USER SERVICABLE PARTS FOLLOWING THIS POINT */
+/* ============================================= */
+
+#define PORTABLE_SNPRINTF_VERSION_MAJOR 2
+#define PORTABLE_SNPRINTF_VERSION_MINOR 2
+
+#if defined(NEED_ASPRINTF) || defined(NEED_ASNPRINTF) || defined(NEED_VASPRINTF) || defined(NEED_VASNPRINTF)
+# if defined(NEED_SNPRINTF_ONLY)
+# undef NEED_SNPRINTF_ONLY
+# endif
+# if !defined(PREFER_PORTABLE_SNPRINTF)
+# define PREFER_PORTABLE_SNPRINTF
+# endif
+#endif
+
+#if defined(SOLARIS_BUG_COMPATIBLE) && !defined(SOLARIS_COMPATIBLE)
+#define SOLARIS_COMPATIBLE
+#endif
+
+#if defined(HPUX_BUG_COMPATIBLE) && !defined(HPUX_COMPATIBLE)
+#define HPUX_COMPATIBLE
+#endif
+
+#if defined(DIGITAL_UNIX_BUG_COMPATIBLE) && !defined(DIGITAL_UNIX_COMPATIBLE)
+#define DIGITAL_UNIX_COMPATIBLE
+#endif
+
+#if defined(PERL_BUG_COMPATIBLE) && !defined(PERL_COMPATIBLE)
+#define PERL_COMPATIBLE
+#endif
+
+#if defined(LINUX_BUG_COMPATIBLE) && !defined(LINUX_COMPATIBLE)
+#define LINUX_COMPATIBLE
+#endif
+
+#include <sys/types.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <errno.h>
+
+#ifdef isdigit
+#undef isdigit
+#endif
+#define isdigit(c) ((c) >= '0' && (c) <= '9')
+
+/* For copying strings longer or equal to 'breakeven_point'
+ * it is more efficient to call memcpy() than to do it inline.
+ * The value depends mostly on the processor architecture,
+ * but also on the compiler and its optimization capabilities.
+ * The value is not critical, some small value greater than zero
+ * will be just fine if you don't care to squeeze every drop
+ * of performance out of the code.
+ *
+ * Small values favor memcpy, large values favor inline code.
+ */
+#if defined(__alpha__) || defined(__alpha)
+#  define breakeven_point   2	/* AXP (DEC Alpha)     - gcc or cc or egcs */
+#endif
+#if defined(__i386__)  || defined(__i386)
+#  define breakeven_point  12	/* Intel Pentium/Linux - gcc 2.96 */
+#endif
+#if defined(__hppa)
+#  define breakeven_point  10	/* HP-PA               - gcc */
+#endif
+#if defined(__sparc__) || defined(__sparc)
+#  define breakeven_point  33	/* Sun Sparc 5         - gcc 2.8.1 */
+#endif
+
+/* some other values of possible interest: */
+/* #define breakeven_point  8 */  /* VAX 4000          - vaxc */
+/* #define breakeven_point 19 */  /* VAX 4000          - gcc 2.7.0 */
+
+#ifndef breakeven_point
+#  define breakeven_point   6	/* some reasonable one-size-fits-all value */
+#endif
+
+#define fast_memcpy(d,s,n) \
+  { register size_t nn = (size_t)(n); \
+    if (nn >= breakeven_point) memcpy((d), (s), nn); \
+    else if (nn > 0) { /* proc call overhead is worth only for large strings*/\
+      register char *dd; register const char *ss; \
+      for (ss=(s), dd=(d); nn>0; nn--) *dd++ = *ss++; } }
+
+#define fast_memset(d,c,n) \
+  { register size_t nn = (size_t)(n); \
+    if (nn >= breakeven_point) memset((d), (int)(c), nn); \
+    else if (nn > 0) { /* proc call overhead is worth only for large strings*/\
+      register char *dd; register const int cc=(int)(c); \
+      for (dd=(d); nn>0; nn--) *dd++ = cc; } }
+
+/* prototypes */
+
+#if defined(NEED_ASPRINTF)
+int asprintf   (char **ptr, const char *fmt, /*args*/ ...);
+#endif
+#if defined(NEED_VASPRINTF)
+int vasprintf  (char **ptr, const char *fmt, va_list ap);
+#endif
+#if defined(NEED_ASNPRINTF)
+int asnprintf  (char **ptr, size_t str_m, const char *fmt, /*args*/ ...);
+#endif
+#if defined(NEED_VASNPRINTF)
+int vasnprintf (char **ptr, size_t str_m, const char *fmt, va_list ap);
+#endif
+
+#if defined(HAVE_SNPRINTF)
+/* declare our portable snprintf  routine under name portable_snprintf  */
+/* declare our portable vsnprintf routine under name portable_vsnprintf */
+#else
+/* declare our portable routines under names snprintf and vsnprintf */
+#define portable_snprintf snprintf
+#if !defined(NEED_SNPRINTF_ONLY)
+#define portable_vsnprintf vsnprintf
+#endif
+#endif
+
+#if !defined(HAVE_SNPRINTF) || defined(PREFER_PORTABLE_SNPRINTF)
+int portable_snprintf(char *str, size_t str_m, const char *fmt, /*args*/ ...);
+#if !defined(NEED_SNPRINTF_ONLY)
+int portable_vsnprintf(char *str, size_t str_m, const char *fmt, va_list ap);
+#endif
+#endif
+
+/* declarations */
+
+static char credits[] = "\n\
+@(#)snprintf.c, v2.2: Mark Martinec, <mark.martinec@ijs.si>\n\
+@(#)snprintf.c, v2.2: Copyright 1999, Mark Martinec. Frontier Artistic License applies.\n\
+@(#)snprintf.c, v2.2: http://www.ijs.si/software/snprintf/\n";
+
+#if defined(NEED_ASPRINTF)
+int asprintf(char **ptr, const char *fmt, /*args*/ ...) {
+  va_list ap;
+  size_t str_m;
+  int str_l;
+
+  *ptr = NULL;
+  va_start(ap, fmt);                            /* measure the required size */
+  str_l = portable_vsnprintf(NULL, (size_t)0, fmt, ap);
+  va_end(ap);
+  assert(str_l >= 0);        /* possible integer overflow if str_m > INT_MAX */
+  *ptr = (char *) malloc(str_m = (size_t)str_l + 1);
+  if (*ptr == NULL) { errno = ENOMEM; str_l = -1; }
+  else {
+    int str_l2;
+    va_start(ap, fmt);
+    str_l2 = portable_vsnprintf(*ptr, str_m, fmt, ap);
+    va_end(ap);
+    assert(str_l2 == str_l);
+  }
+  return str_l;
+}
+#endif
+
+#if defined(NEED_VASPRINTF)
+int vasprintf(char **ptr, const char *fmt, va_list ap) {
+  size_t str_m;
+  int str_l;
+
+  *ptr = NULL;
+  { va_list ap2;
+    va_copy(ap2, ap);  /* don't consume the original ap, we'll need it again */
+    str_l = portable_vsnprintf(NULL, (size_t)0, fmt, ap2);/*get required size*/
+    va_end(ap2);
+  }
+  assert(str_l >= 0);        /* possible integer overflow if str_m > INT_MAX */
+  *ptr = (char *) malloc(str_m = (size_t)str_l + 1);
+  if (*ptr == NULL) { errno = ENOMEM; str_l = -1; }
+  else {
+    int str_l2 = portable_vsnprintf(*ptr, str_m, fmt, ap);
+    assert(str_l2 == str_l);
+  }
+  return str_l;
+}
+#endif
+
+#if defined(NEED_ASNPRINTF)
+int asnprintf (char **ptr, size_t str_m, const char *fmt, /*args*/ ...) {
+  va_list ap;
+  int str_l;
+
+  *ptr = NULL;
+  va_start(ap, fmt);                            /* measure the required size */
+  str_l = portable_vsnprintf(NULL, (size_t)0, fmt, ap);
+  va_end(ap);
+  assert(str_l >= 0);        /* possible integer overflow if str_m > INT_MAX */
+  if ((size_t)str_l + 1 < str_m) str_m = (size_t)str_l + 1;      /* truncate */
+  /* if str_m is 0, no buffer is allocated, just set *ptr to NULL */
+  if (str_m == 0) {  /* not interested in resulting string, just return size */
+  } else {
+    *ptr = (char *) malloc(str_m);
+    if (*ptr == NULL) { errno = ENOMEM; str_l = -1; }
+    else {
+      int str_l2;
+      va_start(ap, fmt);
+      str_l2 = portable_vsnprintf(*ptr, str_m, fmt, ap);
+      va_end(ap);
+      assert(str_l2 == str_l);
+    }
+  }
+  return str_l;
+}
+#endif
+
+#if defined(NEED_VASNPRINTF)
+int vasnprintf (char **ptr, size_t str_m, const char *fmt, va_list ap) {
+  int str_l;
+
+  *ptr = NULL;
+  { va_list ap2;
+    va_copy(ap2, ap);  /* don't consume the original ap, we'll need it again */
+    str_l = portable_vsnprintf(NULL, (size_t)0, fmt, ap2);/*get required size*/
+    va_end(ap2);
+  }
+  assert(str_l >= 0);        /* possible integer overflow if str_m > INT_MAX */
+  if ((size_t)str_l + 1 < str_m) str_m = (size_t)str_l + 1;      /* truncate */
+  /* if str_m is 0, no buffer is allocated, just set *ptr to NULL */
+  if (str_m == 0) {  /* not interested in resulting string, just return size */
+  } else {
+    *ptr = (char *) malloc(str_m);
+    if (*ptr == NULL) { errno = ENOMEM; str_l = -1; }
+    else {
+      int str_l2 = portable_vsnprintf(*ptr, str_m, fmt, ap);
+      assert(str_l2 == str_l);
+    }
+  }
+  return str_l;
+}
+#endif
+
+/*
+ * If the system does have snprintf and the portable routine is not
+ * specifically required, this module produces no code for snprintf/vsnprintf.
+ */
+#if !defined(HAVE_SNPRINTF) || defined(PREFER_PORTABLE_SNPRINTF)
+
+#if !defined(NEED_SNPRINTF_ONLY)
+int portable_snprintf(char *str, size_t str_m, const char *fmt, /*args*/ ...) {
+  va_list ap;
+  int str_l;
+
+  va_start(ap, fmt);
+  str_l = portable_vsnprintf(str, str_m, fmt, ap);
+  va_end(ap);
+  return str_l;
+}
+#endif
+
+#if defined(NEED_SNPRINTF_ONLY)
+int portable_snprintf(char *str, size_t str_m, const char *fmt, /*args*/ ...) {
+#else
+int portable_vsnprintf(char *str, size_t str_m, const char *fmt, va_list ap) {
+#endif
+
+#if defined(NEED_SNPRINTF_ONLY)
+  va_list ap;
+#endif
+  size_t str_l = 0;
+  const char *p = fmt;
+
+/* In contrast with POSIX, the ISO C99 now says
+ * that str can be NULL and str_m can be 0.
+ * This is more useful than the old:  if (str_m < 1) return -1; */
+
+#if defined(NEED_SNPRINTF_ONLY)
+  va_start(ap, fmt);
+#endif
+  if (!p) p = "";
+  while (*p) {
+    if (*p != '%') {
+   /* if (str_l < str_m) str[str_l++] = *p++;    -- this would be sufficient */
+   /* but the following code achieves better performance for cases
+    * where format string is long and contains few conversions */
+      const char *q = strchr(p+1,'%');
+      size_t n = !q ? strlen(p) : (q-p);
+      if (str_l < str_m) {
+        size_t avail = str_m-str_l;
+        fast_memcpy(str+str_l, p, (n>avail?avail:n));
+      }
+      p += n; str_l += n;
+    } else {
+      const char *starting_p;
+      size_t min_field_width = 0, precision = 0;
+      int zero_padding = 0, precision_specified = 0, justify_left = 0;
+      int alternate_form = 0, force_sign = 0;
+      int space_for_positive = 1; /* If both the ' ' and '+' flags appear,
+                                     the ' ' flag should be ignored. */
+      char length_modifier = '\0';            /* allowed values: \0, h, l, L */
+      char tmp[32];/* temporary buffer for simple numeric->string conversion */
+
+      const char *str_arg;      /* string address in case of string argument */
+      size_t str_arg_l;         /* natural field width of arg without padding
+                                   and sign */
+      unsigned char uchar_arg;
+        /* unsigned char argument value - only defined for c conversion.
+           N.B. standard explicitly states the char argument for
+           the c conversion is unsigned */
+
+      size_t number_of_zeros_to_pad = 0;
+        /* number of zeros to be inserted for numeric conversions
+           as required by the precision or minimal field width */
+
+      size_t zero_padding_insertion_ind = 0;
+        /* index into tmp where zero padding is to be inserted */
+
+      char fmt_spec = '\0';
+        /* current conversion specifier character */
+
+      str_arg = credits;/* just to make compiler happy (defined but not used)*/
+      str_arg = NULL;
+      starting_p = p; p++;  /* skip '%' */
+   /* parse flags */
+      while (*p == '0' || *p == '-' || *p == '+' ||
+             *p == ' ' || *p == '#' || *p == '\'') {
+        switch (*p) {
+        case '0': zero_padding = 1; break;
+        case '-': justify_left = 1; break;
+        case '+': force_sign = 1; space_for_positive = 0; break;
+        case ' ': force_sign = 1;
+     /* If both the ' ' and '+' flags appear, the ' ' flag should be ignored */
+#ifdef PERL_COMPATIBLE
+     /* ... but in Perl the last of ' ' and '+' applies */
+                  space_for_positive = 1;
+#endif
+                  break;
+        case '#': alternate_form = 1; break;
+        case '\'': break;
+        }
+        p++;
+      }
+   /* If the '0' and '-' flags both appear, the '0' flag should be ignored. */
+
+   /* parse field width */
+      if (*p == '*') {
+        int j;
+        p++; j = va_arg(ap, int);
+        if (j >= 0) min_field_width = j;
+        else { min_field_width = -j; justify_left = 1; }
+      } else if (isdigit((int)(*p))) {
+        /* size_t could be wider than unsigned int;
+           make sure we treat argument like common implementations do */
+        unsigned int uj = *p++ - '0';
+        while (isdigit((int)(*p))) uj = 10*uj + (unsigned int)(*p++ - '0');
+        min_field_width = uj;
+      }
+   /* parse precision */
+      if (*p == '.') {
+        p++; precision_specified = 1;
+        if (*p == '*') {
+          int j = va_arg(ap, int);
+          p++;
+          if (j >= 0) precision = j;
+          else {
+            precision_specified = 0; precision = 0;
+         /* NOTE:
+          *   Solaris 2.6 man page claims that in this case the precision
+          *   should be set to 0.  Digital Unix 4.0, HPUX 10 and BSD man page
+          *   claim that this case should be treated as unspecified precision,
+          *   which is what we do here.
+          */
+          }
+        } else if (isdigit((int)(*p))) {
+          /* size_t could be wider than unsigned int;
+             make sure we treat argument like common implementations do */
+          unsigned int uj = *p++ - '0';
+          while (isdigit((int)(*p))) uj = 10*uj + (unsigned int)(*p++ - '0');
+          precision = uj;
+        }
+      }
+   /* parse 'h', 'l' and 'll' length modifiers */
+      if (*p == 'h' || *p == 'l') {
+        length_modifier = *p; p++;
+        if (length_modifier == 'l' && *p == 'l') {   /* double l = long long */
+#ifdef SNPRINTF_LONGLONG_SUPPORT
+          length_modifier = '2';                  /* double l encoded as '2' */
+#else
+          length_modifier = 'l';                 /* treat it as a single 'l' */
+#endif
+          p++;
+        }
+      }
+      fmt_spec = *p;
+   /* common synonyms: */
+      switch (fmt_spec) {
+      case 'i': fmt_spec = 'd'; break;
+      case 'D': fmt_spec = 'd'; length_modifier = 'l'; break;
+      case 'U': fmt_spec = 'u'; length_modifier = 'l'; break;
+      case 'O': fmt_spec = 'o'; length_modifier = 'l'; break;
+      default: break;
+      }
+   /* get parameter value, do initial processing */
+      switch (fmt_spec) {
+      case '%': /* % behaves similar to 's' regarding flags and field widths */
+      case 'c': /* c behaves similar to 's' regarding flags and field widths */
+      case 's':
+        length_modifier = '\0';          /* wint_t and wchar_t not supported */
+     /* the result of zero padding flag with non-numeric conversion specifier*/
+     /* is undefined. Solaris and HPUX 10 does zero padding in this case,    */
+     /* Digital Unix and Linux does not. */
+#if !defined(SOLARIS_COMPATIBLE) && !defined(HPUX_COMPATIBLE)
+        zero_padding = 0;    /* turn zero padding off for string conversions */
+#endif
+        str_arg_l = 1;
+        switch (fmt_spec) {
+        case '%':
+          str_arg = p; break;
+        case 'c': {
+          int j = va_arg(ap, int);
+          uchar_arg = (unsigned char) j;   /* standard demands unsigned char */
+          str_arg = (const char *) &uchar_arg;
+          break;
+        }
+        case 's':
+          str_arg = va_arg(ap, const char *);
+          if (!str_arg) str_arg_l = 0;
+       /* make sure not to address string beyond the specified precision !!! */
+          else if (!precision_specified) str_arg_l = strlen(str_arg);
+       /* truncate string if necessary as requested by precision */
+          else if (precision == 0) str_arg_l = 0;
+          else {
+       /* memchr on HP does not like n > 2^31  !!! */
+            const char *q = memchr(str_arg, '\0',
+                             precision <= 0x7fffffff ? precision : 0x7fffffff);
+            str_arg_l = !q ? precision : (q-str_arg);
+          }
+          break;
+        default: break;
+        }
+        break;
+      case 'd': case 'u': case 'o': case 'x': case 'X': case 'p': {
+        /* NOTE: the u, o, x, X and p conversion specifiers imply
+                 the value is unsigned;  d implies a signed value */
+
+        int arg_sign = 0;
+          /* 0 if numeric argument is zero (or if pointer is NULL for 'p'),
+            +1 if greater than zero (or nonzero for unsigned arguments),
+            -1 if negative (unsigned argument is never negative) */
+
+        int int_arg = 0;  unsigned int uint_arg = 0;
+          /* only defined for length modifier h, or for no length modifiers */
+
+        long int long_arg = 0;  unsigned long int ulong_arg = 0;
+          /* only defined for length modifier l */
+
+        void *ptr_arg = NULL;
+          /* pointer argument value -only defined for p conversion */
+
+#ifdef SNPRINTF_LONGLONG_SUPPORT
+        long long int long_long_arg = 0;
+        unsigned long long int ulong_long_arg = 0;
+          /* only defined for length modifier ll */
+#endif
+        if (fmt_spec == 'p') {
+        /* HPUX 10: An l, h, ll or L before any other conversion character
+         *   (other than d, i, u, o, x, or X) is ignored.
+         * Digital Unix:
+         *   not specified, but seems to behave as HPUX does.
+         * Solaris: If an h, l, or L appears before any other conversion
+         *   specifier (other than d, i, u, o, x, or X), the behavior
+         *   is undefined. (Actually %hp converts only 16-bits of address
+         *   and %llp treats address as 64-bit data which is incompatible
+         *   with (void *) argument on a 32-bit system).
+         */
+#ifdef SOLARIS_COMPATIBLE
+#  ifdef SOLARIS_BUG_COMPATIBLE
+          /* keep length modifiers even if it represents 'll' */
+#  else
+          if (length_modifier == '2') length_modifier = '\0';
+#  endif
+#else
+          length_modifier = '\0';
+#endif
+          ptr_arg = va_arg(ap, void *);
+          if (ptr_arg != NULL) arg_sign = 1;
+        } else if (fmt_spec == 'd') {  /* signed */
+          switch (length_modifier) {
+          case '\0':
+          case 'h':
+         /* It is non-portable to specify a second argument of char or short
+          * to va_arg, because arguments seen by the called function
+          * are not char or short.  C converts char and short arguments
+          * to int before passing them to a function.
+          */
+            int_arg = va_arg(ap, int);
+            if      (int_arg > 0) arg_sign =  1;
+            else if (int_arg < 0) arg_sign = -1;
+            break;
+          case 'l':
+            long_arg = va_arg(ap, long int);
+            if      (long_arg > 0) arg_sign =  1;
+            else if (long_arg < 0) arg_sign = -1;
+            break;
+#ifdef SNPRINTF_LONGLONG_SUPPORT
+          case '2':
+            long_long_arg = va_arg(ap, long long int);
+            if      (long_long_arg > 0) arg_sign =  1;
+            else if (long_long_arg < 0) arg_sign = -1;
+            break;
+#endif
+          }
+        } else {  /* unsigned */
+          switch (length_modifier) {
+          case '\0':
+          case 'h':
+            uint_arg = va_arg(ap, unsigned int);
+            if (uint_arg) arg_sign = 1;
+            break;
+          case 'l':
+            ulong_arg = va_arg(ap, unsigned long int);
+            if (ulong_arg) arg_sign = 1;
+            break;
+#ifdef SNPRINTF_LONGLONG_SUPPORT
+          case '2':
+            ulong_long_arg = va_arg(ap, unsigned long long int);
+            if (ulong_long_arg) arg_sign = 1;
+            break;
+#endif
+          }
+        }
+        str_arg = tmp; str_arg_l = 0;
+     /* NOTE:
+      *   For d, i, u, o, x, and X conversions, if precision is specified,
+      *   the '0' flag should be ignored. This is so with Solaris 2.6,
+      *   Digital UNIX 4.0, HPUX 10, Linux, FreeBSD, NetBSD; but not with Perl.
+      */
+#ifndef PERL_COMPATIBLE
+        if (precision_specified) zero_padding = 0;
+#endif
+        if (fmt_spec == 'd') {
+          if (force_sign && arg_sign >= 0)
+            tmp[str_arg_l++] = space_for_positive ? ' ' : '+';
+         /* leave negative numbers for sprintf to handle,
+            to avoid handling tricky cases like (short int)(-32768) */
+#ifdef LINUX_COMPATIBLE
+        } else if (fmt_spec == 'p' && force_sign && arg_sign > 0) {
+          tmp[str_arg_l++] = space_for_positive ? ' ' : '+';
+#endif
+        } else if (alternate_form) {
+          if (arg_sign != 0 && (fmt_spec == 'x' || fmt_spec == 'X') )
+            { tmp[str_arg_l++] = '0'; tmp[str_arg_l++] = fmt_spec; }
+         /* alternate form should have no effect for p conversion, but ... */
+#ifdef HPUX_COMPATIBLE
+          else if (fmt_spec == 'p'
+         /* HPUX 10: for an alternate form of p conversion,
+          *          a nonzero result is prefixed by 0x. */
+#ifndef HPUX_BUG_COMPATIBLE
+         /* Actually it uses 0x prefix even for a zero value. */
+                   && arg_sign != 0
+#endif
+                  ) { tmp[str_arg_l++] = '0'; tmp[str_arg_l++] = 'x'; }
+#endif
+        }
+        zero_padding_insertion_ind = str_arg_l;
+        if (!precision_specified) precision = 1;   /* default precision is 1 */
+        if (precision == 0 && arg_sign == 0
+#if defined(HPUX_BUG_COMPATIBLE) || defined(LINUX_COMPATIBLE)
+            && fmt_spec != 'p'
+         /* HPUX 10 man page claims: With conversion character p the result of
+          * converting a zero value with a precision of zero is a null string.
+          * Actually HP returns all zeroes, and Linux returns "(nil)". */
+#endif
+        ) {
+         /* converted to null string */
+         /* When zero value is formatted with an explicit precision 0,
+            the resulting formatted string is empty (d, i, u, o, x, X, p).   */
+        } else {
+          char f[5]; int f_l = 0;
+          f[f_l++] = '%';    /* construct a simple format string for sprintf */
+          if (!length_modifier) { }
+          else if (length_modifier=='2') { f[f_l++] = 'l'; f[f_l++] = 'l'; }
+          else f[f_l++] = length_modifier;
+          f[f_l++] = fmt_spec; f[f_l++] = '\0';
+          if (fmt_spec == 'p') str_arg_l += sprintf(tmp+str_arg_l, f, ptr_arg);
+          else if (fmt_spec == 'd') {  /* signed */
+            switch (length_modifier) {
+            case '\0':
+            case 'h': str_arg_l+=sprintf(tmp+str_arg_l, f, int_arg);  break;
+            case 'l': str_arg_l+=sprintf(tmp+str_arg_l, f, long_arg); break;
+#ifdef SNPRINTF_LONGLONG_SUPPORT
+            case '2': str_arg_l+=sprintf(tmp+str_arg_l,f,long_long_arg); break;
+#endif
+            }
+          } else {  /* unsigned */
+            switch (length_modifier) {
+            case '\0':
+            case 'h': str_arg_l+=sprintf(tmp+str_arg_l, f, uint_arg);  break;
+            case 'l': str_arg_l+=sprintf(tmp+str_arg_l, f, ulong_arg); break;
+#ifdef SNPRINTF_LONGLONG_SUPPORT
+            case '2': str_arg_l+=sprintf(tmp+str_arg_l,f,ulong_long_arg);break;
+#endif
+            }
+          }
+         /* include the optional minus sign and possible "0x"
+            in the region before the zero padding insertion point */
+          if (zero_padding_insertion_ind < str_arg_l &&
+              tmp[zero_padding_insertion_ind] == '-') {
+            zero_padding_insertion_ind++;
+          }
+          if (zero_padding_insertion_ind+1 < str_arg_l &&
+              tmp[zero_padding_insertion_ind]   == '0' &&
+             (tmp[zero_padding_insertion_ind+1] == 'x' ||
+              tmp[zero_padding_insertion_ind+1] == 'X') ) {
+            zero_padding_insertion_ind += 2;
+          }
+        }
+        { size_t num_of_digits = str_arg_l - zero_padding_insertion_ind;
+          if (alternate_form && fmt_spec == 'o'
+#ifdef HPUX_COMPATIBLE                                  /* ("%#.o",0) -> ""  */
+              && (str_arg_l > 0)
+#endif
+#ifdef DIGITAL_UNIX_BUG_COMPATIBLE                      /* ("%#o",0) -> "00" */
+#else
+              /* unless zero is already the first character */
+              && !(zero_padding_insertion_ind < str_arg_l
+                   && tmp[zero_padding_insertion_ind] == '0')
+#endif
+          ) {        /* assure leading zero for alternate-form octal numbers */
+            if (!precision_specified || precision < num_of_digits+1) {
+             /* precision is increased to force the first character to be zero,
+                except if a zero value is formatted with an explicit precision
+                of zero */
+              precision = num_of_digits+1; precision_specified = 1;
+            }
+          }
+       /* zero padding to specified precision? */
+          if (num_of_digits < precision) 
+            number_of_zeros_to_pad = precision - num_of_digits;
+        }
+     /* zero padding to specified minimal field width? */
+        if (!justify_left && zero_padding) {
+          int n = min_field_width - (str_arg_l+number_of_zeros_to_pad);
+          if (n > 0) number_of_zeros_to_pad += n;
+        }
+        break;
+      }
+      default: /* unrecognized conversion specifier, keep format string as-is*/
+        zero_padding = 0;  /* turn zero padding off for non-numeric convers. */
+#ifndef DIGITAL_UNIX_COMPATIBLE
+        justify_left = 1; min_field_width = 0;                /* reset flags */
+#endif
+#if defined(PERL_COMPATIBLE) || defined(LINUX_COMPATIBLE)
+     /* keep the entire format string unchanged */
+        str_arg = starting_p; str_arg_l = p - starting_p;
+     /* well, not exactly so for Linux, which does something inbetween,
+      * and I don't feel an urge to imitate it: "%+++++hy" -> "%+y"  */
+#else
+     /* discard the unrecognized conversion, just keep *
+      * the unrecognized conversion character          */
+        str_arg = p; str_arg_l = 0;
+#endif
+        if (*p) str_arg_l++;  /* include invalid conversion specifier unchanged
+                                 if not at end-of-string */
+        break;
+      }
+      if (*p) p++;      /* step over the just processed conversion specifier */
+   /* insert padding to the left as requested by min_field_width;
+      this does not include the zero padding in case of numerical conversions*/
+      if (!justify_left) {                /* left padding with blank or zero */
+        int n = min_field_width - (str_arg_l+number_of_zeros_to_pad);
+        if (n > 0) {
+          if (str_l < str_m) {
+            ssize_t avail = str_m-str_l;
+            fast_memset(str+str_l, (zero_padding?'0':' '), (n>avail?avail:n));
+          }
+          str_l += n;
+        }
+      }
+   /* zero padding as requested by the precision or by the minimal field width
+    * for numeric conversions required? */
+      if (number_of_zeros_to_pad <= 0) {
+     /* will not copy first part of numeric right now, *
+      * force it to be copied later in its entirety    */
+        zero_padding_insertion_ind = 0;
+      } else {
+     /* insert first part of numerics (sign or '0x') before zero padding */
+        int n = zero_padding_insertion_ind;
+        if (n > 0) {
+          if (str_l < str_m) {
+            ssize_t avail = str_m-str_l;
+            fast_memcpy(str+str_l, str_arg, (n>avail?avail:n));
+          }
+          str_l += n;
+        }
+     /* insert zero padding as requested by the precision or min field width */
+        n = number_of_zeros_to_pad;
+        if (n > 0) {
+          if (str_l < str_m) {
+            ssize_t avail = str_m-str_l;
+            fast_memset(str+str_l, '0', (n>avail?avail:n));
+          }
+          str_l += n;
+        }
+      }
+   /* insert formatted string
+    * (or as-is conversion specifier for unknown conversions) */
+      { int n = str_arg_l - zero_padding_insertion_ind;
+        if (n > 0) {
+          if (str_l < str_m) {
+            ssize_t avail = str_m-str_l;
+            fast_memcpy(str+str_l, str_arg+zero_padding_insertion_ind,
+                        (n>avail?avail:n));
+          }
+          str_l += n;
+        }
+      }
+   /* insert right padding */
+      if (justify_left) {          /* right blank padding to the field width */
+        int n = min_field_width - (str_arg_l+number_of_zeros_to_pad);
+        if (n > 0) {
+          if (str_l < str_m) {
+            ssize_t avail = str_m-str_l;
+            fast_memset(str+str_l, ' ', (n>avail?avail:n));
+          }
+          str_l += n;
+        }
+      }
+    }
+  }
+#if defined(NEED_SNPRINTF_ONLY)
+  va_end(ap);
+#endif
+  if (str_m > 0) { /* make sure the string is null-terminated
+                      even at the expense of overwriting the last character
+                      (shouldn't happen, but just in case) */
+    str[str_l <= str_m-1 ? str_l : str_m-1] = '\0';
+  }
+  /* Return the number of characters formatted (excluding trailing null
+   * character), that is, the number of characters that would have been
+   * written to the buffer if it were large enough.
+   *
+   * The value of str_l should be returned, but str_l is of unsigned type
+   * size_t, and snprintf is int, possibly leading to an undetected
+   * integer overflow, resulting in a negative return value, which is illegal.
+   * Both XSH5 and ISO C99 (at least the draft) are silent on this issue.
+   * Should errno be set to EOVERFLOW and EOF returned in this case???
+   */
+  return (int) str_l;
+}
+#endif
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/snprintf_2.2/snprintf.h	Sat Jan 19 19:14:36 2002 +0100
@@ -0,0 +1,26 @@
+#ifndef _PORTABLE_SNPRINTF_H_
+#define _PORTABLE_SNPRINTF_H_
+
+#define PORTABLE_SNPRINTF_VERSION_MAJOR 2
+#define PORTABLE_SNPRINTF_VERSION_MINOR 2
+
+#ifdef HAVE_SNPRINTF
+#include <stdio.h>
+#else
+extern int snprintf(char *, size_t, const char *, /*args*/ ...);
+extern int vsnprintf(char *, size_t, const char *, va_list);
+#endif
+
+#if defined(HAVE_SNPRINTF) && defined(PREFER_PORTABLE_SNPRINTF)
+extern int portable_snprintf(char *str, size_t str_m, const char *fmt, /*args*/ ...);
+extern int portable_vsnprintf(char *str, size_t str_m, const char *fmt, va_list ap);
+#define snprintf  portable_snprintf
+#define vsnprintf portable_vsnprintf
+#endif
+
+extern int asprintf  (char **ptr, const char *fmt, /*args*/ ...);
+extern int vasprintf (char **ptr, const char *fmt, va_list ap);
+extern int asnprintf (char **ptr, size_t str_m, const char *fmt, /*args*/ ...);
+extern int vasnprintf(char **ptr, size_t str_m, const char *fmt, va_list ap);
+
+#endif
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/snprintf_2.2/test.c	Sat Jan 19 19:14:36 2002 +0100
@@ -0,0 +1,689 @@
+/*
+ * test.c - test a portable implementation of snprintf
+ *
+ * AUTHOR
+ *   Mark Martinec <mark.martinec@ijs.si>, April 1999.
+ *
+ *   Copyright 1999, Mark Martinec. All rights reserved.
+ *
+ * TERMS AND CONDITIONS
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the "Frontier Artistic License" which comes
+ *   with this Kit.
+ *
+ *   This program 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 Frontier Artistic License for more details.
+ *
+ *   You should have received a copy of the Frontier Artistic License
+ *   with this Kit in the file named LICENSE.txt .
+ *   If not, I'll be glad to provide one.
+ *
+ * NOTE:  This test program is a QUICK and DIRTY tool
+ * =====  used while testing and benchmarking my portable snprintf.
+ *        Certain data types are not fully supported, certain test
+ *        cases were fabricated during testing by modifying the code
+ *        or running it by specifying test parameters in the command line.
+ *
+ *        You are on your own if you want to use this test program!
+ */
+
+/* If no command arguments are specified do the exhaustive test.
+ * This takes a long time. You may want to reduce the fw and fp
+ * upper limits in the for loops.
+ * You may also reduce the number of test elements in the array iargs.
+ */
+
+#include <sys/types.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+#include <assert.h>
+#include <time.h>
+
+#if defined(NEED_ASPRINTF) || defined(NEED_ASNPRINTF) || defined(NEED_VASPRINTF) || defined(NEED_VASNPRINTF)
+# if defined(NEED_SNPRINTF_ONLY)
+# undef NEED_SNPRINTF_ONLY
+# endif
+# if !defined(PREFER_PORTABLE_SNPRINTF)
+# define PREFER_PORTABLE_SNPRINTF
+# endif
+#endif
+
+#ifdef HAVE_SNPRINTF
+extern int portable_snprintf(char *str, size_t str_m, const char *fmt, /*args*/ ...);
+#else
+extern int snprintf(char *, size_t, const char *, /*args*/ ...);
+extern int vsnprintf(char *, size_t, const char *, va_list);
+#endif
+
+#ifndef HAVE_SNPRINTF
+#define portable_snprintf  snprintf
+#define portable_vsnprintf vsnprintf
+#endif
+
+#ifndef CLOCKS_PER_SEC
+#define CLOCKS_PER_SEC 100
+#endif
+
+#define min(a,b) ((a)<(b) ? (a) : (b))
+#define max(a,b) ((a)>(b) ? (a) : (b))
+
+extern int asprintf  (char **ptr, const char *fmt, /*args*/ ...);
+extern int vasprintf (char **ptr, const char *fmt, va_list ap);
+extern int asnprintf (char **ptr, size_t str_m, const char *fmt, /*args*/ ...);
+extern int vasnprintf(char **ptr, size_t str_m, const char *fmt, va_list ap);
+
+#ifndef NEED_SNPRINTF_ONLY
+int wrap_vsnprintf(char *str, size_t str_m, const char *fmt, /*args*/ ...);
+int wrap_vsnprintf(char *str, size_t str_m, const char *fmt, ...) {
+  va_list ap;
+  int str_l;
+
+  va_start(ap, fmt);
+  str_l = vsnprintf(str, str_m, fmt, ap);
+  va_end(ap);
+  return str_l;
+}
+#endif
+
+#ifdef NEED_VASPRINTF
+int wrap_vasprintf(char **ptr, const char *fmt, /*args*/ ...);
+int wrap_vasprintf(char **ptr, const char *fmt, ...) {
+  va_list ap;
+  int str_l;
+
+  va_start(ap, fmt);
+  str_l = vasprintf(ptr, fmt, ap);
+  va_end(ap);
+  return str_l;
+}
+#endif
+
+#ifdef NEED_VASNPRINTF
+int wrap_vasnprintf(char **ptr, size_t str_m, const char *fmt, /*args*/ ...);
+int wrap_vasnprintf(char **ptr, size_t str_m, const char *fmt, ...) {
+  va_list ap;
+  int str_l;
+
+  va_start(ap, fmt);
+  str_l = vasnprintf(ptr, str_m, fmt, ap);
+  va_end(ap);
+  return str_l;
+}
+#endif
+
+int main(int argc, char *argv[]) {
+  char str1[256], str2[256];
+#ifdef HAVE_SNPRINTF
+  char str3[256];
+#endif
+  int len1, len2, len3;
+  int bad = 0;
+  size_t str_m = 20; /* declared str size */
+
+  if (0) {
+ /* benchmarking */
+    const int cnt = 100000;
+    size_t size;
+    char str[40000];
+    time_t t0,t;
+    int j,len,l1,l2;
+    char *p;
+    int breakpoint;
+
+    size = 18000;
+
+    printf("\n\nsize = %d\n", (int)size);
+    p = malloc(size); assert(p);
+    memset(p,'h',size); p[size-1] = '\0';
+    t0 = clock();
+
+    printf("\ndetermine breakeven point to see when it is worth\n");
+    printf("calling memcpy and when to do inline string copy\n");
+    printf("str_l, memcpy, inline\n");
+    for (breakpoint=0; breakpoint<=35; breakpoint++) {
+      register size_t nnn = (size_t)breakpoint;
+      printf("%5ld", nnn);
+      for (j=10*cnt; j>0; j--) memcpy(str, p, nnn);
+      t = clock(); printf(" %1.3f", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
+      for (j=10*cnt; j>0; j--) {
+        register size_t nn = (size_t)breakpoint;
+        if (nn > 0) {
+          register char *dd; register const char *ss;
+          for (ss=p, dd=str; nn>0; nn--) *dd++ = *ss++;
+        }
+      }
+      t = clock(); printf(" %1.3f\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
+    }
+
+    printf("\nmeasuring time to SKIP a long format with no conversions\n");
+    p[0] = '%'; p[1] = 's';
+    for (j=cnt; j>0; j--) l1=portable_snprintf(NULL,(size_t)0,p,"1234567890");
+    t = clock(); printf("t_port_nul = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
+    for (j=cnt; j>0; j--) l2=portable_snprintf(str,(size_t)8,p,"1234567890");
+    t = clock(); printf("t_port     = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
+    assert(l1==l2);
+    p[0] = p[1] = 'h';
+
+    printf("\nmeasuring time to copy a long format with no conversions\n");
+    for (j=cnt; j>0; j--) l1=portable_snprintf(NULL,(size_t)0,p);
+    t = clock(); printf("t_port_nul = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
+    for (j=cnt; j>0; j--) l2=portable_snprintf(str,sizeof(str),p);
+    t = clock(); printf("t_port     = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
+    assert(l1==l2);
+    for (j=cnt; j>0; j--) sprintf(str,p);
+    t = clock(); printf("t_sys      = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
+
+    printf("\nmeasuring time to copy a long format with one conversion\n");
+    p[size-10] = '%';
+    for (j=cnt; j>0; j--) l1=portable_snprintf(NULL,(size_t)0,p);
+    t = clock(); printf("t_port_nul = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
+    for (j=cnt; j>0; j--) l2=portable_snprintf(str,sizeof(str),p);
+    t = clock(); printf("t_port     = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
+    assert(l1==l2);
+    for (j=cnt; j>0; j--) sprintf(str,p);
+    t = clock(); printf("t_sys      = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
+
+    printf("\nmeasuring string argument copy speed\n");
+    for (j=cnt; j>0; j--) l1=portable_snprintf(NULL,(size_t)0,"%.18000s",p);
+    t = clock(); printf("t_port_nul = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
+    for (j=cnt; j>0; j--) l2=portable_snprintf(str,sizeof(str),"%.18000s",p);
+    t = clock(); printf("t_port     = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
+    assert(l1==l2);
+    for (j=cnt; j>0; j--) sprintf(str,"%.18000s",p);
+    t = clock(); printf("t_sys      = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
+
+    printf("\nmeasuring left padding speed\n");
+    p[0] = '\0';
+    for (j=cnt; j>0; j--) l1=portable_snprintf(NULL,(size_t)0,"%-18000s",p);
+    t = clock(); printf("t_port_nul = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
+    for (j=cnt; j>0; j--) l2=portable_snprintf(str,sizeof(str),"%-18000s",p);
+    t = clock(); printf("t_port     = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
+    assert(l1==l2);
+    for (j=cnt; j>0; j--) sprintf(str,"%-18000s",p);
+    t = clock(); printf("t_sys      = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
+
+    printf("\nmeasuring right padding speed\n");
+    p[0] = '\0';
+    for (j=cnt; j>0; j--) l1=portable_snprintf(NULL,(size_t)0,"%18000s",p);
+    t = clock(); printf("t_port_nul = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
+    for (j=cnt; j>0; j--) l2=portable_snprintf(str,sizeof(str),"%18000s",p);
+    t = clock(); printf("t_port     = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
+    assert(l1==l2);
+    for (j=cnt; j>0; j--) sprintf(str,"%18000s",p);
+    t = clock(); printf("t_sys      = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
+
+    printf("\nmeasuring zero padding speed\n");
+    for (j=cnt; j>0; j--) l1=portable_snprintf(NULL,(size_t)0,"%018000d",1);
+    t = clock(); printf("t_port_nul = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
+    for (j=cnt; j>0; j--) l2=portable_snprintf(str,sizeof(str),"%018000d",1);
+    t = clock(); printf("t_port     = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
+    assert(l1==l2);
+    for (j=cnt; j>0; j--) sprintf(str,"%018000d",1);
+    t = clock(); printf("t_sys      = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
+
+    printf("\nmeasuring system's sprintf to efficiently handle truncated strings\n");
+    memset(p,'h',size); p[size-1] = '\0';
+    t0 = clock();
+    for (j=cnt; j>0; j--) len = strlen(p);
+    printf("len = %d\n", len);
+    t = clock(); printf("t_strlen = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
+/* test if the system sprintf scans the whole string (e.g. by strlen)
+ * before recognizing this was a bad idea since the format specified
+ * a truncated string precision, e.g. "%.8s" .
+ */
+    for (j=cnt; j>0; j--) sprintf(str,"%.2s",p);
+    t = clock(); printf("t_sys    = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
+#ifdef HAVE_SNPRINTF
+    for (j=cnt; j>0; j--) snprintf(str,sizeof(str),"%.2s",p);
+    t = clock(); printf("t_sys    = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
+#endif
+    for (j=cnt; j>0; j--) portable_snprintf(str,sizeof(str),"%.2s",p);
+    t = clock(); printf("t_port   = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
+
+    free(p);
+    return 0;
+  }
+
+
+/* preliminary halfhearted test */
+{
+    const char fmt[] = "Bla%.4s%05iHE%%%-50sTail";
+    char *ptr4=0, *ptr5=0, *ptr6=0, *ptr7=0;
+    int len1f;
+    char str_full[256];
+
+    printf("\npreliminary test: snprintf\n");
+    len1  = snprintf(str1, str_m, fmt, "abcdef",-12,"str");
+    len1f = snprintf(str_full, sizeof(str_full), fmt, "abcdef",-12,"str");
+    assert(len1f==len1);
+    assert(memcmp(str1,str_full,min(len1,str_m-1)) == 0);
+    assert(str1[str_m-1] == '\0');
+    assert(str_full[sizeof(str_full)-1] == '\0');
+
+#ifndef NEED_SNPRINTF_ONLY
+    printf("preliminary test: vsnprintf\n");
+    len2 = wrap_vsnprintf(str2, str_m, fmt, "abcdef",-12,"str");
+    assert(len2==len1);
+    assert(memcmp(str1,str2,min(len1+1,str_m)) == 0);
+    assert(str2[str_m-1] == '\0');
+#endif
+
+#ifdef NEED_ASPRINTF
+    printf("preliminary test: asprintf\n");
+    len4 = asprintf(&ptr4, fmt, "abcdef",-12,"str");
+    assert(ptr4);
+    assert(len4==len1);
+    assert(memcmp(str_full,ptr4,min(len4+1,sizeof(str_full))) == 0);
+    assert(ptr4[len4] == '\0');
+#endif
+
+#ifdef NEED_ASNPRINTF
+    printf("preliminary test: asnprintf\n");
+    len5 = asnprintf(&ptr5, str_m, fmt, "abcdef",-12,"str");
+    assert(ptr5);
+    assert(len5==len1);
+    assert(memcmp(str1,ptr5,min(len5+1,str_m)) == 0);
+    assert(ptr5[len5] == '\0');
+#endif
+
+#ifdef NEED_VASPRINTF
+    printf("preliminary test: vasprintf\n");
+    len6 = wrap_vasprintf(&ptr6, fmt, "abcdef",-12,"str");
+    assert(ptr6);
+    assert(len6==len1);
+    assert(memcmp(str_full,ptr6,min(len6+1,sizeof(str_full))) == 0);
+    assert(ptr6[len6] == '\0');
+#endif
+
+#ifdef NEED_VASNPRINTF
+    printf("preliminary test: vasnprintf\n");
+    len7 = wrap_vasnprintf(&ptr7, str_m, fmt, "abcdef",-12,"str");
+    assert(ptr7);
+    assert(len7==len1);
+    assert(memcmp(str1,ptr7,min(len7+1,str_m)) == 0);
+    assert(ptr7[len7] == '\0');
+#endif
+
+    if (ptr4) free(ptr4);
+    if (ptr5) free(ptr5);
+    if (ptr6) free(ptr6);
+    if (ptr7) free(ptr7);
+}
+
+/* second preliminary halfhearted test */
+{
+    printf("\nsecond preliminary test:\n");
+
+    printf("test 0a\n");
+    memset(str1,'x',sizeof(str1));  memset(str2,'x',sizeof(str2));
+    len1 = snprintf(str1, sizeof(str1), "");
+    len2 = sprintf (str2,               "");
+    assert(len1==len2);
+    assert(memcmp(str1,str2,(size_t)len1) == 0);
+
+    printf("test 0b\n");
+    memset(str1,'x',sizeof(str1));  memset(str2,'x',sizeof(str2));
+    len1 = snprintf(str1, sizeof(str1), "YK");
+    len2 = sprintf (str2,               "YK");
+    assert(len1==len2);
+    assert(memcmp(str1,str2,(size_t)len1) == 0);
+
+    printf("test 1\n");
+    memset(str1,'x',sizeof(str1));  memset(str2,'x',sizeof(str2));
+    len1 = snprintf(str1, sizeof(str1), "%+d",0);
+    len2 = sprintf (str2,               "%+d",0);
+    assert(len1==len2);
+    assert(memcmp(str1,str2,(size_t)len1) == 0);
+
+    printf("test 2\n");
+    memset(str1,'x',sizeof(str1));  memset(str2,'x',sizeof(str2));
+    len1 = snprintf(str1, sizeof(str1), "%.2147483647s", "13");
+    len2 = sprintf (str2,               "%.2147483647s", "13");
+    printf("len1=%d, len2=%d\n", len1,len2);
+    assert(len1==len2);
+    assert(memcmp(str1,str2,(size_t)len1) == 0);
+
+    printf("test 3a\n");
+    memset(str1,'x',sizeof(str1));  memset(str2,'x',sizeof(str2));
+    len1 = snprintf(str1, sizeof(str1), "%.2147483648s", "13");
+    len2 = sprintf (str2,               "%.2147483648s", "13");
+    printf("len1=%d, len2=%d\n", len1,len2);
+    assert(len1==len2);
+    assert(memcmp(str1,str2,(size_t)len1) == 0);
+
+    printf("test 3b\n");
+    memset(str1,'x',sizeof(str1));  memset(str2,'x',sizeof(str2));
+    len1 = snprintf(str1, sizeof(str1), "%.2147483649s", "13");
+    len2 = sprintf (str2,               "%.2147483649s", "13");
+    printf("len1=%d, len2=%d\n", len1,len2);
+    assert(len1==len2);
+    assert(memcmp(str1,str2,(size_t)len1) == 0);
+
+    printf("test 4\n");
+    memset(str1,'x',sizeof(str1));  memset(str2,'x',sizeof(str2));
+    len1 = snprintf(str1, sizeof(str1), "%-.2147483647s", "13");
+    len2 = sprintf (str2,               "%-.2147483647s", "13");
+    printf("len1=%d, len2=%d\n", len1,len2);
+    assert(len1==len2);
+    assert(memcmp(str1,str2,(size_t)len1) == 0);
+
+    printf("test 5\n");
+    memset(str1,'x',sizeof(str1));  memset(str2,'x',sizeof(str2));
+    len1 = snprintf(str1, sizeof(str1), "%-.2147483648s", "13");
+    len2 = sprintf (str2,               "%-.2147483648s", "13");
+    printf("len1=%d, len2=%d\n", len1,len2);
+    assert(len1==len2);
+    assert(memcmp(str1,str2,(size_t)len1) == 0);
+
+    printf("test 6\n");
+    memset(str1,'x',sizeof(str1));  memset(str2,'x',sizeof(str2));
+    len1 = snprintf(str1, sizeof(str1), "%.4294967295s", "13");
+    len2 = sprintf (str2,               "%.4294967295s", "13");
+    printf("len1=%d, len2=%d\n", len1,len2);
+    assert(len1==len2);
+    assert(memcmp(str1,str2,(size_t)len1) == 0);
+
+    printf("test 7\n");
+    memset(str1,'x',sizeof(str1));  memset(str2,'x',sizeof(str2));
+    len1 = snprintf(str1, sizeof(str1), "%.4294967296s", "13");
+    len2 = sprintf (str2,               "%.4294967296s", "13");
+    printf("len1=%d, len2=%d\n", len1,len2);
+    assert(len1==len2);
+    assert(memcmp(str1,str2,(size_t)len1) == 0);
+
+
+    printf("test 12\n");
+    memset(str1,'x',sizeof(str1));  memset(str2,'x',sizeof(str2));
+    len1 = snprintf(str1, sizeof(str1), "%.*s", 2147483647,"13");
+    len2 = sprintf (str2,               "%.*s", 2147483647,"13");
+    printf("len1=%d, len2=%d\n", len1,len2);
+    assert(len1==len2);
+    assert(memcmp(str1,str2,(size_t)len1) == 0);
+
+    printf("test 13\n");
+    memset(str1,'x',sizeof(str1));  memset(str2,'x',sizeof(str2));
+    len1 = snprintf(str1, sizeof(str1), "%.*s", 2147483648U,"13");
+    len2 = sprintf (str2,               "%.*s", 2147483648U,"13");
+    printf("len1=%d, len2=%d\n", len1,len2);
+    assert(len1==len2);
+    assert(memcmp(str1,str2,(size_t)len1) == 0);
+
+    printf("test 14\n");
+    memset(str1,'x',sizeof(str1));  memset(str2,'x',sizeof(str2));
+    len1 = snprintf(str1, sizeof(str1), "%-.*s", 2147483647,"13");
+    len2 = sprintf (str2,               "%-.*s", 2147483647,"13");
+    printf("len1=%d, len2=%d\n", len1,len2);
+    assert(len1==len2);
+    assert(memcmp(str1,str2,(size_t)len1) == 0);
+
+    printf("test 15\n");
+    memset(str1,'x',sizeof(str1));  memset(str2,'x',sizeof(str2));
+    len1 = snprintf(str1, sizeof(str1), "%-.*s", 2147483648U,"13");
+    len2 = sprintf (str2,               "%-.*s", 2147483648U,"13");
+    printf("len1=%d, len2=%d\n", len1,len2);
+    assert(len1==len2);
+    assert(memcmp(str1,str2,(size_t)len1) == 0);
+
+    printf("test 16\n");
+    memset(str1,'x',sizeof(str1));  memset(str2,'x',sizeof(str2));
+    len1 = snprintf(str1, sizeof(str1), "%.*s", 4294967295U,"13");
+    len2 = sprintf (str2,               "%.*s", 4294967295U,"13");
+    printf("len1=%d, len2=%d\n", len1,len2);
+    assert(len1==len2);
+    assert(memcmp(str1,str2,(size_t)len1) == 0);
+
+    printf("test 17\n");
+    memset(str1,'x',sizeof(str1));  memset(str2,'x',sizeof(str2));
+    len1 = snprintf(str1, sizeof(str1), "%.*s", 4294967296U,"13");
+/*  len2 = sprintf (str2,               "%.*s", 4294967296U,"13"); */ /* core dumps on HPUX */
+/*  assert(len1==len2);
+ *  assert(memcmp(str1,str2,(size_t)len1) == 0);
+ */
+
+
+    printf("test 95\n");
+    memset(str1,'x',sizeof(str1));  memset(str2,'x',sizeof(str2));
+    len1 = snprintf(str1, sizeof(str1), "%c",'A');
+    len2 = sprintf (str2,               "%c",'A');
+    assert(len1==len2);
+    assert(memcmp(str1,str2,(size_t)len1) == 0);
+
+    printf("test 96\n");
+    memset(str1,'x',sizeof(str1));  memset(str2,'x',sizeof(str2));
+    len1 = snprintf(str1, sizeof(str1), "%10c",'A');
+    len2 = sprintf (str2,               "%10c",'A');
+    assert(len1==len2);
+    assert(memcmp(str1,str2,(size_t)len1) == 0);
+
+    printf("test 97\n");
+    memset(str1,'x',sizeof(str1));  memset(str2,'x',sizeof(str2));
+    len1 = snprintf(str1, sizeof(str1), "%-10c",'A');
+    len2 = sprintf (str2,               "%-10c",'A');
+    assert(len1==len2);
+    assert(memcmp(str1,str2,(size_t)len1) == 0);
+
+    printf("test 98\n");
+    memset(str1,'x',sizeof(str1));  memset(str2,'x',sizeof(str2));
+    len1 = snprintf(str1, sizeof(str1), "%.10c",'A');
+    len2 = sprintf (str2,               "%.10c",'A');
+    assert(len1==len2);
+    assert(memcmp(str1,str2,(size_t)len1) == 0);
+
+    printf("test 99\n");
+    memset(str1,'x',sizeof(str1));  memset(str2,'x',sizeof(str2));
+    len1 = snprintf(str1, sizeof(str1), "%-.10c",'A');
+    len2 = sprintf (str2,               "%-.10c",'A');
+    assert(len1==len2);
+    assert(memcmp(str1,str2,(size_t)len1) == 0);
+
+
+    printf("test 100\n");
+    memset(str1,'x',sizeof(str1));  memset(str2,'x',sizeof(str2));
+    len1 = snprintf(str1, (size_t)8, "blaBhb%shehe%cX","ABCD",'1');
+    len2 = sprintf (str2,            "blaBhb%shehe%cX","ABCD",'1');
+    assert(len1==len2);
+    assert(memcmp(str1,str2,(size_t)7) == 0);
+    assert(str1[7] == '\0');
+    assert(memcmp(str1+14,str2+16,(size_t)(len1-16)) == 0);
+
+}
+
+ /* testing for correctness and compatibility */
+  if (argc >= 3) {
+    char *c; int alldigits = 1;
+    for (c=argv[2]; *c; c++)
+      if (! (*c == '-' || (*c >= '0' && *c <= '9'))) alldigits = 0;
+    if (alldigits) {
+      int j = atoi(argv[2]);
+      len1 = portable_snprintf(str1, str_m, argv[1], j, 3);
+      len2 = sprintf(str2,                  argv[1], j, 3);
+#ifdef HAVE_SNPRINTF
+      len3 = snprintf(str3, str_m,          argv[1], j, 3);
+#endif
+    } else {
+      len1 = portable_snprintf(str1, str_m, argv[1], argv[2], 3);
+      len2 = sprintf(str2,                  argv[1], argv[2], 3);
+#ifdef HAVE_SNPRINTF
+      len3 = snprintf(str3, str_m,          argv[1], argv[2], 3);
+#endif
+    }
+    printf("portable:     |%s|  len = %d\n", str1, len1);
+    printf("sys sprintf:  |%s|  len = %d\n", str2, len2);
+#ifdef HAVE_SNPRINTF
+    printf("sys snprintf: |%s|  len = %d\n", str3, len3);
+#endif
+  } else {  /* exhaustive testing */
+
+    const char flags[] = "+- 0#";     /* set of test flags   (including '\0')*/
+    int flags_l = strlen(flags);
+
+    const char fspec[] = "scdpoxXuiy"; /* set of test formats (including '\0') */
+    int fspec_l = strlen(fspec);
+
+#ifdef SNPRINTF_LONGLONG_SUPPORT
+    const char datatype[] = " hl2"; /* set of datatypes */
+#else
+    const char datatype[] = " hl";  /* set of datatypes */
+#endif
+    int datatype_l = strlen(datatype);
+
+    const long int iargs[] =                /* set of numeric test arguments */
+      { 0,1,9,10,28,99,100,127,128,129,998,1000,32767,32768,32769,
+        -1,-9,-10,-28,-99,-100,-127,-128,-129,
+        -998,-1000,-32767,-32768,-32769 };
+    int iargs_l = sizeof(iargs)/sizeof(iargs[0]);
+    const char *sargs[] =             /* set of string test arguments */
+      { "", "a", "0", "-ab", "abcde", "abcdefghijk mnopqrstuv" };
+    int sargs_l = sizeof(sargs)/sizeof(sargs[0]);
+
+    char fmt[256];
+    int fmt_l;
+    int a, fs, fl1, fl2, fl3, fl4, fl5, fw, fp, dt;
+
+    for (fs=0; fs<=fspec_l; fs++) {  /* format specifier */
+      int strtype = (fspec[fs] == 's' || fspec[fs] == '%');
+      int args_l = (strtype ? sargs_l : iargs_l);
+
+      for (fw= -1; fw<=3; fw++) {  /* minimal field width */
+
+        printf("Trying format  %%");
+        if (fw >= 0) printf("%d", fw);
+        if (fspec[fs]) putchar(fspec[fs]);
+        putchar('\n');
+
+        for (fp= -2; fp<=3; fp++) {   /* format field precision */
+
+          /* data type modifiers */
+          for (dt=0; dt < ((strtype||fspec[fs]=='c') ? 1 : datatype_l); dt++) {
+
+            int dataty = datatype[dt];
+
+            if (fspec[fs] == 'D' || fspec[fs] == 'U' || fspec[fs] == 'O')
+              dataty = 'l';
+
+            if (fspec[fs] == 'p' && dataty == '2') continue;
+
+            for (fl1=0; fl1<=flags_l; fl1++) {  /* flags */
+             for (fl2=0; fl2<=flags_l; fl2++) {
+              for (fl3=0; fl3<=flags_l; fl3++) {
+               for (fl4=0; fl4<=flags_l; fl4++) {
+                for (fl5=0; fl5<=flags_l; fl5++) {
+
+                   for (a=0; a<args_l; a++) {  /* test arguments */
+
+                     fmt_l = 0; fmt[fmt_l++] = '%';
+                     if (flags[fl1]) fmt[fmt_l++] = flags[fl1];
+                     if (flags[fl2]) fmt[fmt_l++] = flags[fl2];
+                     if (flags[fl3]) fmt[fmt_l++] = flags[fl3];
+                     if (flags[fl4]) fmt[fmt_l++] = flags[fl4];
+                     if (flags[fl5]) fmt[fmt_l++] = flags[fl5];
+                     if (fw >= 0) fmt_l += sprintf(fmt+fmt_l, "%d", fw);
+                     if (fp >= -1) {
+                       fmt[fmt_l++] = '.';
+                       if (fp >= 0) fmt_l += sprintf(fmt+fmt_l, "%d", fp);
+                     }
+                     if (dataty == '2')
+                       { fmt[fmt_l++] = 'l'; fmt[fmt_l++] = 'l'; }
+                     else if (dataty != ' ')
+                       { fmt[fmt_l++] = dataty; }
+
+                     if (fspec[fs]) fmt[fmt_l++] = fspec[fs];
+                     fmt[fmt_l++] = '\0';
+
+                     if (a==0 && fl1==flags_l && fl2==flags_l && fl3==flags_l
+                         && fl4==flags_l && fl5==flags_l) printf("%s\n", fmt);
+
+#ifdef HAVE_SNPRINTF
+                     memset(str1,'G',sizeof(str1));
+                     memset(str2,'G',sizeof(str2));
+                     memset(str3,'G',sizeof(str3));
+#endif
+                     len1 = len2 = len3 = 0;
+                     if (strtype) {
+                       len1 = portable_snprintf(str1, str_m, fmt, sargs[a]);
+                       len2 = sprintf(str2,                  fmt, sargs[a]);
+#ifdef HAVE_SNPRINTF
+                       len3 = snprintf(str3, str_m,          fmt, sargs[a]);
+#endif
+                     } else if (fspec[fs] == 'p') {
+                       len1 = portable_snprintf(str1, str_m, fmt, (void *)iargs[a]);
+                       len2 = sprintf(str2,                  fmt, (void *)iargs[a]);
+#ifdef HAVE_SNPRINTF
+                       len3 = snprintf(str3, str_m,          fmt, (void *)iargs[a]);
+#endif
+                     } else {
+                       switch (dataty) {
+                       case '\0':
+                         len1 = portable_snprintf(str1, str_m, fmt, (int) iargs[a]);
+                         len2 = sprintf(str2,                  fmt, (int) iargs[a]);
+#ifdef HAVE_SNPRINTF
+                         len3 = snprintf(str3, str_m,          fmt, (int) iargs[a]);
+#endif
+                         break;
+                       case 'h':
+                         len1 = portable_snprintf(str1, str_m, fmt, (short int)iargs[a]);
+                         len2 = sprintf(str2,                  fmt, (short int)iargs[a]);
+#ifdef HAVE_SNPRINTF
+                         len3 = snprintf(str3, str_m,          fmt, (short int)iargs[a]);
+#endif
+                         break;
+                       case 'l':
+                         len1 = portable_snprintf(str1, str_m, fmt, (long int)iargs[a]);
+                         len2 = sprintf(str2,                  fmt, (long int)iargs[a]);
+#ifdef HAVE_SNPRINTF
+                         len3 = snprintf(str3, str_m,          fmt, (long int)iargs[a]);
+#endif
+                         break;
+#ifdef SNPRINTF_LONGLONG_SUPPORT
+                       case '2':
+                         len1 = portable_snprintf(str1, str_m, fmt, (long long int)iargs[a]);
+                         len2 = sprintf(str2,                  fmt, (long long int)iargs[a]);
+#ifdef HAVE_SNPRINTF
+                         len3 = snprintf(str3, str_m,          fmt, (long long int)iargs[a]);
+#endif
+                         break;
+#endif
+                       }
+                     }
+
+                     if (0) {
+#ifdef HAVE_SNPRINTF
+                     } else if (len1 != len3 ||
+                         memcmp(str1,str3,min(len1+20,sizeof(str1))) != 0) {
+                       bad = 1;
+                       if (strtype) printf("\n2: %s, <%s>\n", fmt, sargs[a]);
+                       else         printf("\n2: %s, %ld\n",   fmt, iargs[a]);
+                       printf("portable:     |%s|  len = %d\n", str1, len1);
+                       printf("sys sprintf:  |%s|  len = %d\n", str2, len2);
+                       printf("sys snprintf: |%s|  len = %d\n", str3, len3);
+#else
+                     } else if (len1 != len2 ||
+                         (len1>0 && memcmp(str1,str2,min(len1,str_m)-1) != 0)) {
+                       bad = 1;
+                       if (strtype) printf("\n1: %s, <%s>\n", fmt, sargs[a]);
+                       else         printf("\n1: %s, %ld\n",   fmt, iargs[a]);
+                       printf("portable:     |%s|  len = %d\n", str1, len1);
+                       printf("sys sprintf:  |%s|  len = %d\n", str2, len2);
+#endif
+                     }
+                     if (bad) return(1);
+                   }
+
+                }
+               }
+              }
+             }
+
+            }
+          }
+        }
+      }
+    }
+  }
+  return (bad?1:0);
+}
--- a/tokenizer.c	Sun Apr 01 01:43:46 2001 +0200
+++ b/tokenizer.c	Sat Jan 19 19:14:36 2002 +0100
@@ -112,6 +112,12 @@
 	if(tokz->ungetc!=-1){
 		c=tokz->ungetc;
 		tokz->ungetc=-1;
+	}else if (tokz->flags&TOKZ_READ_FROM_BUFFER) {
+		assert(tokz->buffer.data!=NULL);
+		if (tokz->buffer.pos==tokz->buffer.len)
+			c=EOF;
+		else
+			c=tokz->buffer.data[tokz->buffer.pos++];
 	}else{
 		c=getc(tokz->file);
 	}
@@ -578,6 +584,7 @@
 {
 	int c, c2, e;
 	
+	if (!(tokz->flags&TOKZ_READ_FROM_BUFFER))
 	assert(tokz->file!=NULL);
 	
 	tok_free(tok);
@@ -804,6 +811,9 @@
 	tokz->nest_lvl=0;
 	tokz->filestack_n=0;
 	tokz->filestack=NULL;
+	tokz->buffer.data=0;
+	tokz->buffer.len=0;
+	tokz->buffer.pos=0;
 	
 	return tokz;
 }
@@ -838,6 +848,27 @@
 	return tokz;
 }
 
+Tokenizer *tokz_prepare_buffer(char *buffer, int len)
+{
+	Tokenizer *tokz;
+	char old=0;
+
+	tokz=tokz_create();
+	if (len>0) {
+		old=buffer[len-1];
+		buffer[len-1]='\0';
+	}
+
+	tokz->flags|=TOKZ_READ_FROM_BUFFER;
+	tokz->buffer.data=scopy(buffer);
+	tokz->buffer.len=len>0 ? len : strlen(tokz->buffer.data);
+	tokz->buffer.pos=0;
+
+	if (old>0)
+		buffer[len-1]=old;
+
+	return tokz;
+}
 
 /*
  * File close

mercurial