/* sprintf --- do formatted memory to memory conversion */
/* */
/* sprintf (str, control, arg1, arg2, ...) */
/* in control str conversion fields are */
/* % (start of conversion specifier) */
/* optional flag, one of */
/* - + <blank> # */
/* optional decimal width value ('*' val from arg) */
/* optional period */
/* optional decimal precision value ('*' from arg) */
/* optional long int designation ('l') */
/* (recognize and ignore 'h') */
/* conversion designator, one of */
/* d o u x X f e E g G c s % */
/* */
/* any other characters are copied to the str from */
/* control directly. */
/* */
/********************************************************/
/* WARNING: Number of arguments MUST match number of */
/* fields specified in the control string. */
/********************************************************/
/*
** Go through control string and arguments, using encode to build
** temporary formatted strings, copying the results into the final
** string.
*/
/*
** The defining or not defining of DEBUG controls whether or
** the debug(x) statements are compiled in. This device is
** very useful for debugging code, without having to worry
** about putting code in and out of comments
*/
#include <debug.h>
/* macro for getting a given argument */
#define assign(p) switch (argno) { \
case 1: p = arg1; break; \
case 2: p = arg2; break; \
case 3: p = arg3; break; \
case 4: p = arg4; break; \
case 5: p = arg5; break; \
case 6: p = arg6; break; \
case 7: p = arg7; break; \
case 8: p = arg8; break; \
case 9: p = arg9; break; \
case 10: p = arg10; break; \
default: debug(fprintf(stderr,"sprintf: tried to use > 10 args\n"));return (EOF);}
#define BOMB() if (1) { string[s_in] = '\0'; return (EOF); } else
sprintf (string, control, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
char *string;
char *control;
char *arg1, *arg2, *arg3, *arg4, *arg5, *arg6, *arg7, *arg8, *arg9, *arg10;
{
int left_justify;
int signed_output; /* number is always signed (pos no has +) */
int prefix_blank; /* put a blank in front of pos no's */
int alternate_form; /* see printf doc... */
int is_long; /* long int (floats always double) */
int is_negative; /* negative number */
int is_unsigned; /* use unsigned notation */
int use_shortest; /* 'g' --- shortest of 'e' & 'f' */
int no_point; /* no decimal point in floating pt */
char swtcontrol [MAXLINE]; /* encode string */
char width[MAXLINE]; /* field width */
char prec[MAXLINE]; /* precision */
char fill; /* padding char */
char conv; /* conv specifier */
char *argp; /* current argument */
int argno = 0; /* current arg number */
char result [MAXLINE]; /* temp str for encode */
char result2 [MAXLINE];
char *cp;
int s_in; /* index into dest string */
int c_in; /* index into control string */
int i, j, k;
int base; /* converting to base 8, 10, 16 */
s_in = 0;
for (c_in = 0; control[c_in] != '\0'; c_in++)
{
/* set defaults */
fill = ' ';
width[0] = prec[0] = '\0';
left_justify = signed_output = prefix_blank =
alternate_form = is_long = is_negative =
is_unsigned = use_shortest = no_point = FALSE;
base = 8; /* will be added to as necessary */
if (control[c_in] != '%' && control[c_in] != '\0')
{
string[s_in++] = control[c_in];
/* copy literal characters */
continue;
/* get the next character in the string */
}
if (control[c_in] == '\0')
break;
/* else
just saw a '%' */
c_in++; /* skip leading '%' */
argno++; /* get next arg */
/* control flag */
switch (control[c_in]) {
case '-':
left_justify = TRUE;
c_in++;
break;
case '+':
signed_output = TRUE;
c_in++;
break;
case ' ':
prefix_blank = TRUE;
c_in++;
break;
case '#':
alternate_form = TRUE;
c_in++;
break;
case '\0':
/* error!! */
BOMB();
break;
default:
break;
}
/* field width */
if (control[c_in] == '*') /* get from arg */
{
assign (argp);
itoc (*argp, width, sizeof (width));
c_in++;
argno++; /* to get proper arg */
}
else if (control[c_in] == '-') /* negative width no good */
c_in++;
if (isdigit (control[c_in]))
{
for (i = 0; isdigit (control[c_in]); i++)
width[i] = control[c_in++];
width[i] = '\0';
}
if (control[c_in] == '\0')
BOMB();
else if (control[c_in] == '.')
{
c_in++;
/* precision */
if (control[c_in] == '*') /* get from arg */
{
assign (argp);
itoc (*argp, prec, sizeof (prec));
c_in++;
argno++; /* to get proper arg */
}
else if (isdigit (control[c_in]))
{
for (i = 0; isdigit (control[c_in]); i++)
prec[i] = control[c_in++];
prec[i] = '\0';
}
else
prec[0] = '\0';
}
if (control[c_in] == '\0')
BOMB();
if (control[c_in] == 'l') /* long arg */
{
is_long = TRUE;
c_in++;
}
else if (control[c_in] == 'h')
c_in++; /* ignore it */
/* for compatibility with earlier printf's */
/* a leading 0 in the width means fill with 0's */
if (width[0] == '0')
fill = '0';
conv = control[c_in];
/* do not increment c_in, that is done by for loop */
assign (argp); /* do only once */
switch (conv) {
case '%':
string[s_in++] = '%';
break;
case 'c':
string[s_in++] = (char) *argp;
break;
case 'x':
case 'X':
base += 6;
case 'u':
case 'd':
base += 2;
case 'o':
is_unsigned = (conv != 'd');
i = 0;
encode(swtcontrol, MAXLINE, "*s*s,*i*s*c",
left_justify ? "*-" : "*",
width, /* if empty will print nothing */
is_unsigned ? -base : base,
fill == '0' ? ",0" : "",
is_long ? 'l' : 'i');
encode (result, MAXLINE, swtcontrol, argp);
if (! is_unsigned) /* signed conversion */
{
if (signed_output && result[0] != '-')
string[s_in++] = '+';
else if (prefix_blank)
string[s_in++] = ' ';
}
else if (alternate_form && conv != 'u')
{
/* octal or hex */
string[s_in++] = '0';
if (tolower (conv) == 'x')
string[s_in++] = conv;
}
if (conv == 'X')
mapstr (result, UPPER);
for (i = 0; result[i] != '\0'; i++)
string[s_in++] = result[i];
break;
case 's':
if (argp == NULL)
break; /* null string */
i = encode (swtcontrol, MAXLINE, "*s*s",
left_justify ? "*" : "*-", width);
if (prec[0] != '\0')
{
swtcontrol[i++] = ',';
for (j = 0; prec[j] != '\0'; j++)
swtcontrol[i++] = prec[j];
}
swtcontrol[i++] = 's';
swtcontrol[i] = '\0';
encode (result, MAXLINE, swtcontrol, * argp);
for (i = 0; result[i] != '\0'; i++)
string[s_in++] = result[i];
break;
case 'g':
case 'G':
use_shortest = TRUE;
case 'e':
case 'E':
case 'f':
if (prec[0] == '\0')
{
prec[0] = '6';
prec[1] = '\0';
}
else if (ctoi (prec, (j = 1, &j)) == 0)
no_point = TRUE;
encode (swtcontrol, MAXLINE, "*s*s,*sd",
left_justify ? "*" : "*-", width, prec);
/* f format */
i = encode (result, MAXLINE, swtcontrol, argp);
encode (swtcontrol, MAXLINE, "*s*s,-*sd",
left_justify ? "*" : "*-", width, prec);
/* e format */
j = encode (result2, MAXLINE, swtcontrol, argp);
if (use_shortest)
{
if (i <= j)
conv = 'f';
else
conv = 'e';
}
if (conv == 'f')
cp = result;
else
{
i = j;
cp = result2;
}
/* cp will be string, i length */
if (signed_output && cp[0] != '-')
string[s_in++] = '+';
else if (prefix_blank)
string[s_in++] = ' ';
if (isupper (conv))
mapstr (cp, UPPER);
else
mapstr (cp, LOWER);
/* copy first part of number */
j = 0;
if (cp[j] == '-')
string[s_in++] = cp[j++];
for (; isdigit (cp[j]); j++)
string[s_in++] = cp[j];
if (alternate_form) /* keep decimal point */
{
if (cp[j] == '.' && no_point)
{
string[s_in++] = cp[j];
for (j++; isdigit (cp[j]); j++)
;
}
/* else
fall thru to copy all of it */
}
else if (no_point)
{
if (cp[j] == '.')
for (j++; isdigit (cp[j]); j++)
;
}
/* copy the rest of it */
for (; cp[j] != '\0'; j++)
string[s_in++] = cp[j];
break;
case '\0':
BOMB();
break;
default:
/* treat like a string with the char in it */
i = encode (swtcontrol, MAXLINE, "*s*s",
left_justify ? "*" : "*-", width);
if (prec[0] != '\0')
{
swtcontrol[i++] = ',';
for (j = 0; prec[j] != '\0'; j++)
swtcontrol[i++] = prec[j];
}
swtcontrol[i++] = 's';
swtcontrol[i] = '\0';
result2[0] = conv;
result2[1] = '\0'; /* use as temp buf */
encode (result, MAXLINE, swtcontrol, result2);
for (i = 0; result[i] != '\0'; i++)
string[s_in++] = result[i];
break;
}
}
/* normal exit */
string[s_in] = '\0';
return (--s_in);
}