Thread: sprintf and arrays

I have a function which takes a format string and an array of unknown length, then needs to format the array into the string. For example, the calling code could look like this:

Code:

char *result = malloc(21);
char *format = "%s is not %s.";
char *array[2] = {"Foo", "bar"};
asprintf(result, format, array);

The first way I thought of to accomplish this was to loop through the array and replace one format field at a time. But this only works for the first field; all the rest are replaced with "(null)" in GCC. The standard doesn't define any behavior for this case, which seems really weird to me; obviously, the language should do what would make my project easier. But seriously, I see no use for putting "(null)" as a placeholder everywhere; I think the standard should say to ignore excess fields...

Anyway, what else can I try? I thought of splitting the string just before each percent-sign and formatting each piece individually before reassembling the whole thing, but that's a nasty hack.

EDIT: I just thought of another way... I can double each successive percent-sign, so the above string becomes "%s is not %%s." But then I wonder whether I should do that with a loop or recursion...

Thanks.

Code:

foo( s, f, a )
    x = 0
    while *f
        if *f is not %
            *s++ = *f++
        else
            strcat s, a[ x ]
            s += strlen a[ x++ ]
            f+=2

That should do it. Although you might want to allow for the possibility of %%.


Quzah.

I actually thought this would be a lot simpler than it turned out to be. Oh well, it was a fun exercise, anyway.

Code:

char* foo( char* dst, char* fmt, char** argv, size_t max )
{
	char
		* buf,
		* ptr, 
		** args,
		pct = '%',
		tag = 0x3, // randomly chosen
		sav = 0x4; // randomly chosen
	size_t
		len = strlen( fmt ) + 1;
	for( args = argv; *args; ++args )
		len += strlen( *args );
	if( len > max )
		return 0;
	buf = malloc( len );
	strcpy( dst, fmt );
/*
	Hide '%' symbols
*/	
	for( ptr = dst; *ptr; ++ptr )
	{		
		if( *ptr == pct )
		{
			if( *( ptr + 1 ) == pct )
				*ptr = *( ptr + 1 ) = sav;
			else
				*ptr = tag;
		}		
	}
	while( *argv )
	{
	/*
		Reveal next '%' symbol
	*/	
		for( ptr = dst; *ptr; ++ptr )
		{		
			if( *ptr == tag )
			{
				*ptr = pct;
				break;
			}
		}	
		sprintf( buf, dst, *argv++ );
		strcpy( dst, buf );
	}
	free( buf );	
/*
	Convert remaining hidden symbols that were originally 
	escaped in the format string into a single '%' symbol
*/	
	for( ptr = buf = dst; *buf; ++buf, ++ptr )
	{	
		if( *buf == sav )
		{
			*ptr = pct;
			++buf;
		}	
		else
			*ptr = *buf;
	}	
	*ptr = 0;	
	return dst;
}

Example:

Code:

int main( void )
{	
	const size_t
		max = 1024;
	char
		buf[ max ],
		* args[ ] = 
	{
		"one", "two", "three", NULL
	};		
	foo( buf, "one: %s, none: %%s, two: %s, three: %s\n", args, max );
	puts( buf );	
	return 0;
}

nonoob: Inverted, that could be (EDIT: Well, there would have to be some safety checks):

Code:

void asprintf(char *result, char *format, void **array){
    sprintf(result, format, array[0], array[1], array[3], array[4], array[5], array[6], array[7]);
}

This is a good last resort, but I would really rather retain all the flexibility of the builtin printf's. IMO, the builtins should have started from this idea and wrapped it in the current va_list implementation, which would have been much easier than the other way around.

Maybe something like:

Code:

#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>

#define VSNBUFF   32

int asprintf(char **dst, const char *fmt, ...) {
   size_t length = 2 * strlen(fmt);   /* Estimate total length */
   char *tmp;
   va_list arglist;
   int chk;
   if(length < VSNBUFF)
       length = VSNBUFF;
   tmp = (char*)malloc(length + 1);
   if(!tmp)
       return(-1);
   for(;;)
       {
       va_start(arglist, fmt);
       chk = vsnprintf(tmp, length, fmt, arglist);
       va_end(arglist);
       if((size_t)chk >= length)
           length += length;
       else
           break;
       tmp = (char*)realloc(tmp, length + 1);
       if(!tmp)
           return(-1);
       }
  tmp[chk] = 0;
  *dst = tmp;
  return(chk);
}

int main()
{
   char *s;
   asprintf(&s, "%c %d %f %s", 'x', 10, 0.5, "abc");
   puts(s);
}

Of course, this totally depends on vsnprintf being in your library (Don't know if it's standard, but most implementations have it).

You'll need something like va_args if you plan on passing countless random data types to it. Then you'll want to add a case statement, and process the character after the % sign to see what type of data it is, and append that instead of just doing a strcat. (Actually, you can still do a strcat if you want. Just sprintf to a temporary buffer, and strcat that.)


Quzah.

Well you can use an array of void pointers instead, so long as you set up dereferencing them correctly through a switch or what not. But va_args was basically designed for just that sort of job.


Quzah.

Ronix: Yeah, I'm going for a void**. Although the combination of void** and unlimited length may be too ambitious for anyone who's not a genius and/or billionaire.

Quzah: I was really hoping to simply wrap the standard sprintf and not mess with the switch and whatnot, but that may be completely impossible for anything short of a preprocessor (and a preprocessor designed around its product language's library would be a little weird). As I noted in an earlier post, I think this should have been in the standard...

Function signature, possibly with an additional argument for the length of 'args', or a requirement that it be null-terminated:

Code:

void _sprintf(char *result, char *format, void **args);

(I'm not sure what should replace the underscore.)

It depends really on what, or rather how, you are getting 'args', and how you expect to pass those. Is there some reason you need an array of random stuff to pass as an argument?

Quzah.

Well, I gave it a try. Although it's by no means perfect, and I still think the variadic form is far superior.

Code:

#include <stdio.h>
#include <string.h>

int qualifier(char c) {
    static char lookup[] = { 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1,
        1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1
    };
    return(c >= 'E' && c <= 's'&& lookup[c - 'E'] == 1);
}

#define LOWER(C)  (((C) >= 'A' && (C) <= 'Z')? (C) - 'A' + 'a' : (C))

int xsprintf(char *dst, const char *fmt, void **args) {
    char *end = dst;
    const char *fmt_begin;
    void *arg;
    if(!dst || !fmt || !args)
        return(-1);
    while(*fmt)
        {
        if(*fmt == '%')
            {
            fmt_begin = fmt++;
            if(*fmt == '%')
                *end++ = '%';
            else
                {
                char fmt2[8] = { '%' };
                int len;
                for(; !qualifier(*fmt); ++fmt);
                len = fmt - fmt_begin;
                if(len)
                    memcpy(fmt2 + 1, fmt_begin + 1, len);
                fmt2[len] = *fmt, fmt2[len + 1] = 0;
                arg = *args++;
                switch(*fmt)
                    {
                    case 'c':
                        *end++ = *(char*)arg;
                        break;
                    case 'x':
                    case 'X':
                    case 'o':
                    case 'i':
                    case 'd':
                        {
                        char buffer[sizeof(long) * 8];
                        unsigned long val;
                        val = *(fmt - 1) == 'h'? *(short*)arg :
                            *(fmt - 1) == 'd'? *(int*)arg :
                            *fmt == 'p'? (unsigned long)arg : *(long*)arg;
                        len = sprintf(buffer, fmt2, val);
                        if(len < 0)
                            return(-1);
                        memcpy(end, buffer, len);
                        end += len;
                        }
                        break;
                    case 'e':
                    case 'E':
                    case 'f':
                    case 'F':
                    case 'g':
                    case 'G':
                        {
                        char buffer[512];
                        long double val = LOWER(*(fmt - 1)) == 'h'?
                            *(float*)arg : LOWER(*(fmt - 1)) == 'L'?
                            *(long double*)arg : *(double*)arg;
                        fmt2[len] = 'L', fmt2[len + 1] = 'f', fmt2[len + 2] = 0;
                        len = sprintf(buffer, fmt2, val);
                        if(len < 0)
                            return(-1);
                        memcpy(end, buffer, len);
                        end += len;
                        }
                        break;
                    case 's':
                        {
                        if(*fmt_begin == '.')
                            {
                            len = (int)strtol(fmt_begin, NULL, 10);
                            strncpy(end, (const char*)arg, len);
                            }
                        else
                            {
                            len = (int)strlen((const char*)arg);
                            memcpy(end, (const char*)arg, len);
                            }
                        end += len;
                        }
                        break;
                    case 'n':
                        *(int*)arg = end - dst;
                        break;
                    default:
                        return(-1);
                    }
                }
            }
        else
            *end++ = *fmt;
        ++fmt;
        }
    *end = 0;
    return(end - dst);
}

int main()
{
    char s[100];
    int i = 10;
    double d = 0.5;
    char c = 'y';
    void *p[] = { &i, &d, &c, "Foo" };
    xsprintf(s, "%3d %.2f %c %s %%100", p);
    puts(s);
}

There are several problems with my function: There's no format string checking (You could achieve this via compiler builtins, like the ones included in gcc), there's no support for some of the newest additions ($ position modifiers; 'z', 'j' and 't' qualifiers; and lack of locale-dependant grouping) and there may be an overflow with very large floating point values (Don't know if 512 characters is enough).

Eventually, you could lose all the sprintf calls and use your own functions to convert numeric variables into strings.