oysteikt/heimdal
0
0
Fork 0
Code Issues 5 Pull Requests Releases Activity

* don't ever print sign for unsigned conversions

Browse Source 
* don't break when right justifying a number past the end of the buffer
* handle zero precision and the value zero more correctly


git-svn-id: svn://svn.h5l.se/heimdal/trunk/heimdal@12413 ec53bebd-3082-4978-b11e-865c3cabbd6b
This commit is contained in:
Johan Danielsson
2003-06-29 18:51:30 +00:00
parent 76192475cc
commit 4a9b3f573a
1 changed files with 428 additions and 388 deletions
Download Patch File Download Diff File Expand all files Collapse all files

816
lib/roken/snprintf.c
View File

@@ -41,6 +41,7 @@ RCSID("$Id$");
#include <string.h> #include <string.h>
#include <ctype.h> #include <ctype.h>
#include <roken.h> #include <roken.h>
#include <assert.h>
enum format_flags { enum format_flags {
minus_flag = 1, minus_flag = 1,
@@ -55,13 +56,13 @@ enum format_flags {
*/ */
struct snprintf_state { struct snprintf_state {
unsigned char *str; unsigned char *str;
unsigned char *s; unsigned char *s;
unsigned char *theend; unsigned char *theend;
size_t sz; size_t sz;
size_t max_sz; size_t max_sz;
void (*append_char)(struct snprintf_state *, unsigned char); void (*append_char)(struct snprintf_state *, unsigned char);
/* XXX - methods */ /* XXX - methods */
}; };
#if TEST_SNPRINTF #if TEST_SNPRINTF
@@ -72,45 +73,45 @@ struct snprintf_state {
static int static int
sn_reserve (struct snprintf_state *state, size_t n) sn_reserve (struct snprintf_state *state, size_t n)
{ {
return state->s + n > state->theend; return state->s + n > state->theend;
} }
static void static void
sn_append_char (struct snprintf_state *state, unsigned char c) sn_append_char (struct snprintf_state *state, unsigned char c)
{ {
if (!sn_reserve (state, 1)) if (!sn_reserve (state, 1))
*state->s++ = c; *state->s++ = c;
} }
#endif #endif
static int static int
as_reserve (struct snprintf_state *state, size_t n) as_reserve (struct snprintf_state *state, size_t n)
{ {
if (state->s + n > state->theend) { if (state->s + n > state->theend) {
int off = state->s - state->str; int off = state->s - state->str;
unsigned char *tmp; unsigned char *tmp;
if (state->max_sz && state->sz >= state->max_sz) if (state->max_sz && state->sz >= state->max_sz)
return 1; return 1;
state->sz = max(state->sz * 2, state->sz + n); state->sz = max(state->sz * 2, state->sz + n);
if (state->max_sz) if (state->max_sz)
state->sz = min(state->sz, state->max_sz); state->sz = min(state->sz, state->max_sz);
tmp = realloc (state->str, state->sz); tmp = realloc (state->str, state->sz);
if (tmp == NULL) if (tmp == NULL)
return 1; return 1;
state->str = tmp; state->str = tmp;
state->s = state->str + off; state->s = state->str + off;
state->theend = state->str + state->sz - 1; state->theend = state->str + state->sz - 1;
} }
return 0; return 0;
} }
static void static void
as_append_char (struct snprintf_state *state, unsigned char c) as_append_char (struct snprintf_state *state, unsigned char c)
{ {
if(!as_reserve (state, 1)) if(!as_reserve (state, 1))
*state->s++ = c; *state->s++ = c;
} }
/* longest integer types */ /* longest integer types */
@@ -123,14 +124,24 @@ typedef unsigned long u_longest;
typedef long longest; typedef long longest;
#endif #endif
/*
* is # supposed to do anything?
*/
static int
pad(struct snprintf_state *state, int width, char c)
{
int len = 0;
while(width-- > 0){
(*state->append_char)(state, c);
++len;
}
return len;
}
/* return true if we should use alternatve hex form */
static int static int
use_alternative (int flags, u_longest num, unsigned base) use_alternative (int flags, u_longest num, unsigned base)
{ {
return flags & alternate_flag && (base == 16 || base == 8) && num != 0; return (flags & alternate_flag) && base == 16 && num != 0;
} }
static int static int
@@ -138,79 +149,110 @@ append_number(struct snprintf_state *state,
u_longest num, unsigned base, const char *rep, u_longest num, unsigned base, const char *rep,
int width, int prec, int flags, int minusp) int width, int prec, int flags, int minusp)
{ {
int len = 0; int len = 0;
int i; u_longest n = num;
u_longest n = num; char nstr[64]; /* enough for <192 bit octal integers */
int nstart, nlen;
char signchar;
/* given precision, ignore zero flag */ /* given precision, ignore zero flag */
if(prec != -1) if(prec != -1)
flags &= ~zero_flag; flags &= ~zero_flag;
else else
prec = 1; prec = 1;
/* zero value with zero precision -> "" */
if(prec == 0 && n == 0) /* format number as string */
return 0; nstart = sizeof(nstr);
do{ nlen = 0;
(*state->append_char)(state, rep[n % base]); nstr[--nstart] = '\0';
++len; do {
n /= base; assert(nstart > 0);
} while(n); nstr[--nstart] = rep[n % base];
prec -= len; ++nlen;
/* pad with prec zeros */ n /= base;
while(prec-- > 0){ } while(n);
(*state->append_char)(state, '0');
++len; /* zero value with zero precision should produce no digits */
} if(prec == 0 && num == 0) {
/* add length of alternate prefix (added later) to len */ nlen--;
if(use_alternative(flags, num, base)) nstart++;
len += base / 8;
/* pad with zeros */
if(flags & zero_flag){
width -= len;
if(minusp || (flags & space_flag) || (flags & plus_flag))
width--;
while(width-- > 0){
(*state->append_char)(state, '0');
len++;
} }
}
/* add alternate prefix */ /* figure out what char to use for sign */
if(use_alternative(flags, num, base)){ if(minusp)
if(base == 16) signchar = '-';
(*state->append_char)(state, rep[10] + 23); /* XXX */ else if((flags & plus_flag))
(*state->append_char)(state, '0'); signchar = '+';
} else if((flags & space_flag))
/* add sign */ signchar = ' ';
if(minusp){ else
(*state->append_char)(state, '-'); signchar = '\0';
++len;
} else if(flags & plus_flag) { if((flags & alternate_flag) && base == 8) {
(*state->append_char)(state, '+'); /* if necessary, increase the precision to
++len; make first digit a zero */
} else if(flags & space_flag) {
(*state->append_char)(state, ' '); /* XXX C99 claims (regarding # and %o) that "if the value and
++len; precision are both 0, a single 0 is printed", but there is
} no such wording for %x. This would mean that %#.o would
if(flags & minus_flag) output "0", but %#.x "". This does not make sense, and is
/* swap before padding with spaces */ also not what other printf implementations are doing. */
for(i = 0; i < len / 2; i++){
char c = state->s[-i-1]; if(prec <= nlen && nstr[nstart] != '0' && nstr[nstart] != '\0')
state->s[-i-1] = state->s[-len+i]; prec = nlen + 1;
state->s[-len+i] = c;
} }
width -= len;
while(width-- > 0){ /* possible formats:
(*state->append_char)(state, ' '); pad | sign | alt | zero | digits
++len; sign | alt | zero | digits | pad minus_flag
} sign | alt | zero | digits zero_flag */
if(!(flags & minus_flag))
/* swap after padding with spaces */ /* if not right justifying or padding with zeros, we need to
for(i = 0; i < len / 2; i++){ compute the length of the rest of the string, and then pad with
char c = state->s[-i-1]; spaces */
state->s[-i-1] = state->s[-len+i]; if(!(flags & (minus_flag | zero_flag))) {
state->s[-len+i] = c; if(prec > nlen)
width -= prec;
else
width -= nlen;
if(use_alternative(flags, num, base))
width -= 2;
if(signchar != '\0')
width--;
/* pad to width */
len += pad(state, width, ' ');
} }
return len; if(signchar != '\0') {
(*state->append_char)(state, signchar);
++len;
}
if(use_alternative(flags, num, base)) {
(*state->append_char)(state, '0');
(*state->append_char)(state, rep[10] + 23); /* XXX */
len += 2;
}
if(flags & zero_flag) {
/* pad to width with zeros */
if(prec - nlen > width - len - nlen)
len += pad(state, prec - nlen, '0');
else
len += pad(state, width - len - nlen, '0');
} else
/* pad to prec with zeros */
len += pad(state, prec - nlen, '0');
while(nstr[nstart] != '\0') {
(*state->append_char)(state, nstr[nstart++]);
++len;
}
if(flags & minus_flag)
len += pad(state, width - len, ' ');
return len;
} }
/* /*
@@ -234,10 +276,8 @@ append_string (struct snprintf_state *state,
else else
width -= strlen((const char *)arg); width -= strlen((const char *)arg);
if(!(flags & minus_flag)) if(!(flags & minus_flag))
while(width-- > 0) { len += pad(state, width, ' ');
(*state->append_char) (state, ' ');
++len;
}
if (prec != -1) { if (prec != -1) {
while (*arg && prec--) { while (*arg && prec--) {
(*state->append_char) (state, *arg++); (*state->append_char) (state, *arg++);
@@ -250,10 +290,7 @@ append_string (struct snprintf_state *state,
} }
} }
if(flags & minus_flag) if(flags & minus_flag)
while(width-- > 0) { len += pad(state, width, ' ');
(*state->append_char) (state, ' ');
++len;
}
return len; return len;
} }
@@ -263,19 +300,19 @@ append_char(struct snprintf_state *state,
int width, int width,
int flags) int flags)
{ {
int len = 0; int len = 0;
while(!(flags & minus_flag) && --width > 0) { while(!(flags & minus_flag) && --width > 0) {
(*state->append_char) (state, ' ') ; (*state->append_char) (state, ' ') ;
++len;
}
(*state->append_char) (state, arg);
++len; ++len;
} while((flags & minus_flag) && --width > 0) {
(*state->append_char) (state, arg); (*state->append_char) (state, ' ');
++len; ++len;
while((flags & minus_flag) && --width > 0) { }
(*state->append_char) (state, ' '); return 0;
++len;
}
return 0;
} }
/* /*
@@ -313,212 +350,215 @@ else \
static int static int
xyzprintf (struct snprintf_state *state, const char *char_format, va_list ap) xyzprintf (struct snprintf_state *state, const char *char_format, va_list ap)
{ {
const unsigned char *format = (const unsigned char *)char_format; const unsigned char *format = (const unsigned char *)char_format;
unsigned char c; unsigned char c;
int len = 0; int len = 0;
while((c = *format++)) { while((c = *format++)) {
if (c == '%') { if (c == '%') {
int flags = 0; int flags = 0;
int width = 0; int width = 0;
int prec = -1; int prec = -1;
int long_long_flag = 0; int long_long_flag = 0;
int long_flag = 0; int long_flag = 0;
int short_flag = 0; int short_flag = 0;
/* flags */ /* flags */
while((c = *format++)){ while((c = *format++)){
if(c == '-') if(c == '-')
flags |= minus_flag; flags |= minus_flag;
else if(c == '+') else if(c == '+')
flags |= plus_flag; flags |= plus_flag;
else if(c == ' ') else if(c == ' ')
flags |= space_flag; flags |= space_flag;
else if(c == '#') else if(c == '#')
flags |= alternate_flag; flags |= alternate_flag;
else if(c == '0') else if(c == '0')
flags |= zero_flag; flags |= zero_flag;
else if(c == '\'') else if(c == '\'')
; /* just ignore */ ; /* just ignore */
else else
break; break;
} }
if((flags & space_flag) && (flags & plus_flag)) if((flags & space_flag) && (flags & plus_flag))
flags ^= space_flag; flags ^= space_flag;
if((flags & minus_flag) && (flags & zero_flag)) if((flags & minus_flag) && (flags & zero_flag))
flags ^= zero_flag; flags ^= zero_flag;
/* width */ /* width */
if (isdigit(c)) if (isdigit(c))
do { do {
width = width * 10 + c - '0'; width = width * 10 + c - '0';
c = *format++; c = *format++;
} while(isdigit(c)); } while(isdigit(c));
else if(c == '*') { else if(c == '*') {
width = va_arg(ap, int); width = va_arg(ap, int);
c = *format++; c = *format++;
} }
/* precision */ /* precision */
if (c == '.') { if (c == '.') {
prec = 0; prec = 0;
c = *format++; c = *format++;
if (isdigit(c)) if (isdigit(c))
do { do {
prec = prec * 10 + c - '0'; prec = prec * 10 + c - '0';
c = *format++; c = *format++;
} while(isdigit(c)); } while(isdigit(c));
else if (c == '*') { else if (c == '*') {
prec = va_arg(ap, int); prec = va_arg(ap, int);
c = *format++; c = *format++;
}
}
/* size */
if (c == 'h') {
short_flag = 1;
c = *format++;
} else if (c == 'l') {
long_flag = 1;
c = *format++;
if (c == 'l') {
long_long_flag = 1;
c = *format++;
}
}
if(c != 'd' && c != 'i')
flags &= ~(plus_flag | space_flag);
switch (c) {
case 'c' :
append_char(state, va_arg(ap, int), width, flags);
++len;
break;
case 's' :
len += append_string(state,
va_arg(ap, unsigned char*),
width,
prec,
flags);
break;
case 'd' :
case 'i' : {
longest arg;
u_longest num;
int minusp = 0;
PARSE_INT_FORMAT(arg, ap, signed);
if (arg < 0) {
minusp = 1;
num = -arg;
} else
num = arg;
len += append_number (state, num, 10, "0123456789",
width, prec, flags, minusp);
break;
}
case 'u' : {
u_longest arg;
PARSE_INT_FORMAT(arg, ap, unsigned);
len += append_number (state, arg, 10, "0123456789",
width, prec, flags, 0);
break;
}
case 'o' : {
u_longest arg;
PARSE_INT_FORMAT(arg, ap, unsigned);
len += append_number (state, arg, 010, "01234567",
width, prec, flags, 0);
break;
}
case 'x' : {
u_longest arg;
PARSE_INT_FORMAT(arg, ap, unsigned);
len += append_number (state, arg, 0x10, "0123456789abcdef",
width, prec, flags, 0);
break;
}
case 'X' :{
u_longest arg;
PARSE_INT_FORMAT(arg, ap, unsigned);
len += append_number (state, arg, 0x10, "0123456789ABCDEF",
width, prec, flags, 0);
break;
}
case 'p' : {
unsigned long arg = (unsigned long)va_arg(ap, void*);
len += append_number (state, arg, 0x10, "0123456789ABCDEF",
width, prec, flags, 0);
break;
}
case 'n' : {
int *arg = va_arg(ap, int*);
*arg = state->s - state->str;
break;
}
case '\0' :
--format;
/* FALLTHROUGH */
case '%' :
(*state->append_char)(state, c);
++len;
break;
default :
(*state->append_char)(state, '%');
(*state->append_char)(state, c);
len += 2;
break;
}
} else {
(*state->append_char) (state, c);
++len;
} }
}
/* size */
if (c == 'h') {
short_flag = 1;
c = *format++;
} else if (c == 'l') {
long_flag = 1;
c = *format++;
if (c == 'l') {
long_long_flag = 1;
c = *format++;
}
}
switch (c) {
case 'c' :
append_char(state, va_arg(ap, int), width, flags);
++len;
break;
case 's' :
len += append_string(state,
va_arg(ap, unsigned char*),
width,
prec,
flags);
break;
case 'd' :
case 'i' : {
longest arg;
u_longest num;
int minusp = 0;
PARSE_INT_FORMAT(arg, ap, signed);
if (arg < 0) {
minusp = 1;
num = -arg;
} else
num = arg;
len += append_number (state, num, 10, "0123456789",
width, prec, flags, minusp);
break;
}
case 'u' : {
u_longest arg;
PARSE_INT_FORMAT(arg, ap, unsigned);
len += append_number (state, arg, 10, "0123456789",
width, prec, flags, 0);
break;
}
case 'o' : {
u_longest arg;
PARSE_INT_FORMAT(arg, ap, unsigned);
len += append_number (state, arg, 010, "01234567",
width, prec, flags, 0);
break;
}
case 'x' : {
u_longest arg;
PARSE_INT_FORMAT(arg, ap, unsigned);
len += append_number (state, arg, 0x10, "0123456789abcdef",
width, prec, flags, 0);
break;
}
case 'X' :{
u_longest arg;
PARSE_INT_FORMAT(arg, ap, unsigned);
len += append_number (state, arg, 0x10, "0123456789ABCDEF",
width, prec, flags, 0);
break;
}
case 'p' : {
unsigned long arg = (unsigned long)va_arg(ap, void*);
len += append_number (state, arg, 0x10, "0123456789ABCDEF",
width, prec, flags, 0);
break;
}
case 'n' : {
int *arg = va_arg(ap, int*);
*arg = state->s - state->str;
break;
}
case '\0' :
--format;
/* FALLTHROUGH */
case '%' :
(*state->append_char)(state, c);
++len;
break;
default :
(*state->append_char)(state, '%');
(*state->append_char)(state, c);
len += 2;
break;
}
} else {
(*state->append_char) (state, c);
++len;
} }
} return len;
return len;
} }
#if !defined(HAVE_SNPRINTF) || defined(TEST_SNPRINTF) #if !defined(HAVE_SNPRINTF) || defined(TEST_SNPRINTF)
int int
snprintf (char *str, size_t sz, const char *format, ...) snprintf (char *str, size_t sz, const char *format, ...)
{ {
va_list args; va_list args;
int ret; int ret;
va_start(args, format);
ret = vsnprintf (str, sz, format, args);
va_end(args);
#ifdef PARANOIA
{
int ret2;
char *tmp;
tmp = malloc (sz);
if (tmp == NULL)
abort ();
va_start(args, format); va_start(args, format);
ret2 = vsprintf (tmp, format, args); ret = vsnprintf (str, sz, format, args);
va_end(args); va_end(args);
if (ret != ret2 || strcmp(str, tmp))
abort (); #ifdef PARANOIA
free (tmp); {
} int ret2;
char *tmp;
tmp = malloc (sz);
if (tmp == NULL)
abort ();
va_start(args, format);
ret2 = vsprintf (tmp, format, args);
va_end(args);
if (ret != ret2 || strcmp(str, tmp))
abort ();
free (tmp);
}
#endif #endif
return ret; return ret;
} }
#endif #endif
@@ -526,31 +566,31 @@ snprintf (char *str, size_t sz, const char *format, ...)
int int
asprintf (char **ret, const char *format, ...) asprintf (char **ret, const char *format, ...)
{ {
va_list args; va_list args;
int val; int val;
va_start(args, format);
val = vasprintf (ret, format, args);
va_end(args);
#ifdef PARANOIA
{
int ret2;
char *tmp;
tmp = malloc (val + 1);
if (tmp == NULL)
abort ();
va_start(args, format); va_start(args, format);
ret2 = vsprintf (tmp, format, args); val = vasprintf (ret, format, args);
va_end(args); va_end(args);
if (val != ret2 || strcmp(*ret, tmp))
abort (); #ifdef PARANOIA
free (tmp); {
} int ret2;
char *tmp;
tmp = malloc (val + 1);
if (tmp == NULL)
abort ();
va_start(args, format);
ret2 = vsprintf (tmp, format, args);
va_end(args);
if (val != ret2 || strcmp(*ret, tmp))
abort ();
free (tmp);
}
#endif #endif
return val; return val;
} }
#endif #endif
@@ -558,29 +598,29 @@ asprintf (char **ret, const char *format, ...)
int int
asnprintf (char **ret, size_t max_sz, const char *format, ...) asnprintf (char **ret, size_t max_sz, const char *format, ...)
{ {
va_list args; va_list args;
int val; int val;
va_start(args, format); va_start(args, format);
val = vasnprintf (ret, max_sz, format, args); val = vasnprintf (ret, max_sz, format, args);
#ifdef PARANOIA #ifdef PARANOIA
{ {
int ret2; int ret2;
char *tmp; char *tmp;
tmp = malloc (val + 1); tmp = malloc (val + 1);
if (tmp == NULL) if (tmp == NULL)
abort (); abort ();
ret2 = vsprintf (tmp, format, args); ret2 = vsprintf (tmp, format, args);
if (val != ret2 || strcmp(*ret, tmp)) if (val != ret2 || strcmp(*ret, tmp))
abort (); abort ();
free (tmp); free (tmp);
} }
#endif #endif
va_end(args); va_end(args);
return val; return val;
} }
#endif #endif
@@ -588,7 +628,7 @@ asnprintf (char **ret, size_t max_sz, const char *format, ...)
int int
vasprintf (char **ret, const char *format, va_list args) vasprintf (char **ret, const char *format, va_list args)
{ {
return vasnprintf (ret, 0, format, args); return vasnprintf (ret, 0, format, args);
} }
#endif #endif
@@ -597,38 +637,38 @@ vasprintf (char **ret, const char *format, va_list args)
int int
vasnprintf (char **ret, size_t max_sz, const char *format, va_list args) vasnprintf (char **ret, size_t max_sz, const char *format, va_list args)
{ {
int st; int st;
struct snprintf_state state; struct snprintf_state state;
state.max_sz = max_sz; state.max_sz = max_sz;
state.sz = 1; state.sz = 1;
state.str = malloc(state.sz); state.str = malloc(state.sz);
if (state.str == NULL) { if (state.str == NULL) {
*ret = NULL; *ret = NULL;
return -1; return -1;
} }
state.s = state.str; state.s = state.str;
state.theend = state.s + state.sz - 1; state.theend = state.s + state.sz - 1;
state.append_char = as_append_char; state.append_char = as_append_char;
st = xyzprintf (&state, format, args); st = xyzprintf (&state, format, args);
if (st > state.sz) { if (st > state.sz) {
free (state.str); free (state.str);
*ret = NULL; *ret = NULL;
return -1; return -1;
} else { } else {
char *tmp; char *tmp;
*state.s = '\0'; *state.s = '\0';
tmp = realloc (state.str, st+1); tmp = realloc (state.str, st+1);
if (tmp == NULL) { if (tmp == NULL) {
free (state.str); free (state.str);
*ret = NULL; *ret = NULL;
return -1; return -1;
}
*ret = tmp;
return st;
} }
*ret = tmp;
return st;
}
} }
#endif #endif
@@ -636,20 +676,20 @@ vasnprintf (char **ret, size_t max_sz, const char *format, va_list args)
int int
vsnprintf (char *str, size_t sz, const char *format, va_list args) vsnprintf (char *str, size_t sz, const char *format, va_list args)
{ {
struct snprintf_state state; struct snprintf_state state;
int ret; int ret;
unsigned char *ustr = (unsigned char *)str; unsigned char *ustr = (unsigned char *)str;
state.max_sz = 0; state.max_sz = 0;
state.sz = sz; state.sz = sz;
state.str = ustr; state.str = ustr;
state.s = ustr; state.s = ustr;
state.theend = ustr + sz - (sz > 0); state.theend = ustr + sz - (sz > 0);
state.append_char = sn_append_char; state.append_char = sn_append_char;
ret = xyzprintf (&state, format, args); ret = xyzprintf (&state, format, args);
if (state.s != NULL) if (state.s != NULL)
*state.s = '\0'; *state.s = '\0';
return ret; return ret;
} }
#endif #endif