> > In article <[EMAIL PROTECTED]> you wrote: > > > FYI, looks like support for Racoon is ending. Does anyone have any > > > experience with the version in ipsec-tools ? > > I have been using it with FreeBSD 4.11. The only issues I have ran > > into is that some of its debug messages use %zu and %zd. The %z > > isn't know by 4.x libc and causes a core dump. This issue is easily > > fixed with sed. Since 5.x know about %z, this should be a non-issue > > for more current versions of FreeBSD. > > I can't find a port for ipsec-tools. Is anybody working on wrapping > it in a port? I'd rather not convert from racoon to ipsec-tools > before it becomes easier to track new versions. > > Or maybe I should try isakmpd. That does have a port.
Or run the attached patches on the 4.x src tree. Marc
--- /usr/src/lib/libc/stdio/vfprintf.c Sun Oct 13 16:28:00 2002
+++ /usr/src/lib/libc/stdio/vfprintf.c Tue Mar 22 11:57:31 2005
@@ -39,7 +39,7 @@
static char sccsid[] = "@(#)vfprintf.c 8.1 (Berkeley) 6/4/93";
#endif
static const char rcsid[] =
- "$FreeBSD: src/lib/libc/stdio/vfprintf.c,v 1.22.2.5 2002/10/12 10:46:37
schweikh Exp $";
+ "$FreeBSD: src/lib/libc/stdio/vfprintf.c,v 1.32 2001/11/30 06:12:15 fenner
Exp $";
#endif /* LIBC_SCCS and not lint */
/*
@@ -50,10 +50,13 @@
#include <sys/types.h>
+#include <ctype.h>
#include <limits.h>
+#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <sys/inttypes.h>
#if __STDC__
#include <stdarg.h>
@@ -65,15 +68,60 @@
#include "local.h"
#include "fvwrite.h"
+typedef int64_t intmax_t;
+typedef uint64_t uintmax_t;
+#define INTMAX_MAX INT64_MAX
+#define UINTMAX_MAX UINT64_MAX
+#define INT64_MAX 0x7fffffffffffffffLL
+#define UINT64_MAX 0xffffffffffffffffULL
+
/* Define FLOATING_POINT to get floating point. */
#define FLOATING_POINT
+union arg {
+ int intarg;
+ u_int uintarg;
+ long longarg;
+ u_long ulongarg;
+ long long longlongarg;
+ unsigned long long ulonglongarg;
+ ptrdiff_t ptrdiffarg;
+ size_t sizearg;
+ intmax_t intmaxarg;
+ uintmax_t uintmaxarg;
+ void *pvoidarg;
+ char *pchararg;
+ signed char *pschararg;
+ short *pshortarg;
+ int *pintarg;
+ long *plongarg;
+ long long *plonglongarg;
+ ptrdiff_t *pptrdiffarg;
+ size_t *psizearg;
+ intmax_t *pintmaxarg;
+#ifdef FLOATING_POINT
+ double doublearg;
+ long double longdoublearg;
+#endif
+};
+
+/*
+ * Type ids for argument type table.
+ */
+enum typeid {
+ T_UNUSED, TP_SHORT, T_INT, T_U_INT, TP_INT,
+ T_LONG, T_U_LONG, TP_LONG, T_LLONG, T_U_LLONG, TP_LLONG,
+ T_PTRDIFFT, TP_PTRDIFFT, T_SIZET, TP_SIZET,
+ T_INTMAXT, T_UINTMAXT, TP_INTMAXT, TP_VOID, TP_CHAR, TP_SCHAR,
+ T_DOUBLE, T_LONG_DOUBLE
+};
+
static int __sprint __P((FILE *, struct __suio *));
static int __sbprintf __P((FILE *, const char *, va_list));
-static char * __ultoa __P((u_long, char *, int, int, char *));
-static char * __uqtoa __P((u_quad_t, char *, int, int, char *));
-static void __find_arguments __P((const char *, va_list, void ***));
-static void __grow_type_table __P((int, unsigned char **, int *));
+static char * __ujtoa __P((uintmax_t, char *, int, int, char *, const char
*));
+static char * __ultoa __P((u_long, char *, int, int, char *, const char *));
+static void __find_arguments __P((const char *, va_list, union arg **));
+static void __grow_type_table __P((int, enum typeid **, int *));
/*
* Flush out all the vectors defined by the given uio,
@@ -118,8 +166,8 @@
fake._lbfsize = 0; /* not actually used, but Just In Case */
/* do the work, then copy any error status */
- ret = vfprintf(&fake, fmt, ap);
- if (ret >= 0 && fflush(&fake))
+ ret = __vfprintf(&fake, fmt, ap);
+ if (ret >= 0 && __fflush(&fake))
ret = EOF;
if (fake._flags & __SERR)
fp->_flags |= __SERR;
@@ -140,10 +188,12 @@
* use the given digits.
*/
static char *
-__ultoa(u_long val, char *endp, int base, int octzero, char *xdigs)
+__ultoa(u_long val, char *endp, int base, int octzero, char *xdigs,
+ const char *thousep)
{
register char *cp = endp;
register long sval;
+ int ndig;
/*
* Handle the three cases separately, in the hope of getting
@@ -155,6 +205,7 @@
*--cp = to_char(val);
return (cp);
}
+ ndig = 0;
/*
* On many machines, unsigned arithmetic is harder than
* signed arithmetic, so we do at most one unsigned mod and
@@ -163,11 +214,16 @@
*/
if (val > LONG_MAX) {
*--cp = to_char(val % 10);
+ ndig++;
sval = val / 10;
} else
sval = val;
do {
*--cp = to_char(sval % 10);
+ if (++ndig == 3 && thousep && *thousep != '\0') {
+ *--cp = *thousep;
+ ndig = 0;
+ }
sval /= 10;
} while (sval != 0);
break;
@@ -194,30 +250,39 @@
return (cp);
}
-/* Identical to __ultoa, but for quads. */
+/* Identical to __ultoa, but for intmax_t. */
static char *
-__uqtoa(u_quad_t val, char *endp, int base, int octzero, char *xdigs)
+__ujtoa(uintmax_t val, char *endp, int base, int octzero, char *xdigs,
+ const char *thousep)
{
char *cp = endp;
- quad_t sval;
+ intmax_t sval;
+ int ndig;
/* quick test for small values; __ultoa is typically much faster */
/* (perhaps instead we should run until small, then call __ultoa?) */
if (val <= ULONG_MAX)
- return (__ultoa((u_long)val, endp, base, octzero, xdigs));
+ return (__ultoa((u_long)val, endp, base, octzero, xdigs,
+ thousep));
switch (base) {
case 10:
if (val < 10) {
*--cp = to_char(val % 10);
return (cp);
}
- if (val > QUAD_MAX) {
+ ndig = 0;
+ if (val > INTMAX_MAX) {
*--cp = to_char(val % 10);
+ ndig++;
sval = val / 10;
} else
sval = val;
do {
*--cp = to_char(sval % 10);
+ if (++ndig == 3 && thousep && *thousep != '\0') {
+ *--cp = *thousep;
+ ndig = 0;
+ }
sval /= 10;
} while (sval != 0);
break;
@@ -244,12 +309,26 @@
return (cp);
}
+/*
+ * MT-safe version
+ */
+int
+vfprintf(FILE *fp, const char *fmt0, va_list ap)
+{
+ int ret;
+
+ FLOCKFILE(fp);
+ ret = __vfprintf(fp, fmt0, ap);
+ FUNLOCKFILE(fp);
+ return (ret);
+}
+
#ifdef FLOATING_POINT
#include <locale.h>
#include <math.h>
#include "floatio.h"
-#define BUF (MAXEXP+MAXFRACT+1) /* + decimal point */
+#define BUF ((MAXEXP*4/3)+MAXFRACT+1) /* + decimal
point */
#define DEFPREC 6
static char *cvt __P((double, int, int, char *, int *, int, int *, char **));
@@ -257,7 +336,7 @@
#else /* no FLOATING_POINT */
-#define BUF 68
+#define BUF 90
#endif /* FLOATING_POINT */
@@ -271,12 +350,21 @@
#define LADJUST 0x004 /* left adjustment */
#define LONGDBL 0x008 /* long double */
#define LONGINT 0x010 /* long integer */
-#define QUADINT 0x020 /* quad integer */
+#define LLONGINT 0x020 /* long long integer */
#define SHORTINT 0x040 /* short integer */
#define ZEROPAD 0x080 /* zero (as opposed to blank)
pad */
#define FPT 0x100 /* Floating point number */
+ /* C99 additional size modifiers: */
+#define SIZET 0x200 /* size_t */
+#define PTRDIFFT 0x400 /* ptrdiff_t */
+#define INTMAXT 0x800 /* intmax_t */
+#define CHARINT 0x1000 /* print char using int format
*/
+
+/*
+ * Non-MT-safe version
+ */
int
-vfprintf(FILE *fp, const char *fmt0, va_list ap)
+__vfprintf(FILE *fp, const char *fmt0, va_list ap)
{
char *fmt; /* format string */
int ch; /* character from fmt */
@@ -288,8 +376,9 @@
int width; /* width from format (%8d), or 0 */
int prec; /* precision from format (%.3d), or -1 */
char sign; /* sign prefix (' ', '+', '-', or \0) */
+ const char *thousands_sep;
#ifdef FLOATING_POINT
- char *decimal_point = localeconv()->decimal_point;
+ char *decimal_point;
char softsign; /* temporary negative sign for floats */
double _double; /* double precision arguments %[eEfgG] */
int expt; /* integer value of exponent */
@@ -299,7 +388,7 @@
char *dtoaresult; /* buffer allocated by dtoa */
#endif
u_long ulval; /* integer arguments %[diouxX] */
- u_quad_t uqval; /* %q integers */
+ uintmax_t ujval; /* %j, %ll, %q, %t, %z integers */
int base; /* base for [diouxX] conversion */
int dprec; /* a copy of prec if [diouxX], 0 otherwise */
int realsz; /* field size expanded by dprec, sign, etc */
@@ -309,10 +398,10 @@
#define NIOV 8
struct __suio uio; /* output information: summary */
struct __siov iov[NIOV];/* ... and individual io vectors */
- char buf[BUF]; /* space for %c, %[diouxX], %[eEfgG] */
+ char buf[BUF]; /* space for %c, %[diouxX], %[eEfFgG] */
char ox[2]; /* space for 0x hex-prefix */
- void **argtable; /* args, built due to positional arg */
- void *statargtable [STATIC_ARG_TBL_SIZE];
+ union arg *argtable; /* args, built due to positional arg */
+ union arg statargtable [STATIC_ARG_TBL_SIZE];
int nextarg; /* 1-based argument index */
va_list orgap; /* original argument pointer */
@@ -363,7 +452,7 @@
* argument (and arguments must be gotten sequentially).
*/
#define GETARG(type) \
- ((argtable != NULL) ? *((type*)(argtable[nextarg++])) : \
+ ((argtable != NULL) ? *((type*)(&argtable[nextarg++])) : \
(nextarg++, va_arg(ap, type)))
/*
@@ -373,11 +462,24 @@
#define SARG() \
(flags&LONGINT ? GETARG(long) : \
flags&SHORTINT ? (long)(short)GETARG(int) : \
+ flags&CHARINT ? (long)(signed char)GETARG(int) : \
(long)GETARG(int))
#define UARG() \
(flags&LONGINT ? GETARG(u_long) : \
flags&SHORTINT ? (u_long)(u_short)GETARG(int) : \
+ flags&CHARINT ? (u_long)(u_char)GETARG(int) : \
(u_long)GETARG(u_int))
+#define INTMAX_SIZE (INTMAXT|SIZET|PTRDIFFT|LLONGINT)
+#define SJARG() \
+ (flags&INTMAXT ? GETARG(intmax_t) : \
+ flags&SIZET ? (intmax_t)GETARG(size_t) : \
+ flags&PTRDIFFT ? (intmax_t)GETARG(ptrdiff_t) : \
+ (intmax_t)GETARG(long long))
+#define UJARG() \
+ (flags&INTMAXT ? GETARG(uintmax_t) : \
+ flags&SIZET ? (uintmax_t)GETARG(size_t) : \
+ flags&PTRDIFFT ? (uintmax_t)GETARG(ptrdiff_t) : \
+ (uintmax_t)GETARG(unsigned long long))
/*
* Get * arguments, including the form *nn$. Preserve the nextarg
@@ -405,22 +507,19 @@
}
+ thousands_sep = NULL;
#ifdef FLOATING_POINT
dtoaresult = NULL;
+ decimal_point = localeconv()->decimal_point;
#endif
- FLOCKFILE(fp);
/* sorry, fprintf(read_only_file, "") returns EOF, not 0 */
- if (cantwrite(fp)) {
- FUNLOCKFILE(fp);
+ if (cantwrite(fp))
return (EOF);
- }
/* optimise fprintf(stderr) (and other unbuffered Unix files) */
if ((fp->_flags & (__SNBF|__SWR|__SRW)) == (__SNBF|__SWR) &&
- fp->_file >= 0) {
- FUNLOCKFILE(fp);
+ fp->_file >= 0)
return (__sbprintf(fp, fmt0, ap));
- }
fmt = (char *)fmt0;
argtable = NULL;
@@ -487,6 +586,9 @@
case '+':
sign = '+';
goto rflag;
+ case '\'':
+ thousands_sep = localeconv()->thousands_sep;
+ goto rflag;
case '.':
if ((ch = *fmt++) == '*') {
GETASTER (n);
@@ -532,16 +634,30 @@
goto rflag;
#endif
case 'h':
- flags |= SHORTINT;
+ if (flags & SHORTINT) {
+ flags &= ~SHORTINT;
+ flags |= CHARINT;
+ } else
+ flags |= SHORTINT;
+ goto rflag;
+ case 'j':
+ flags |= INTMAXT;
goto rflag;
case 'l':
- if (flags & LONGINT)
- flags |= QUADINT;
- else
+ if (flags & LONGINT) {
+ flags &= ~LONGINT;
+ flags |= LLONGINT;
+ } else
flags |= LONGINT;
goto rflag;
case 'q':
- flags |= QUADINT;
+ flags |= LLONGINT; /* not necessarily */
+ goto rflag;
+ case 't':
+ flags |= PTRDIFFT;
+ goto rflag;
+ case 'z':
+ flags |= SIZET;
goto rflag;
case 'c':
*(cp = buf) = GETARG(int);
@@ -553,10 +669,10 @@
/*FALLTHROUGH*/
case 'd':
case 'i':
- if (flags & QUADINT) {
- uqval = GETARG(quad_t);
- if ((quad_t)uqval < 0) {
- uqval = -uqval;
+ if (flags & INTMAX_SIZE) {
+ ujval = SJARG();
+ if ((intmax_t)ujval < 0) {
+ ujval = -ujval;
sign = '-';
}
} else {
@@ -569,9 +685,14 @@
base = 10;
goto number;
#ifdef FLOATING_POINT
+#ifdef HEXFLOAT
+ case 'a':
+ case 'A':
+#endif
case 'e':
case 'E':
case 'f':
+ case 'F':
goto fp_begin;
case 'g':
case 'G':
@@ -588,12 +709,18 @@
if (isinf(_double)) {
if (_double < 0)
sign = '-';
- cp = "Inf";
+ if (isupper(ch))
+ cp = "INF";
+ else
+ cp = "inf";
size = 3;
break;
}
if (isnan(_double)) {
- cp = "NaN";
+ if (isupper(ch))
+ cp = "NAN";
+ else
+ cp = "nan";
size = 3;
break;
}
@@ -610,13 +737,13 @@
else
ch = 'g';
}
- if (ch <= 'e') { /* 'e' or 'E' fmt */
+ if (ch == 'e' || ch == 'E') {
--expt;
expsize = exponent(expstr, expt, ch);
size = expsize + ndig;
if (ndig > 1 || flags & ALT)
++size;
- } else if (ch == 'f') { /* f fmt */
+ } else if (ch == 'f' || ch == 'F') {
if (expt > 0) {
size = expt;
if (prec || flags & ALT)
@@ -636,12 +763,25 @@
break;
#endif /* FLOATING_POINT */
case 'n':
- if (flags & QUADINT)
- *GETARG(quad_t *) = ret;
+ /*
+ * Assignment-like behavior is specified if the
+ * value overflows or is otherwise unrepresentable.
+ * C99 says to use `signed char' for %hhn conversions.
+ */
+ if (flags & LLONGINT)
+ *GETARG(long long *) = ret;
+ else if (flags & SIZET)
+ *GETARG(ssize_t *) = (ssize_t)ret;
+ else if (flags & PTRDIFFT)
+ *GETARG(ptrdiff_t *) = ret;
+ else if (flags & INTMAXT)
+ *GETARG(intmax_t *) = ret;
else if (flags & LONGINT)
*GETARG(long *) = ret;
else if (flags & SHORTINT)
*GETARG(short *) = ret;
+ else if (flags & CHARINT)
+ *GETARG(signed char *) = ret;
else
*GETARG(int *) = ret;
continue; /* no output */
@@ -649,8 +789,8 @@
flags |= LONGINT;
/*FALLTHROUGH*/
case 'o':
- if (flags & QUADINT)
- uqval = GETARG(u_quad_t);
+ if (flags & INTMAX_SIZE)
+ ujval = UJARG();
else
ulval = UARG();
base = 8;
@@ -663,10 +803,10 @@
* defined manner.''
* -- ANSI X3J11
*/
- ulval = (u_long)GETARG(void *);
+ ujval = (uintmax_t)(uintptr_t)GETARG(void *);
base = 16;
xdigs = "0123456789abcdef";
- flags = (flags & ~QUADINT) | HEXPREFIX;
+ flags = flags | INTMAXT | HEXPREFIX;
ch = 'x';
goto nosign;
case 's':
@@ -694,8 +834,8 @@
flags |= LONGINT;
/*FALLTHROUGH*/
case 'u':
- if (flags & QUADINT)
- uqval = GETARG(u_quad_t);
+ if (flags & INTMAX_SIZE)
+ ujval = UJARG();
else
ulval = UARG();
base = 10;
@@ -705,14 +845,15 @@
goto hex;
case 'x':
xdigs = "0123456789abcdef";
-hex: if (flags & QUADINT)
- uqval = GETARG(u_quad_t);
+hex:
+ if (flags & INTMAX_SIZE)
+ ujval = UJARG();
else
ulval = UARG();
base = 16;
/* leading 0x/X only if non-zero */
if (flags & ALT &&
- (flags & QUADINT ? uqval != 0 : ulval != 0))
+ (flags & INTMAX_SIZE ? ujval != 0 : ulval != 0))
flags |= HEXPREFIX;
/* unsigned conversions */
@@ -731,14 +872,14 @@
* -- ANSI X3J11
*/
cp = buf + BUF;
- if (flags & QUADINT) {
- if (uqval != 0 || prec != 0)
- cp = __uqtoa(uqval, cp, base,
- flags & ALT, xdigs);
+ if (flags & INTMAX_SIZE) {
+ if (ujval != 0 || prec != 0)
+ cp = __ujtoa(ujval, cp, base,
+ flags & ALT, xdigs, thousands_sep);
} else {
if (ulval != 0 || prec != 0)
cp = __ultoa(ulval, cp, base,
- flags & ALT, xdigs);
+ flags & ALT, xdigs, thousands_sep);
}
size = buf + BUF - cp;
break;
@@ -864,7 +1005,6 @@
#endif
if (__sferror(fp))
ret = EOF;
- FUNLOCKFILE(fp);
if ((argtable != NULL) && (argtable != statargtable))
free (argtable);
return (ret);
@@ -872,34 +1012,13 @@
}
/*
- * Type ids for argument type table.
- */
-#define T_UNUSED 0
-#define T_SHORT 1
-#define T_U_SHORT 2
-#define TP_SHORT 3
-#define T_INT 4
-#define T_U_INT 5
-#define TP_INT 6
-#define T_LONG 7
-#define T_U_LONG 8
-#define TP_LONG 9
-#define T_QUAD 10
-#define T_U_QUAD 11
-#define TP_QUAD 12
-#define T_DOUBLE 13
-#define T_LONG_DOUBLE 14
-#define TP_CHAR 15
-#define TP_VOID 16
-
-/*
* Find all arguments when a positional parameter is encountered. Returns a
* table, indexed by argument number, of pointers to each arguments. The
* initial argument table should be an array of STATIC_ARG_TBL_SIZE entries.
* It will be replaces with a malloc-ed one if it overflows.
*/
static void
-__find_arguments (const char *fmt0, va_list ap, void ***argtable)
+__find_arguments (const char *fmt0, va_list ap, union arg **argtable)
{
char *fmt; /* format string */
int ch; /* character from fmt */
@@ -907,8 +1026,8 @@
char *cp; /* handy char pointer (short term usage) */
int flags; /* flags as above */
int width; /* width from format (%8d), or 0 */
- unsigned char *typetable; /* table of types */
- unsigned char stattypetable [STATIC_ARG_TBL_SIZE];
+ enum typeid *typetable; /* table of types */
+ enum typeid stattypetable [STATIC_ARG_TBL_SIZE];
int tablesize; /* current size of type table */
int tablemax; /* largest used index in table */
int nextarg; /* 1-based argument index */
@@ -923,12 +1042,18 @@
typetable[nextarg++] = type)
#define ADDSARG() \
- ((flags&LONGINT) ? ADDTYPE(T_LONG) : \
- ((flags&SHORTINT) ? ADDTYPE(T_SHORT) : ADDTYPE(T_INT)))
+ ((flags&INTMAXT) ? ADDTYPE(T_INTMAXT) : \
+ ((flags&SIZET) ? ADDTYPE(T_SIZET) : \
+ ((flags&PTRDIFFT) ? ADDTYPE(T_PTRDIFFT) : \
+ ((flags&LLONGINT) ? ADDTYPE(T_LLONG) : \
+ ((flags&LONGINT) ? ADDTYPE(T_LONG) : ADDTYPE(T_INT))))))
#define ADDUARG() \
- ((flags&LONGINT) ? ADDTYPE(T_U_LONG) : \
- ((flags&SHORTINT) ? ADDTYPE(T_U_SHORT) : ADDTYPE(T_U_INT)))
+ ((flags&INTMAXT) ? ADDTYPE(T_UINTMAXT) : \
+ ((flags&SIZET) ? ADDTYPE(T_SIZET) : \
+ ((flags&PTRDIFFT) ? ADDTYPE(T_PTRDIFFT) : \
+ ((flags&LLONGINT) ? ADDTYPE(T_U_LLONG) : \
+ ((flags&LONGINT) ? ADDTYPE(T_U_LONG) : ADDTYPE(T_U_INT))))))
/*
* Add * arguments to the type array.
@@ -979,6 +1104,7 @@
goto rflag;
case '-':
case '+':
+ case '\'':
goto rflag;
case '.':
if ((ch = *fmt++) == '*') {
@@ -1010,16 +1136,30 @@
goto rflag;
#endif
case 'h':
- flags |= SHORTINT;
+ if (flags & SHORTINT) {
+ flags &= ~SHORTINT;
+ flags |= CHARINT;
+ } else
+ flags |= SHORTINT;
+ goto rflag;
+ case 'j':
+ flags |= INTMAXT;
goto rflag;
case 'l':
- if (flags & LONGINT)
- flags |= QUADINT;
- else
+ if (flags & LONGINT) {
+ flags &= ~LONGINT;
+ flags |= LLONGINT;
+ } else
flags |= LONGINT;
goto rflag;
case 'q':
- flags |= QUADINT;
+ flags |= LLONGINT; /* not necessarily */
+ goto rflag;
+ case 't':
+ flags |= PTRDIFFT;
+ goto rflag;
+ case 'z':
+ flags |= SIZET;
goto rflag;
case 'c':
ADDTYPE(T_INT);
@@ -1029,13 +1169,13 @@
/*FALLTHROUGH*/
case 'd':
case 'i':
- if (flags & QUADINT) {
- ADDTYPE(T_QUAD);
- } else {
- ADDSARG();
- }
+ ADDSARG();
break;
#ifdef FLOATING_POINT
+#ifdef HEXFLOAT
+ case 'a':
+ case 'A':
+#endif
case 'e':
case 'E':
case 'f':
@@ -1048,12 +1188,20 @@
break;
#endif /* FLOATING_POINT */
case 'n':
- if (flags & QUADINT)
- ADDTYPE(TP_QUAD);
+ if (flags & INTMAXT)
+ ADDTYPE(TP_INTMAXT);
+ else if (flags & PTRDIFFT)
+ ADDTYPE(TP_PTRDIFFT);
+ else if (flags & SIZET)
+ ADDTYPE(TP_SIZET);
+ else if (flags & LLONGINT)
+ ADDTYPE(TP_LLONG);
else if (flags & LONGINT)
ADDTYPE(TP_LONG);
else if (flags & SHORTINT)
ADDTYPE(TP_SHORT);
+ else if (flags & CHARINT)
+ ADDTYPE(TP_SCHAR);
else
ADDTYPE(TP_INT);
continue; /* no output */
@@ -1061,10 +1209,7 @@
flags |= LONGINT;
/*FALLTHROUGH*/
case 'o':
- if (flags & QUADINT)
- ADDTYPE(T_U_QUAD);
- else
- ADDUARG();
+ ADDUARG();
break;
case 'p':
ADDTYPE(TP_VOID);
@@ -1076,17 +1221,9 @@
flags |= LONGINT;
/*FALLTHROUGH*/
case 'u':
- if (flags & QUADINT)
- ADDTYPE(T_U_QUAD);
- else
- ADDUARG();
- break;
case 'X':
case 'x':
- if (flags & QUADINT)
- ADDTYPE(T_U_QUAD);
- else
- ADDUARG();
+ ADDUARG();
break;
default: /* "%?" prints ?, unless ? is NUL */
if (ch == '\0')
@@ -1099,63 +1236,83 @@
* Build the argument table.
*/
if (tablemax >= STATIC_ARG_TBL_SIZE) {
- *argtable = (void **)
- malloc (sizeof (void *) * (tablemax + 1));
+ *argtable = (union arg *)
+ malloc (sizeof (union arg) * (tablemax + 1));
}
- (*argtable) [0] = NULL;
+ (*argtable) [0].intarg = 0;
for (n = 1; n <= tablemax; n++) {
switch (typetable [n]) {
- case T_UNUSED:
- (*argtable) [n] = (void *) &va_arg (ap, int);
+ case T_UNUSED: /* whoops! */
+ (*argtable) [n].intarg = va_arg (ap, int);
break;
- case T_SHORT:
- (*argtable) [n] = (void *) &va_arg (ap, int);
- break;
- case T_U_SHORT:
- (*argtable) [n] = (void *) &va_arg (ap, int);
+ case TP_SCHAR:
+ (*argtable) [n].pschararg = va_arg (ap, signed char *);
break;
case TP_SHORT:
- (*argtable) [n] = (void *) &va_arg (ap, short *);
+ (*argtable) [n].pshortarg = va_arg (ap, short *);
break;
case T_INT:
- (*argtable) [n] = (void *) &va_arg (ap, int);
+ (*argtable) [n].intarg = va_arg (ap, int);
break;
case T_U_INT:
- (*argtable) [n] = (void *) &va_arg (ap, unsigned int);
+ (*argtable) [n].uintarg = va_arg (ap, unsigned int);
break;
case TP_INT:
- (*argtable) [n] = (void *) &va_arg (ap, int *);
+ (*argtable) [n].pintarg = va_arg (ap, int *);
break;
case T_LONG:
- (*argtable) [n] = (void *) &va_arg (ap, long);
+ (*argtable) [n].longarg = va_arg (ap, long);
break;
case T_U_LONG:
- (*argtable) [n] = (void *) &va_arg (ap, unsigned long);
+ (*argtable) [n].ulongarg = va_arg (ap, unsigned long);
break;
case TP_LONG:
- (*argtable) [n] = (void *) &va_arg (ap, long *);
+ (*argtable) [n].plongarg = va_arg (ap, long *);
+ break;
+ case T_LLONG:
+ (*argtable) [n].longlongarg = va_arg (ap, long long);
break;
- case T_QUAD:
- (*argtable) [n] = (void *) &va_arg (ap, quad_t);
+ case T_U_LLONG:
+ (*argtable) [n].ulonglongarg = va_arg (ap, unsigned
long long);
break;
- case T_U_QUAD:
- (*argtable) [n] = (void *) &va_arg (ap, u_quad_t);
+ case TP_LLONG:
+ (*argtable) [n].plonglongarg = va_arg (ap, long long *);
break;
- case TP_QUAD:
- (*argtable) [n] = (void *) &va_arg (ap, quad_t *);
+ case T_PTRDIFFT:
+ (*argtable) [n].ptrdiffarg = va_arg (ap, ptrdiff_t);
break;
+ case TP_PTRDIFFT:
+ (*argtable) [n].pptrdiffarg = va_arg (ap, ptrdiff_t *);
+ break;
+ case T_SIZET:
+ (*argtable) [n].sizearg = va_arg (ap, size_t);
+ break;
+ case TP_SIZET:
+ (*argtable) [n].psizearg = va_arg (ap, ssize_t *);
+ break;
+ case T_INTMAXT:
+ (*argtable) [n].intmaxarg = va_arg (ap, intmax_t);
+ break;
+ case T_UINTMAXT:
+ (*argtable) [n].uintmaxarg = va_arg (ap, uintmax_t);
+ break;
+ case TP_INTMAXT:
+ (*argtable) [n].pintmaxarg = va_arg (ap, intmax_t *);
+ break;
+#ifdef FLOATING_POINT
case T_DOUBLE:
- (*argtable) [n] = (void *) &va_arg (ap, double);
+ (*argtable) [n].doublearg = va_arg (ap, double);
break;
case T_LONG_DOUBLE:
- (*argtable) [n] = (void *) &va_arg (ap, long double);
+ (*argtable) [n].longdoublearg = va_arg (ap, long
double);
break;
+#endif
case TP_CHAR:
- (*argtable) [n] = (void *) &va_arg (ap, char *);
+ (*argtable) [n].pchararg = va_arg (ap, char *);
break;
case TP_VOID:
- (*argtable) [n] = (void *) &va_arg (ap, void *);
+ (*argtable) [n].pvoidarg = va_arg (ap, void *);
break;
}
}
@@ -1168,11 +1325,11 @@
* Increase the size of the type table.
*/
static void
-__grow_type_table (int nextarg, unsigned char **typetable, int *tablesize)
+__grow_type_table (int nextarg, enum typeid **typetable, int *tablesize)
{
- unsigned char *const oldtable = *typetable;
+ enum typeid *const oldtable = *typetable;
const int oldsize = *tablesize;
- unsigned char *newtable;
+ enum typeid *newtable;
int newsize = oldsize * 2;
if (newsize < nextarg + 1)
@@ -1215,8 +1372,13 @@
ndigits++;
mode = 2; /* ndigits significant digits */
}
- digits = __dtoa(value, mode, ndigits, decpt, &dsgn, &rve, dtoaresultp);
- *sign = dsgn != 0;
+ if (value < 0) {
+ value = -value;
+ *sign = '-';
+ } else
+ *sign = '\000';
+ digits = __dtoa(value, mode, ndigits, decpt, &dsgn, &rve,
+ dtoaresultp);
if ((ch != 'g' && ch != 'G') || flags & ALT) {
/* print trailing zeros */
bp = digits + ndigits;
--- /usr/src/lib/libc/stdio/fflush.c Sat Aug 28 02:00:58 1999
+++ /usr/src/lib/libc/stdio/fflush.c Tue Mar 22 12:37:03 2005
@@ -35,44 +35,75 @@
*/
#if defined(LIBC_SCCS) && !defined(lint)
-#if 0
static char sccsid[] = "@(#)fflush.c 8.1 (Berkeley) 6/4/93";
-#endif
-static const char rcsid[] =
- "$FreeBSD: src/lib/libc/stdio/fflush.c,v 1.7 1999/08/28 00:00:58 peter Exp
$";
#endif /* LIBC_SCCS and not lint */
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD: src/lib/libc/stdio/fflush.c,v 1.13 2004/07/04 20:17:00
cperciva Exp $");
#include <errno.h>
#include <stdio.h>
-#include "local.h"
#include "libc_private.h"
+#include "local.h"
-/* Flush a single file, or (if fp is NULL) all files. */
+static int sflush_locked(FILE *);
+
+/*
+ * Flush a single file, or (if fp is NULL) all files.
+ * MT-safe version
+ */
int
-fflush(fp)
- register FILE *fp;
+fflush(FILE *fp)
{
int retval;
if (fp == NULL)
- return (_fwalk(__sflush));
+ return (_fwalk(sflush_locked));
FLOCKFILE(fp);
+
+ /*
+ * There is disagreement about the correct behaviour of fflush()
+ * when passed a file which is not open for reading. According to
+ * the ISO C standard, the behaviour is undefined.
+ * Under linux, such an fflush returns success and has no effect;
+ * under Windows, such an fflush is documented as behaving instead
+ * as fpurge().
+ * Given that applications may be written with the expectation of
+ * either of these two behaviours, the only safe (non-astonishing)
+ * option is to return EBADF and ask that applications be fixed.
+ */
if ((fp->_flags & (__SWR | __SRW)) == 0) {
errno = EBADF;
retval = EOF;
- } else {
+ } else
retval = __sflush(fp);
- }
FUNLOCKFILE(fp);
return (retval);
}
+/*
+ * Flush a single file, or (if fp is NULL) all files.
+ * Non-MT-safe version
+ */
int
-__sflush(fp)
- register FILE *fp;
+__fflush(FILE *fp)
{
- register unsigned char *p;
- register int n, t;
+ int retval;
+
+ if (fp == NULL)
+ return (_fwalk(sflush_locked));
+ if ((fp->_flags & (__SWR | __SRW)) == 0) {
+ errno = EBADF;
+ retval = EOF;
+ } else
+ retval = __sflush(fp);
+ return (retval);
+}
+
+int
+__sflush(FILE *fp)
+{
+ unsigned char *p;
+ int n, t;
t = fp->_flags;
if ((t & __SWR) == 0)
@@ -98,4 +129,15 @@
}
}
return (0);
+}
+
+static int
+sflush_locked(FILE *fp)
+{
+ int ret;
+
+ FLOCKFILE(fp);
+ ret = __sflush(fp);
+ FUNLOCKFILE(fp);
+ return (ret);
}
--- /usr/src/contrib/gcc/c-common.c Fri Jun 21 01:12:24 2002
+++ /usr/src/contrib/gcc/c-common.c Tue Mar 22 14:46:14 2005
@@ -1778,6 +1778,8 @@
{
if (*format_chars == 'h' || *format_chars == 'l')
length_char = *format_chars++;
+ else if (*format_chars == 'z' || *format_chars == 't')
+ length_char = *format_chars++;
else if ((*format_chars == 'q' || *format_chars == 'L')
&& !flag_format_extensions)
{
@@ -1936,6 +1938,8 @@
case 'q': wanted_type = fci->qlen ? *(fci->qlen) : 0; break;
case 'L': wanted_type = fci->bigllen ? *(fci->bigllen) : 0; break;
case 'Z': wanted_type = fci->zlen ? *fci->zlen : 0; break;
+ case 'z': wanted_type = fci->zlen ? *fci->zlen : 0; break;
+ case 't': wanted_type = fci->nolen ? *fci->nolen : 0; break;
}
if (wanted_type == 0)
warning ("use of `%c' length character with `%c' type character",
pgp6GkpLALiJE.pgp
Description: PGP signature
