Call printf with dynamic arguments at runtime

Question

I try to write a wrapper for printf in C++. Of course i found va_list but dont know how its applicable to me because the wrapper will not be called directly. I will show later on.

I parse a script that includes a function with an unknown number of arguments like

ASTNode node(Token(PRINT, PRINT));
consume(PRINT);
consume(LPAREN);
node.make_child(variable()); // <-- formatstring (node.child[int])
while(current_token._type() != RPAREN) {
    consume(COMMA);
    node.make_child(variable()); // <-- the values to replace in formatstring (node.child[int++])
    i++; 
}
consume(RPAREN);
return node;

The first will be the formatstring and the others will be the values to replace in the format string so the function where i execute it will look like

if(node._token()._type() == PRINT) {
    Token formatstring = visit(*node.child[0]);
    Token temp;
    int i = 1;
    while(i < node.child.size()) {
        visit(*node.child[i++]); // <-- the values to replace in formatstring        
    }        
}

and doesnt take any "real" parameter. How can i build a dynamic parameter array using va_list or another method?

Thank you

Edit It seems my question is unclear to someone..

printf is called like printf(formatstring, param1, param2, param3...) and i want to do build the parameters passed after the first parameter (formatstring) in a loop like

// Pseudocode
out("printf(");
out($myformatstring);
int i = 1;
while(i<parameter_count) {
    out(parameter[i++]);
    out(",");
}
out(")");

Answer 1

As I understand you have a given format string, and "read/parse" arguments.

You have so 2 problems to handle, handling the format and using correct type for argument.

printf family doesn't support partial replacement (contrary to Qt for example, which allow QString("%1 %2").arg("Hello") resulting into QString("Hello %2") which allow chaining).

So you have to parse the full format string manually:

• print regular characters.

• when % is encountered, retrieve the flag format (unless it is %%, in that case display % directly).

• from flag format, switch to appropriate conversion, something like

   // flagFormat would "simply" be %i, %010d, %4.2f or %+.0e
   switch (format_type) {
       case EFormatType::String: // %s
            printf(flagFormat, to_string(args[i]).c_str()); break;
       case EFormatType::Int: // %i, %d
            printf(flagFormat, to_int(args[i])); break;
       case EFormatType::String: // %f, %F, %e, %g, %
            printf(flagFormat, to_double(args[i])); break;
       // ...
   }
   ++i;
  

Answer 2

// Pseudocode
// I would like to propose a way to solve the problem, added some stuff here

out("printf("); 

// you should create format string in accordance with types of parameters
$myformatstring = ""   // let suppose  myformatstring is of type "string"
                   // and it has defined operator "+=" (concatenation of strings)
for(int j = 0;j < parametar_count; j++)
{
    switch(parametar[j].type )  // suppose that you have type information of param's 
    {
        case 'i': myformatstring += " %d "; break;
        case 'f': myformatstring += " %f "; break;
        case 's': myformatstring += " %s"; break;
    ...  // you should handle all types you use ...

    }
}
$myformatstring += "\\n\","; // terminate format string and write a comma before 
                             // other arguments...
out($myformatstring);

int i = 1;
while(i<parameter_count) {
   out(parameter[i++]);
   if( i < parameter_count -1 )   // you don't need comma after last parameter 
      out(",");
}
out(");");

Answer 3

/* 
  there is example that explains how to use stdarg for a function 
  with variable number of parameters
*/ 



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

void myfunc(char* fmt, ...);

/* this example folows logic of printf to specify format
    %d - integer
    %c - single character
    %s - string
    other character will be copied to output
*/

int main( int argc, char* argv[])
{
    myfunc("%s %d ABCD %c", "a string", 4, 'D'); 
}


void myfunc(char *fmt, ...)
{
va_list ap;
int d;
char c, *s;

  va_start(ap, fmt);
  while (*fmt)
  {
    if(*fmt == '%')
    { 
       fmt++;
       switch (*fmt)     // detect format characters
       {
         case 's':              /* string format character is recognized*/
             s = va_arg(ap, char *);
             printf("string: %s\n", s);  /* this example just print out paramater, you can do what you want */
         break;

         case 'd':              /* integer format character */
             d = va_arg(ap, int);
             printf("int: %d\n", d);
         break;

         case 'c':              /* char format character*/
            c = (char) va_arg(ap, int);
            printf("char: %c\n", c);
         break;

     default:
       printf("Just copy non format characters %c\n",*fmt);  // copy non format characters after %
       } 
     }
     else
       printf("just copy '%c'\n", *fmt); 

    fmt++;
  }
  va_end(ap);
}