Appeler dynamiquement une fonction C avec un argument varargs

Dans CamelBones-je utiliser libffi appeler objc_msgSend(), qui est un varargs fonction. Fonctionne un régal.

Puisqu'il n'est généralement pas un problème pour passer plus des arguments à une fonction prenant variable d'arguments que la fonction attend (voir note de bas de page n ° 1), vous pouvez faire quelque chose comme ce qui suit:

//you didn't give a clear specification of what you want/need, so this 
//example may not be quite what you want as I've had to guess at
//some of the specifications. Hopefully the comments will make clear
//what I may have assumed.
//
//NOTE:  while I have compiled this example, I have not tested it,
//       so there is a distinct possiblity of bugs (particularly
//       off-by-one errors). Check me on this stuff, please.
//I made these up so I could compile the example
#define ITEMDATA ((char const*) NULL)
#define ENDITEM  ((char const*) 0xffffffff)
void web_submit_data_wrapper( const char*bufferName, 
const char* bufferValue, 
size_t headerCount,       //number of header pointers to pass (8 in your example)
size_t itemStartIndex,    //index where items start in the buffers (11 in your example)
size_t itemCount,         //number of items to pass (unspecified in your example)
size_t dataSize )         //size of each header or item (129 in your example)
{
//kMaxVarArgs would be 3000 or a gazillion in your case
//size_t const kMaxVarArgs = 20;  //I'd prefer to use this in C++
#define kMaxVarArgs (20)
typedef char const* char_ptr_t;
typedef char_ptr_t char_ptr_array_t[kMaxVarArgs];
char_ptr_array_t varargs = {0};
size_t idx = 0;
//build up the array of pararmeters we'll pass to the variable arg list
//first the headers
while (headerCount--) {
varargs[idx++] = &bufferName[idx * dataSize];
}
//mark the end of the header data
varargs[idx++] = ITEMDATA;
//now the "items"
while (itemCount--) {
varargs[idx++] = &bufferName[itemStartIndex * dataSize];
varargs[idx++] = &bufferValue[itemStartIndex * dataSize];
varargs[idx++] = ENDITEM;
++itemStartIndex;
}
//the thing after the last item 
//(I'm not sure what this is from your example)
varargs[idx] = &bufferName[itemStartIndex * dataSize];
//now call the target function - the fact that we're passing more arguments
// than necessary should not matter due to the way VA_ARGS are handled 
// but see the Footnote in the SO answer for a disclaimer
web_submit_data( 
varargs[0],
varargs[1],
varargs[2],
//... ad nasuem until
varargs[kMaxVarArgs-1]
);
}

Note de bas de page n ° 1: Si vous pensez à la façon dont les macros dans stdargs.h loi, cela devient clair. Cependant, je ne prétends pas que cette technique pourrait être conformes aux normes. En fait, dans l'histoire récente, le stackoverflow réponses que j'ai posté où j'ai fait cet avertissement ont en effet été jugés non-conformes aux normes (en général, par le vigilant litb). Afin d'utiliser cette technique à vos propres risques, et de vérifier, vérifier, vérifier).

Remarque: le code est déjà compilateur-dépendante (mais peut-être pas de processeur-dépendant), parce que l'invocation de web_submit_data suppose que l'argument sous-expressions dans un appel de procédure sont évaluées de gauche à droite, mais le langage C, les feuilles de l'ordre de l'argument de l'évaluation quelconque.

Voir pour référence: http://en.wikipedia.org/wiki/Evaluation_strategy#Call_by_value

Alors peut-être que la non-solution portable ne va pas faire des choses bien pire pour vous.

Écrire une fois avec le préprocesseur et ne jamais regarder en arrière.

#define WEB_SUBMIT_BUFFER(name, val)         \
do {                                     \
const int size = 129;                \
int i = 0;                           \
int j = 11;                          \
web_submit_data(&(name)[i++ * size], \
&(name)[i++ * size], \
/* etc ad nauseum */                 \
} while (0)

Ou si le nombre d'arguments est fixé pour chaque appel, écrire un script pour générer des préprocesseur pour cacher la façon dont odieux que l'appel est.

#define WEB_SUBMIT_BUFFER_32(name, val)      \
do {                                     \
const int size = 129;                \
int i = 0;                           \
int j = 11;                          \
web_submit_data(&(name)[i++ * size], \
&(name)[i++ * size], \
/* 32 times */                       \
} while (0)
#define WEB_SUBMIT_BUFFER_33(name, val) ...
#define WEB_SUBMIT_BUFFER_34(name, val) /* etc */

Il y a deux façon de passer un nombre variable d'arguments: une fonction qui accepte "..." ou à une fonction qui accepte va_list.

Vous ne pouvez pas définir dynamiquement le nombre d'arguments pour les "..." de l'interface, mais vous devriez être capable de le faire pour le va_list. Google pour va_start, va_end, et va_list.