tyler.durden/openssh-portable
1
0
Fork 0
mirror of https://github.com/PowerShell/openssh-portable.git synced 2025-09-26 03:18:54 +02:00
Code Issues Packages Projects Releases Wiki Activity

- (bal) Cleaned out bsd-snprintf.c. VARARGS have been banished and

Browse Source 
I did a base KNF over the whe whole file to make it more acceptable.
   (backed out of original patch and removed it from ChangeLog)

This has been a long time coming.  If we decide that we need VARARGS support
we should do it at a higher level, since no where else do we support VARARGS
in the code base.
This commit is contained in:
Ben Lindstrom 2001-02-13 02:18:50 +00:00
parent d8ab0d4a85
commit 6c92dab9a1
4 changed files with 577 additions and 669 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
ChangeLog
View File

@ -1,7 +1,8 @@
20010213 20010213
- (bal) added NeXT work around for bsd-snprintf.c in bsd-nextstep.h.
- (bal) added TODO item to clean up and sort out 'varargs' from 'stdargs'
- (djm) Only test -S potential EGD sockets if they exist and are readable. - (djm) Only test -S potential EGD sockets if they exist and are readable.
- (bal) Cleaned out bsd-snprintf.c. VARARGS have been banished and
I did a base KNF over the whe whole file to make it more acceptable.
(backed out of original patch and removed it from ChangeLog)
20010212 20010212
- (djm) Update Redhat specfile to allow --define "skip_x11_askpass 1", - (djm) Update Redhat specfile to allow --define "skip_x11_askpass 1",
@ -3909,4 +3910,4 @@
- Wrote replacements for strlcpy and mkdtemp - Wrote replacements for strlcpy and mkdtemp
- Released 1.0pre1 - Released 1.0pre1
$Id: ChangeLog,v 1.751 2001/02/13 01:11:17 djm Exp $ $Id: ChangeLog,v 1.752 2001/02/13 02:18:50 mouring Exp $

5
TODO
View File

@ -29,9 +29,6 @@ Programming:
- Verify that It's safe to enable NGROUPS_MAX under NeXTStep for - Verify that It's safe to enable NGROUPS_MAX under NeXTStep for
groupaccess features. (mouring@eviladmin.org) groupaccess features. (mouring@eviladmin.org)
- Clean up bsd-snprintf.c and sort out how to detect between VARARGS
and STDARGS for better portablity (mouring@eviladmin.org)
Documentation: Documentation:
- More and better - More and better
@ -65,4 +62,4 @@ Packaging:
- HP/UX: Provide DEPOT package scripts. - HP/UX: Provide DEPOT package scripts.
(gilbert.r.loomis@saic.com) (gilbert.r.loomis@saic.com)
$Id: TODO,v 1.34 2001/02/12 15:57:18 mouring Exp $ $Id: TODO,v 1.35 2001/02/13 02:18:50 mouring Exp $

8
openbsd-compat/bsd-nextstep.h
View File

@ -21,7 +21,7 @@
* *
*/ */
/* $Id: bsd-nextstep.h,v 1.3 2001/02/12 15:57:18 mouring Exp $ */ /* $Id: bsd-nextstep.h,v 1.4 2001/02/13 02:18:50 mouring Exp $ */
#ifndef _NEXT_POSIX_H #ifndef _NEXT_POSIX_H
#define _NEXT_POSIX_H #define _NEXT_POSIX_H
@ -29,12 +29,6 @@
#ifdef HAVE_NEXT #ifdef HAVE_NEXT
#include <sys/dir.h> #include <sys/dir.h>
/*
* Temporary hack to let bsd-snprintf.c work. bsd-snprintf.c really
* needs to be cleaned up.
*/
#define HAVE_STDARG_H 1
/* NeXT's readdir() is BSD (struct direct) not POSIX (struct dirent) */ /* NeXT's readdir() is BSD (struct direct) not POSIX (struct dirent) */
#define dirent direct #define dirent direct

482
openbsd-compat/bsd-snprintf.c
View File

@ -38,60 +38,37 @@
* missing. Some systems only have snprintf() but not vsnprintf(), so * missing. Some systems only have snprintf() but not vsnprintf(), so
* the code is now broken down under HAVE_SNPRINTF and HAVE_VSNPRINTF. * the code is now broken down under HAVE_SNPRINTF and HAVE_VSNPRINTF.
* *
* Ben Lindstrom <mouring@pconline.com> 09/27/00 for OpenSSH * Ben Lindstrom <mouring@eviladmin.org> 09/27/00 for OpenSSH
* Welcome to the world of %lld and %qd support. With other * Welcome to the world of %lld and %qd support. With other
* long long support. This is needed for sftp-server to work * long long support. This is needed for sftp-server to work
* right. * right.
*
* Ben Lindstrom <mouring@eviladmin.org> 02/12/01 for OpenSSH
* Removed all hint of VARARGS stuff and banished it to the void,
* and did a bit of KNF style work to make things a bit more
* acceptable. Consider stealing from mutt or enlightenment.
**************************************************************/ **************************************************************/
#include "includes.h" #include "includes.h"
RCSID("$Id: bsd-snprintf.c,v 1.2 2001/02/09 01:55:36 djm Exp $"); RCSID("$Id: bsd-snprintf.c,v 1.3 2001/02/13 02:18:50 mouring Exp $");
#if !defined(HAVE_SNPRINTF) || !defined(HAVE_VSNPRINTF) #if !defined(HAVE_SNPRINTF) || !defined(HAVE_VSNPRINTF)
#include <string.h> static void
# include <ctype.h> dopr(char *buffer, size_t maxlen, const char *format, va_list args);
#include <sys/types.h>
/* Define this as a fall through, HAVE_STDARG_H is probably already set */ static void
fmtstr(char *buffer, size_t *currlen, size_t maxlen, char *value, int flags,
int min, int max);
#define HAVE_VARARGS_H static void
fmtint(char *buffer, size_t *currlen, size_t maxlen, long value, int base,
int min, int max, int flags);
/* varargs declarations: */ static void
fmtfp(char *buffer, size_t *currlen, size_t maxlen, long double fvalue,
#if defined(HAVE_STDARG_H) int min, int max, int flags);
# include <stdarg.h>
# define HAVE_STDARGS /* let's hope that works everywhere (mj) */
# define VA_LOCAL_DECL va_list ap
# define VA_START(f) va_start(ap, f)
# define VA_SHIFT(v,t) ; /* no-op for ANSI */
# define VA_END va_end(ap)
#else
# if defined(HAVE_VARARGS_H)
# include <varargs.h>
# undef HAVE_STDARGS
# define VA_LOCAL_DECL va_list ap
# define VA_START(f) va_start(ap) /* f is ignored! */
# define VA_SHIFT(v,t) v = va_arg(ap,t)
# define VA_END va_end(ap)
# else
/*XX ** NO VARARGS ** XX*/
# endif
#endif
/*int snprintf (char *str, size_t count, const char *fmt, ...);*/
/*int vsnprintf (char *str, size_t count, const char *fmt, va_list arg);*/
static void dopr (char *buffer, size_t maxlen, const char *format,
va_list args);
static void fmtstr (char *buffer, size_t *currlen, size_t maxlen,
char *value, int flags, int min, int max);
static void fmtint (char *buffer, size_t *currlen, size_t maxlen,
long value, int base, int min, int max, int flags);
static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
long double fvalue, int min, int max, int flags);
static void dopr_outch (char *buffer, size_t *currlen, size_t maxlen, char c );
/* /*
* dopr(): poor man's version of doprintf * dopr(): poor man's version of doprintf
@ -123,45 +100,39 @@ static void dopr_outch (char *buffer, size_t *currlen, size_t maxlen, char c );
#define DP_C_LONG_LONG 4 #define DP_C_LONG_LONG 4
#define char_to_int(p) (p - '0') #define char_to_int(p) (p - '0')
#ifndef MAX #define abs_val(p) (p < 0 ? -p : p)
# define MAX(p,q) ((p >= q) ? p : q)
#endif
static void dopr (char *buffer, size_t maxlen, const char *format, va_list args)
static void
dopr(char *buffer, size_t maxlen, const char *format, va_list args)
{ {
char *strvalue;
char ch; char ch;
long value; long value;
long double fvalue; long double fvalue;
char *strvalue; int min = 0;
int min; int max = -1;
int max; int state = DP_S_DEFAULT;
int state; int flags = 0;
int flags; int cflags = 0;
int cflags; size_t currlen = 0;
size_t currlen;
state = DP_S_DEFAULT;
currlen = flags = cflags = min = 0;
max = -1;
ch = *format++; ch = *format++;
while (state != DP_S_DONE) while (state != DP_S_DONE) {
{
if ((ch == '\0') || (currlen >= maxlen)) if ((ch == '\0') || (currlen >= maxlen))
state = DP_S_DONE; state = DP_S_DONE;
switch(state) switch(state) {
{
case DP_S_DEFAULT: case DP_S_DEFAULT:
if (ch == '%') if (ch == '%')
state = DP_S_FLAGS; state = DP_S_FLAGS;
else else
dopr_outch (buffer, &currlen, maxlen, ch); dopr_outch(buffer, &currlen, maxlen, ch);
ch = *format++; ch = *format++;
break; break;
case DP_S_FLAGS: case DP_S_FLAGS:
switch (ch) switch (ch) {
{
case '-': case '-':
flags |= DP_F_MINUS; flags |= DP_F_MINUS;
ch = *format++; ch = *format++;
@ -188,49 +159,38 @@ static void dopr (char *buffer, size_t maxlen, const char *format, va_list args)
} }
break; break;
case DP_S_MIN: case DP_S_MIN:
if (isdigit((unsigned char)ch)) if (isdigit((unsigned char)ch)) {
{
min = 10*min + char_to_int (ch); min = 10*min + char_to_int (ch);
ch = *format++; ch = *format++;
} } else if (ch == '*') {
else if (ch == '*')
{
min = va_arg (args, int); min = va_arg (args, int);
ch = *format++; ch = *format++;
state = DP_S_DOT; state = DP_S_DOT;
} } else
else
state = DP_S_DOT; state = DP_S_DOT;
break; break;
case DP_S_DOT: case DP_S_DOT:
if (ch == '.') if (ch == '.') {
{
state = DP_S_MAX; state = DP_S_MAX;
ch = *format++; ch = *format++;
} } else
else
state = DP_S_MOD; state = DP_S_MOD;
break; break;
case DP_S_MAX: case DP_S_MAX:
if (isdigit((unsigned char)ch)) if (isdigit((unsigned char)ch)) {
{
if (max < 0) if (max < 0)
max = 0; max = 0;
max = 10*max + char_to_int (ch); max = 10*max + char_to_int(ch);
ch = *format++; ch = *format++;
} } else if (ch == '*') {
else if (ch == '*')
{
max = va_arg (args, int); max = va_arg (args, int);
ch = *format++; ch = *format++;
state = DP_S_MOD; state = DP_S_MOD;
} } else
else
state = DP_S_MOD; state = DP_S_MOD;
break; break;
case DP_S_MOD: case DP_S_MOD:
switch (ch) switch (ch) {
{
case 'h': case 'h':
cflags = DP_C_SHORT; cflags = DP_C_SHORT;
ch = *format++; ch = *format++;
@ -257,42 +217,41 @@ static void dopr (char *buffer, size_t maxlen, const char *format, va_list args)
state = DP_S_CONV; state = DP_S_CONV;
break; break;
case DP_S_CONV: case DP_S_CONV:
switch (ch) switch (ch) {
{
case 'd': case 'd':
case 'i': case 'i':
if (cflags == DP_C_SHORT) if (cflags == DP_C_SHORT)
value = va_arg (args, int); value = va_arg(args, int);
else if (cflags == DP_C_LONG) else if (cflags == DP_C_LONG)
value = va_arg (args, long int); value = va_arg(args, long int);
else if (cflags == DP_C_LONG_LONG) else if (cflags == DP_C_LONG_LONG)
value = va_arg (args, long long); value = va_arg (args, long long);
else else
value = va_arg (args, int); value = va_arg (args, int);
fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags); fmtint(buffer, &currlen, maxlen, value, 10, min, max, flags);
break; break;
case 'o': case 'o':
flags |= DP_F_UNSIGNED; flags |= DP_F_UNSIGNED;
if (cflags == DP_C_SHORT) if (cflags == DP_C_SHORT)
value = va_arg (args, unsigned int); value = va_arg(args, unsigned int);
else if (cflags == DP_C_LONG) else if (cflags == DP_C_LONG)
value = va_arg (args, unsigned long int); value = va_arg(args, unsigned long int);
else if (cflags == DP_C_LONG_LONG) else if (cflags == DP_C_LONG_LONG)
value = va_arg (args, unsigned long long); value = va_arg(args, unsigned long long);
else else
value = va_arg (args, unsigned int); value = va_arg(args, unsigned int);
fmtint (buffer, &currlen, maxlen, value, 8, min, max, flags); fmtint(buffer, &currlen, maxlen, value, 8, min, max, flags);
break; break;
case 'u': case 'u':
flags |= DP_F_UNSIGNED; flags |= DP_F_UNSIGNED;
if (cflags == DP_C_SHORT) if (cflags == DP_C_SHORT)
value = va_arg (args, unsigned int); value = va_arg(args, unsigned int);
else if (cflags == DP_C_LONG) else if (cflags == DP_C_LONG)
value = va_arg (args, unsigned long int); value = va_arg(args, unsigned long int);
else if (cflags == DP_C_LONG_LONG) else if (cflags == DP_C_LONG_LONG)
value = va_arg (args, unsigned long long); value = va_arg(args, unsigned long long);
else else
value = va_arg (args, unsigned int); value = va_arg(args, unsigned int);
fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags); fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
break; break;
case 'X': case 'X':
@ -300,87 +259,78 @@ static void dopr (char *buffer, size_t maxlen, const char *format, va_list args)
case 'x': case 'x':
flags |= DP_F_UNSIGNED; flags |= DP_F_UNSIGNED;
if (cflags == DP_C_SHORT) if (cflags == DP_C_SHORT)
value = va_arg (args, unsigned int); value = va_arg(args, unsigned int);
else if (cflags == DP_C_LONG) else if (cflags == DP_C_LONG)
value = va_arg (args, unsigned long int); value = va_arg(args, unsigned long int);
else if (cflags == DP_C_LONG_LONG) else if (cflags == DP_C_LONG_LONG)
value = va_arg (args, unsigned long long); value = va_arg(args, unsigned long long);
else else
value = va_arg (args, unsigned int); value = va_arg(args, unsigned int);
fmtint (buffer, &currlen, maxlen, value, 16, min, max, flags); fmtint(buffer, &currlen, maxlen, value, 16, min, max, flags);
break; break;
case 'f': case 'f':
if (cflags == DP_C_LDOUBLE) if (cflags == DP_C_LDOUBLE)
fvalue = va_arg (args, long double); fvalue = va_arg(args, long double);
else else
fvalue = va_arg (args, double); fvalue = va_arg(args, double);
/* um, floating point? */ /* um, floating point? */
fmtfp (buffer, &currlen, maxlen, fvalue, min, max, flags); fmtfp(buffer, &currlen, maxlen, fvalue, min, max, flags);
break; break;
case 'E': case 'E':
flags |= DP_F_UP; flags |= DP_F_UP;
case 'e': case 'e':
if (cflags == DP_C_LDOUBLE) if (cflags == DP_C_LDOUBLE)
fvalue = va_arg (args, long double); fvalue = va_arg(args, long double);
else else
fvalue = va_arg (args, double); fvalue = va_arg(args, double);
break; break;
case 'G': case 'G':
flags |= DP_F_UP; flags |= DP_F_UP;
case 'g': case 'g':
if (cflags == DP_C_LDOUBLE) if (cflags == DP_C_LDOUBLE)
fvalue = va_arg (args, long double); fvalue = va_arg(args, long double);
else else
fvalue = va_arg (args, double); fvalue = va_arg(args, double);
break; break;
case 'c': case 'c':
dopr_outch (buffer, &currlen, maxlen, va_arg (args, int)); dopr_outch(buffer, &currlen, maxlen, va_arg(args, int));
break; break;
case 's': case 's':
strvalue = va_arg (args, char *); strvalue = va_arg(args, char *);
if (max < 0) if (max < 0)
max = maxlen; /* ie, no max */ max = maxlen; /* ie, no max */
fmtstr (buffer, &currlen, maxlen, strvalue, flags, min, max); fmtstr(buffer, &currlen, maxlen, strvalue, flags, min, max);
break; break;
case 'p': case 'p':
strvalue = va_arg (args, void *); strvalue = va_arg(args, void *);
fmtint (buffer, &currlen, maxlen, (long) strvalue, 16, min, max, flags); fmtint(buffer, &currlen, maxlen, (long) strvalue, 16, min, max, flags);
break; break;
case 'n': case 'n':
if (cflags == DP_C_SHORT) if (cflags == DP_C_SHORT) {
{
short int *num; short int *num;
num = va_arg (args, short int *); num = va_arg(args, short int *);
*num = currlen; *num = currlen;
} } else if (cflags == DP_C_LONG) {
else if (cflags == DP_C_LONG)
{
long int *num; long int *num;
num = va_arg (args, long int *); num = va_arg(args, long int *);
*num = currlen; *num = currlen;
} } else if (cflags == DP_C_LONG_LONG) {
else if (cflags == DP_C_LONG_LONG)
{
long long *num; long long *num;
num = va_arg (args, long long *); num = va_arg(args, long long *);
*num = currlen; *num = currlen;
} } else {
else
{
int *num; int *num;
num = va_arg (args, int *); num = va_arg(args, int *);
*num = currlen; *num = currlen;
} }
break; break;
case '%': case '%':
dopr_outch (buffer, &currlen, maxlen, ch); dopr_outch(buffer, &currlen, maxlen, ch);
break; break;
case 'w': case 'w': /* not supported yet, treat as next char */
/* not supported yet, treat as next char */
ch = *format++; ch = *format++;
break; break;
default: default: /* Unknown, skip */
/* Unknown, skip */
break; break;
} }
ch = *format++; ch = *format++;
@ -390,8 +340,7 @@ static void dopr (char *buffer, size_t maxlen, const char *format, va_list args)
break; break;
case DP_S_DONE: case DP_S_DONE:
break; break;
default: default: /* hmm? */
/* hmm? */
break; /* some picky compilers need this */ break; /* some picky compilers need this */
} }
} }
@ -401,16 +350,15 @@ static void dopr (char *buffer, size_t maxlen, const char *format, va_list args)
buffer[maxlen - 1] = '\0'; buffer[maxlen - 1] = '\0';
} }
static void fmtstr (char *buffer, size_t *currlen, size_t maxlen, static void
fmtstr(char *buffer, size_t *currlen, size_t maxlen,
char *value, int flags, int min, int max) char *value, int flags, int min, int max)
{ {
int padlen, strln; /* amount to pad */ int padlen, strln; /* amount to pad */
int cnt = 0; int cnt = 0;
if (value == 0) if (value == 0)
{
value = "<NULL>"; value = "<NULL>";
}
for (strln = 0; value[strln]; ++strln); /* strlen */ for (strln = 0; value[strln]; ++strln); /* strlen */
padlen = min - strln; padlen = min - strln;
@ -419,20 +367,17 @@ static void fmtstr (char *buffer, size_t *currlen, size_t maxlen,
if (flags & DP_F_MINUS) if (flags & DP_F_MINUS)
padlen = -padlen; /* Left Justify */ padlen = -padlen; /* Left Justify */
while ((padlen > 0) && (cnt < max)) while ((padlen > 0) && (cnt < max)) {
{ dopr_outch(buffer, currlen, maxlen, ' ');
dopr_outch (buffer, currlen, maxlen, ' ');
--padlen; --padlen;
++cnt; ++cnt;
} }
while (*value && (cnt < max)) while (*value && (cnt < max)) {
{ dopr_outch(buffer, currlen, maxlen, *value++);
dopr_outch (buffer, currlen, maxlen, *value++);
++cnt; ++cnt;
} }
while ((padlen < 0) && (cnt < max)) while ((padlen < 0) && (cnt < max)) {
{ dopr_outch(buffer, currlen, maxlen, ' ');
dopr_outch (buffer, currlen, maxlen, ' ');
++padlen; ++padlen;
++cnt; ++cnt;
} }
@ -440,12 +385,13 @@ static void fmtstr (char *buffer, size_t *currlen, size_t maxlen,
/* Have to handle DP_F_NUM (ie 0x and 0 alternates) */ /* Have to handle DP_F_NUM (ie 0x and 0 alternates) */
static void fmtint (char *buffer, size_t *currlen, size_t maxlen, static void
fmtint(char *buffer, size_t *currlen, size_t maxlen,
long value, int base, int min, int max, int flags) long value, int base, int min, int max, int flags)
{ {
int signvalue = 0;
unsigned long uvalue; unsigned long uvalue;
char convert[20]; char convert[20];
int signvalue = 0;
int place = 0; int place = 0;
int spadlen = 0; /* amount to space pad */ int spadlen = 0; /* amount to space pad */
int zpadlen = 0; /* amount to zero pad */ int zpadlen = 0; /* amount to zero pad */
@ -456,72 +402,64 @@ static void fmtint (char *buffer, size_t *currlen, size_t maxlen,
uvalue = value; uvalue = value;
if(!(flags & DP_F_UNSIGNED)) if (!(flags & DP_F_UNSIGNED)) {
{ if (value < 0) {
if( value < 0 ) {
signvalue = '-'; signvalue = '-';
uvalue = -value; uvalue = -value;
} } else if (flags & DP_F_PLUS) /* Do a sign (+/i) */
else
if (flags & DP_F_PLUS) /* Do a sign (+/i) */
signvalue = '+'; signvalue = '+';
else else if (flags & DP_F_SPACE)
if (flags & DP_F_SPACE)
signvalue = ' '; signvalue = ' ';
} }
if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */ if (flags & DP_F_UP)
caps = 1; /* Should characters be upper case? */
do { do {
convert[place++] = convert[place++] =
(caps? "0123456789ABCDEF":"0123456789abcdef") (caps? "0123456789ABCDEF":"0123456789abcdef")
[uvalue % (unsigned)base ]; [uvalue % (unsigned)base];
uvalue = (uvalue / (unsigned)base ); uvalue = (uvalue / (unsigned)base );
} while(uvalue && (place < 20)); } while (uvalue && (place < 20));
if (place == 20) place--; if (place == 20)
place--;
convert[place] = 0; convert[place] = 0;
zpadlen = max - place; zpadlen = max - place;
spadlen = min - MAX (max, place) - (signvalue ? 1 : 0); spadlen = min - MAX (max, place) - (signvalue ? 1 : 0);
if (zpadlen < 0) zpadlen = 0; if (zpadlen < 0)
if (spadlen < 0) spadlen = 0; zpadlen = 0;
if (flags & DP_F_ZERO) if (spadlen < 0)
{ spadlen = 0;
if (flags & DP_F_ZERO) {
zpadlen = MAX(zpadlen, spadlen); zpadlen = MAX(zpadlen, spadlen);
spadlen = 0; spadlen = 0;
} }
if (flags & DP_F_MINUS) if (flags & DP_F_MINUS)
spadlen = -spadlen; /* Left Justifty */ spadlen = -spadlen; /* Left Justifty */
#ifdef DEBUG_SNPRINTF
dprint (1, (debugfile, "zpad: %d, spad: %d, min: %d, max: %d, place: %d\n",
zpadlen, spadlen, min, max, place));
#endif
/* Spaces */ /* Spaces */
while (spadlen > 0) while (spadlen > 0) {
{ dopr_outch(buffer, currlen, maxlen, ' ');
dopr_outch (buffer, currlen, maxlen, ' ');
--spadlen; --spadlen;
} }
/* Sign */ /* Sign */
if (signvalue) if (signvalue)
dopr_outch (buffer, currlen, maxlen, signvalue); dopr_outch(buffer, currlen, maxlen, signvalue);
/* Zeros */ /* Zeros */
if (zpadlen > 0) if (zpadlen > 0) {
{ while (zpadlen > 0) {
while (zpadlen > 0) dopr_outch(buffer, currlen, maxlen, '0');
{
dopr_outch (buffer, currlen, maxlen, '0');
--zpadlen; --zpadlen;
} }
} }
/* Digits */ /* Digits */
while (place > 0) while (place > 0)
dopr_outch (buffer, currlen, maxlen, convert[--place]); dopr_outch(buffer, currlen, maxlen, convert[--place]);
/* Left Justified spaces */ /* Left Justified spaces */
while (spadlen < 0) { while (spadlen < 0) {
@ -530,22 +468,12 @@ static void fmtint (char *buffer, size_t *currlen, size_t maxlen,
} }
} }
static long double abs_val (long double value) static long double
{ pow10(int exp)
long double result = value;
if (value < 0)
result = -value;
return result;
}
static long double pow10 (int exp)
{ {
long double result = 1; long double result = 1;
while (exp) while (exp) {
{
result *= 10; result *= 10;
exp--; exp--;
} }
@ -553,25 +481,25 @@ static long double pow10 (int exp)
return result; return result;
} }
static long round (long double value) static long
round(long double value)
{ {
long intpart; long intpart = value;
intpart = value; value -= intpart;
value = value - intpart;
if (value >= 0.5) if (value >= 0.5)
intpart++; intpart++;
return intpart; return intpart;
} }
static void fmtfp (char *buffer, size_t *currlen, size_t maxlen, static void
long double fvalue, int min, int max, int flags) fmtfp(char *buffer, size_t *currlen, size_t maxlen, long double fvalue,
int min, int max, int flags)
{ {
int signvalue = 0;
long double ufvalue;
char iconvert[20]; char iconvert[20];
char fconvert[20]; char fconvert[20];
int signvalue = 0;
int iplace = 0; int iplace = 0;
int fplace = 0; int fplace = 0;
int padlen = 0; /* amount to pad */ int padlen = 0; /* amount to pad */
@ -579,6 +507,7 @@ static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
int caps = 0; int caps = 0;
long intpart; long intpart;
long fracpart; long fracpart;
long double ufvalue;
/* /*
* AIX manpage says the default is 0, but Solaris says the default * AIX manpage says the default is 0, but Solaris says the default
@ -587,21 +516,15 @@ static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
if (max < 0) if (max < 0)
max = 6; max = 6;
ufvalue = abs_val (fvalue); ufvalue = abs_val(fvalue);
if (fvalue < 0) if (fvalue < 0)
signvalue = '-'; signvalue = '-';
else else if (flags & DP_F_PLUS) /* Do a sign (+/i) */
if (flags & DP_F_PLUS) /* Do a sign (+/i) */
signvalue = '+'; signvalue = '+';
else else if (flags & DP_F_SPACE)
if (flags & DP_F_SPACE)
signvalue = ' '; signvalue = ' ';
#if 0
if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
#endif
intpart = ufvalue; intpart = ufvalue;
/* /*
@ -614,25 +537,21 @@ static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
/* We "cheat" by converting the fractional part to integer by /* We "cheat" by converting the fractional part to integer by
* multiplying by a factor of 10 * multiplying by a factor of 10
*/ */
fracpart = round ((pow10 (max)) * (ufvalue - intpart)); fracpart = round((pow10 (max)) * (ufvalue - intpart));
if (fracpart >= pow10 (max)) if (fracpart >= pow10 (max)) {
{
intpart++; intpart++;
fracpart -= pow10 (max); fracpart -= pow10 (max);
} }
#ifdef DEBUG_SNPRINTF
dprint (1, (debugfile, "fmtfp: %f =? %d.%d\n", fvalue, intpart, fracpart));
#endif
/* Convert integer part */ /* Convert integer part */
do { do {
iconvert[iplace++] = iconvert[iplace++] =
(caps? "0123456789ABCDEF":"0123456789abcdef")[intpart % 10]; (caps? "0123456789ABCDEF":"0123456789abcdef")[intpart % 10];
intpart = (intpart / 10); intpart = (intpart / 10);
} while(intpart && (iplace < 20)); } while(intpart && (iplace < 20));
if (iplace == 20) iplace--; if (iplace == 20)
iplace--;
iconvert[iplace] = 0; iconvert[iplace] = 0;
/* Convert fractional part */ /* Convert fractional part */
@ -641,7 +560,8 @@ static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
(caps? "0123456789ABCDEF":"0123456789abcdef")[fracpart % 10]; (caps? "0123456789ABCDEF":"0123456789abcdef")[fracpart % 10];
fracpart = (fracpart / 10); fracpart = (fracpart / 10);
} while(fracpart && (fplace < 20)); } while(fracpart && (fplace < 20));
if (fplace == 20) fplace--; if (fplace == 20)
fplace--;
fconvert[fplace] = 0; fconvert[fplace] = 0;
/* -1 for decimal point, another -1 if we are printing a sign */ /* -1 for decimal point, another -1 if we are printing a sign */
@ -654,54 +574,49 @@ static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
if (flags & DP_F_MINUS) if (flags & DP_F_MINUS)
padlen = -padlen; /* Left Justifty */ padlen = -padlen; /* Left Justifty */
if ((flags & DP_F_ZERO) && (padlen > 0)) if ((flags & DP_F_ZERO) && (padlen > 0)) {
{ if (signvalue) {
if (signvalue) dopr_outch(buffer, currlen, maxlen, signvalue);
{
dopr_outch (buffer, currlen, maxlen, signvalue);
--padlen; --padlen;
signvalue = 0; signvalue = 0;
} }
while (padlen > 0) while (padlen > 0) {
{ dopr_outch(buffer, currlen, maxlen, '0');
dopr_outch (buffer, currlen, maxlen, '0');
--padlen; --padlen;
} }
} }
while (padlen > 0) while (padlen > 0) {
{ dopr_outch(buffer, currlen, maxlen, ' ');
dopr_outch (buffer, currlen, maxlen, ' ');
--padlen; --padlen;
} }
if (signvalue) if (signvalue)
dopr_outch (buffer, currlen, maxlen, signvalue); dopr_outch(buffer, currlen, maxlen, signvalue);
while (iplace > 0) while (iplace > 0)
dopr_outch (buffer, currlen, maxlen, iconvert[--iplace]); dopr_outch(buffer, currlen, maxlen, iconvert[--iplace]);
/* /*
* Decimal point. This should probably use locale to find the correct * Decimal point. This should probably use locale to find the correct
* char to print out. * char to print out.
*/ */
dopr_outch (buffer, currlen, maxlen, '.'); dopr_outch(buffer, currlen, maxlen, '.');
while (fplace > 0) while (fplace > 0)
dopr_outch (buffer, currlen, maxlen, fconvert[--fplace]); dopr_outch(buffer, currlen, maxlen, fconvert[--fplace]);
while (zpadlen > 0) while (zpadlen > 0) {
{ dopr_outch(buffer, currlen, maxlen, '0');
dopr_outch (buffer, currlen, maxlen, '0');
--zpadlen; --zpadlen;
} }
while (padlen < 0) while (padlen < 0) {
{ dopr_outch(buffer, currlen, maxlen, ' ');
dopr_outch (buffer, currlen, maxlen, ' ');
++padlen; ++padlen;
} }
} }
static void dopr_outch (char *buffer, size_t *currlen, size_t maxlen, char c) static void
dopr_outch(char *buffer, size_t *currlen, size_t maxlen, char c)
{ {
if (*currlen < maxlen) if (*currlen < maxlen)
buffer[(*currlen)++] = c; buffer[(*currlen)++] = c;
@ -709,44 +624,34 @@ static void dopr_outch (char *buffer, size_t *currlen, size_t maxlen, char c)
#endif /* !defined(HAVE_SNPRINTF) || !defined(HAVE_VSNPRINTF) */ #endif /* !defined(HAVE_SNPRINTF) || !defined(HAVE_VSNPRINTF) */
#ifndef HAVE_VSNPRINTF #ifndef HAVE_VSNPRINTF
int vsnprintf (char *str, size_t count, const char *fmt, va_list args) int
vsnprintf(char *str, size_t count, const char *fmt, va_list args)
{ {
str[0] = 0; str[0] = 0;
dopr(str, count, fmt, args); dopr(str, count, fmt, args);
return(strlen(str)); return(strlen(str));
} }
#endif /* !HAVE_VSNPRINTF */ #endif /* !HAVE_VSNPRINTF */
#ifndef HAVE_SNPRINTF #ifndef HAVE_SNPRINTF
/* VARARGS3 */ int
#ifdef HAVE_STDARGS snprintf(char *str,size_t count,const char *fmt,...)
int snprintf (char *str,size_t count,const char *fmt,...)
#else
int snprintf (va_alist) va_dcl
#endif
{ {
#ifndef HAVE_STDARGS va_list ap;
char *str;
size_t count;
char *fmt;
#endif
VA_LOCAL_DECL;
VA_START (fmt); va_start(ap, fmt);
VA_SHIFT (str, char *);
VA_SHIFT (count, size_t );
VA_SHIFT (fmt, char *);
(void) vsnprintf(str, count, fmt, ap); (void) vsnprintf(str, count, fmt, ap);
VA_END; va_end(ap);
return(strlen(str)); return(strlen(str));
} }
#ifdef TEST_SNPRINTF #ifdef TEST_SNPRINTF
#ifndef LONG_STRING int
#define LONG_STRING 1024 main(void)
#endif
int main (void)
{ {
#define LONG_STRING 1024
char buf1[LONG_STRING]; char buf1[LONG_STRING];
char buf2[LONG_STRING]; char buf2[LONG_STRING];
char *fp_fmt[] = { char *fp_fmt[] = {
@ -763,8 +668,19 @@ int main (void)
"%3.2f", "%3.2f",
NULL NULL
}; };
double fp_nums[] = { -1.5, 134.21, 91340.2, 341.1234, 0203.9, 0.96, 0.996, double fp_nums[] = {
0.9996, 1.996, 4.136, 0}; -1.5,
134.21,
91340.2,
341.1234,
0203.9,
0.96,
0.996,
0.9996,
1.996,
4.136,
0
};
char *int_fmt[] = { char *int_fmt[] = {
"%-1.5d", "%-1.5d",
"%1.5d", "%1.5d",
@ -784,36 +700,36 @@ int main (void)
int fail = 0; int fail = 0;
int num = 0; int num = 0;
printf ("Testing snprintf format codes against system sprintf...\n"); printf("Testing snprintf format codes against system sprintf...\n");
for (x = 0; fp_fmt[x] != NULL ; x++) for (x = 0; fp_fmt[x] != NULL ; x++) {
for (y = 0; fp_nums[y] != 0 ; y++) for (y = 0; fp_nums[y] != 0 ; y++) {
{ snprintf(buf1, sizeof (buf1), fp_fmt[x], fp_nums[y]);
snprintf (buf1, sizeof (buf1), fp_fmt[x], fp_nums[y]);
sprintf (buf2, fp_fmt[x], fp_nums[y]); sprintf (buf2, fp_fmt[x], fp_nums[y]);
if (strcmp (buf1, buf2)) if (strcmp (buf1, buf2)) {
{ printf("snprintf doesn't match Format: %s\n\t"
printf("snprintf doesn't match Format: %s\n\tsnprintf = %s\n\tsprintf = %s\n", "snprintf = %s\n\tsprintf = %s\n",
fp_fmt[x], buf1, buf2); fp_fmt[x], buf1, buf2);
fail++; fail++;
} }
num++; num++;
} }
}
for (x = 0; int_fmt[x] != NULL ; x++) for (x = 0; int_fmt[x] != NULL ; x++) {
for (y = 0; int_nums[y] != 0 ; y++) for (y = 0; int_nums[y] != 0 ; y++) {
{ snprintf(buf1, sizeof (buf1), int_fmt[x], int_nums[y]);
snprintf (buf1, sizeof (buf1), int_fmt[x], int_nums[y]); sprintf(buf2, int_fmt[x], int_nums[y]);
sprintf (buf2, int_fmt[x], int_nums[y]); if (strcmp (buf1, buf2)) {
if (strcmp (buf1, buf2)) printf("snprintf doesn't match Format: %s\n\t"
{ "snprintf = %s\n\tsprintf = %s\n",
printf("snprintf doesn't match Format: %s\n\tsnprintf = %s\n\tsprintf = %s\n",
int_fmt[x], buf1, buf2); int_fmt[x], buf1, buf2);
fail++; fail++;
} }
num++; num++;
} }
printf ("%d tests failed out of %d.\n", fail, num); }
printf("%d tests failed out of %d.\n", fail, num);
return(0);
} }
#endif /* SNPRINTF_TEST */ #endif /* SNPRINTF_TEST */