int function2(int*,int,int,int);

#define xyz(a,b,c) {\
int x[100],i; \
for(i=0;i<c;i++) x[i] = something(a,b,c); \
function2(x,a,b,c); \

Calls like:

  xyz(1,2,3);

work fine, other than the return value of "function2" gets thrown away.

Now, if I want to do this:

int jkl;
...
jkl = xyz(1,2,3);
...

where "jkl" is to get that value returned by "function2", how do I do
it? I'm having trouble with the syntax.

I want things to expand where:

  jkl = xyz(p,q,r);

expands equivalently to:
{
int x[100],i;
for(i=0;i<r;i++) x[i] = something(p,q,r);
jkl = function2(x,p,q,r);

There is a big picture question that might help to have answered.  Why
not use a function?  The answer may be that you can't re-write the two
called functions to take a va_list, but that as least rules out the
obvious solution.

void buildlist(unsigned int *,...);
int zlink(int(int,...),int,unsigned int *);

#define LINKX(routine,flags,...)\
   {unsigned int list[MAXARGS];\
   buildlist(list,__VA_ARGS__);\
   j = zlink((routine),(flags),list);\
   }

"routine" is a function (one of many) called by zlink with a specialized
parameter list in array list, and the functions cannot be changed.  It
returns int.

zlink() cannot be changed.

The "j=zlink()" is a hack to get the return value out.

Calls are like this:

int returnvalue1,returnvalue2;
int j;
int module1(int,...),module2(int,...);
...
LINKX(module1,flag,1,2,3);
returnvalue1=j;
...
LINKX(module2,flag2,4,5,6,7,8,9);
returnvalue2=j;
...
I'd like to eliminate the "j=zlink() hack and change things so calls are
like this:

Usage:
LINKX(module2,flag2,returnvalue2,4,5,6,7,8,9);

This is what pete was suggesting I'd guess, why did you think it a bad
idea?

[... putting back snipped context ...]

Now, this goes against many people's coding standards, as it hides the fact
that it's going to change the value of that first parameter, but it does "work".

You could "unhide" this a little, by putting:

     (*retval) = function2(x,p,q,r);

and passing:

     xyz(&jkl,1,2,3);

It looks ugly, but again, it "works".

A minor(?) nit here is the "extraneous" semicolon in this syntax.  Consider:

     if ( foo )
         xyz(&jkl,1,2,3);
     else
         xyz(&jkl,4,5,6);

This will expand to:

     if ( foo )
        {
        your macro
        };
     else
        {
        your macro
        };

which will generate a syntax error.  (Or, worse, not generate one if this is
a nested if.)

I believe the "standard" way of handling this is to put the entire code
block in a do...while(0) loop:

     #define xyz(retval,x,y,z) do { \
         ... your code ...          \
         } while (0)

Note the lack of a terminating semicolon on the while.  This will be
supplied by the semicolon in the "call" to the macro.

  #define LINKX(routine, flags, ...)\
     zlink((routine), (flags),\
           buildlist((unsigned int[MAXARGS]){0}, __VA_ARGS__));

Alternatively, you might be able to share the temporary array:

  #define LINKX(routine, flags, ...)\
    (buildlist(shared_list, __VA_ARGS__),\
     zlink((routine), (flags), shared_list))

You then need to define shared_array in the containing block.  If
buildlist can use a static array and return that you could write:

  #define LINKX(routine, flags, ...)\
     zlink((routine), (flags), buildlist(__VA_ARGS__));

There is also a gcc-specific solution using ({}).

There is no such thing as a "function macro" or a "macro function" in C.
There are "function-like macros", but those are merely macros with
parameters.

Keep in mind that macro expansion is almost purely textual, and applies
only to the macro invocation itself.  For example, given:

    x = MY_MACRO(y, z);

the expansion of MY_MACRO can't do anything with x.

int zlink(int(int, ...), int, unsigned int *);
int zlink(int bar(int, ...), int flags, unsigned int *list) {
  return 12;

int main(void) {
  zlink_args mylist;
  int w, x, y, z;

  w = x = y = z = 10;
  return LINKX(foo, (1 << 3) & (1 << 4), mylist, w, x, y, z);

For example, why use a macro at all?  You could use a function that
allocates the array, populates it from arguments, then calls 'zlink'
and returns that call's result.

Also, consider a loop where we don't pass 'mylist':

enum { lim = 50 };
int i, rc, w, x, y, z;

w = x = y = z = 0;
for (i = 0; i < lim; i++) {
  rc = LINKX(foo, (1 << 3) & (1 << 4), w, x, y, z);
  if (rc) {
    /* ... */
  }