How do I do generic programming in C?

Greetings, group.  I have a situation at work in which our software
(running
on a PC) needs to talk to two different versions of our firmware (running
on
circuit boards in boxes hundreds of feet away, communicating via RS232).

The two firmware versions (1400 and 1600) are very similar, with 1600
having
a few more members in each of several key structs used for communicating
and
storing data.  (Alas, the added members were scattered through the structs
by our firmware designer, instead of being added only at the end.  Sigh.)

I use the 1600 structs in the PC software to hold data from both firmware
types, but for communications, the correct struct MUST be used,
because the firmware is expecting a data packet of a certain length, with
the data members in a certain order.

SO, i had to create "Expand" and "Extract" functions to convert between
the two versions of the "setup_t" structure, like so:

int ExpandSetupFrom1400 (setup1400_t const *in, setup_t *out)
{
  if (!in || !out) return 666;

  memset(out, 0, sizeof(*out));

  out->CoolStages         = in->CoolStages;
  out->HeatStages         = in->HeatStages;
  out->StageWidth         = in->StageWidth;
  out->TimePeriods        = in->TimePeriods;
  (several hundred more lines of "out->foo = in->foo;")

  return 42;
} // end ExpandSetupFrom1400()

int ExtractSetupTo1400 (setup_t const *in, setup1400_t *out)
{

  ***EXACT SAME FUNCTION BODY AS "ExpandSetupFrom1400()"!!!***

} // end ExtractSetupTo1400()

This is ridiculous!  I now have two HUGE functions with the exact
same function body!  The only difference is the paramater types.

I suppose I could put the function body in a separate C file and
#include it, like so:

int ExpandSetupFrom1400 (setup1400_t const *in, setup_t *out)
{
   #include "common_body.c"
}

int ExtractSetupTo1400 (setup_t const *in, setup1400_t *out)
{
   #include "common_body.c"
}

But that makes it impossible to assign breakpoints or use the
debugger.

Is there some way of switching parameter types at runtime, ala
C++ "templates"?  Basically, "generic programming", but in C rather
than in C++?

I tried some ideas, but they didn't work.  For example:

int ExpandExtract (void * in, void * out)
{
  if (!in || !out) return 666;

  memset(out, 0, sizeof(*out));
  out->CoolStages         = in->CoolStages;  // ERROR!
  out->HeatStages         = in->HeatStages;  // ERROR!
  out->StageWidth         = in->StageWidth;  // ERROR!
  out->TimePeriods        = in->TimePeriods; // ERROR!
  (several hundred more lines of "out->foo = in->foo;")
  return 42;
}

(Compiler screams: "Error! Can't access members of objects
via void pointers" or words to that effect.)

If this was C++, I'd make the expand/extract function a template:

template<class A, class B>
int ExpandExtract (A* in, void B* out)
{
   out->foo = in->foo;
   out->bar = in->bar;
   etc, etc, etc...
}

and call it like so:

   ExtractExpandSetup<setup_t, setup_1400_t>(a,b);

So... is there any way of emulating templates in C?
Or do I just have to live with duplicate functions?

-- 
Cheers,
Robbie Hatley
lonewolf aatt well dott com
www dott well dott com slant user slant lonewolf slant