how to generate this code?

[Roberto Gori]

Hi all,

i'm looking for a way, a tool or a macro like this:

USEFULMACRO(foo, bar, type1 arg1, type2 arg2, ..., typeN argN)

to generate the following code:

void foo(type1 arg1, type2 arg2, ..., typeN argN)
{
bar(arg1, arg2, ..., argN);
}

N is variable.
The function "foo" invokes "bar" with the same arguments list.
All the C++ types are admitted (function pointers included).

Some idea?

[Victor Bazarov]

Roberto Gori wrote:

i'm looking for a way, a tool or a macro like this:

USEFULMACRO(foo, bar, type1 arg1, type2 arg2, ..., typeN argN)

to generate the following code:

void foo(type1 arg1, type2 arg2, ..., typeN argN)
{
bar(arg1, arg2, ..., argN);
}

N is variable.
The function "foo" invokes "bar" with the same arguments list.
All the C++ types are admitted (function pointers included).

Some idea?

Since you have to separate names of arguments from their types in the
macro when it's generated, you need to separate them in the macro arg
list:

USEFULMACRO(foo, bar, type1, arg1, ...

Otherwise "type1 arg1" is a single preprocessing token, and there are no
means to "split" it into two using any preprocessor mechanisms.

Since you want a variable number of arguments, you need a compiler
capable of macros with variable number of arguments, otherwise you have
to generate all macros up to maximum number of args your system is going
to handle. See "variadic macro" in the archives. Some compilers can do
that. It's not a standard construct yet, though.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Ron Natalie]

Roberto Gori wrote:

Hi all,

i'm looking for a way, a tool or a macro like this:

USEFULMACRO(foo, bar, type1 arg1, type2 arg2, ..., typeN argN)

to generate the following code:

void foo(type1 arg1, type2 arg2, ..., typeN argN)
{
bar(arg1, arg2, ..., argN);
}

N is variable.
The function "foo" invokes "bar" with the same arguments list.
All the C++ types are admitted (function pointers included).

Some idea?

Can't be done. First, there is no such concept as
variable arguments in the middle of the arg list. They
must be at the end. Second, the only thing you can
do with variable args is extract them with the cstdarg
macros. You can't pass them en masse to another ...
expecting function.

[Victor Bazarov]

Ron Natalie wrote:

Roberto Gori wrote:

>Hi all,

i'm looking for a way, a tool or a macro like this:

USEFULMACRO(foo, bar, type1 arg1, type2 arg2, ..., typeN argN)

to generate the following code:

void foo(type1 arg1, type2 arg2, ..., typeN argN)
{
bar(arg1, arg2, ..., argN);
}

N is variable.
The function "foo" invokes "bar" with the same arguments list.
All the C++ types are admitted (function pointers included).

Some idea?

Can't be done. First, there is no such concept as
variable arguments in the middle of the arg list. They
must be at the end. Second, the only thing you can
do with variable args is extract them with the cstdarg
macros. You can't pass them en masse to another ...
expecting function.

I don't think the variable arguments in the middle is what OP wants. I
also don't think that passing them en masse is the goal. Let's say we
only have three (or four, depending on how you count) things there:

USEFULMACRO(foo, bar, type arg)

What would be its definition so it is possible to generate this code:

void foo(type arg) {
bar(arg);
}

?

Methinks the problem is trying to extract the second word (token) "arg"
from the third macro argument.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Phlip]

Roberto Gori wrote:

i'm looking for a way, a tool or a macro like this:

USEFULMACRO(foo, bar, type1 arg1, type2 arg2, ..., typeN argN)

Long argument lists are a "design smell". That means they are an indicator
that other parts of your design could be better.

Why aren't all those arguments elements of a collection, such as an
std::map<>? Or even data stored in a class?

--
Phlip
http://c2.com/cgi/wiki?ZeekLand <-- NOT a blog!!!

[Roberto Gori]

"Victor Bazarov" <v.********@comAcast.netwrote in message
news:ea**********@news.datemas.de...

Roberto Gori wrote:

>i'm looking for a way, a tool or a macro like this:

USEFULMACRO(foo, bar, type1 arg1, type2 arg2, ..., typeN argN)

to generate the following code:

void foo(type1 arg1, type2 arg2, ..., typeN argN)
{
bar(arg1, arg2, ..., argN);
}

N is variable.
The function "foo" invokes "bar" with the same arguments list.
All the C++ types are admitted (function pointers included).

Some idea?

Since you have to separate names of arguments from their types in the
macro when it's generated, you need to separate them in the macro arg
list:

USEFULMACRO(foo, bar, type1, arg1, ...

Otherwise "type1 arg1" is a single preprocessing token, and there are no
means to "split" it into two using any preprocessor mechanisms.

I think that when the argument is a function pointer (something like float
(*pt2Func)(float, float) ) it's not possible to separate the tokens with
commas.

>
Since you want a variable number of arguments, you need a compiler
capable of macros with variable number of arguments, otherwise you have
to generate all macros up to maximum number of args your system is going
to handle. See "variadic macro" in the archives. Some compilers can do
that. It's not a standard construct yet, though.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Jakob Bieling]

Roberto Gori <r.****@cineca.itwrote:

"Victor Bazarov" <v.********@comAcast.netwrote in message
news:ea**********@news.datemas.de...

>Roberto Gori wrote:

>>i'm looking for a way, a tool or a macro like this:

USEFULMACRO(foo, bar, type1 arg1, type2 arg2, ..., typeN argN)

to generate the following code:

void foo(type1 arg1, type2 arg2, ..., typeN argN)
{
bar(arg1, arg2, ..., argN);
}

N is variable.
The function "foo" invokes "bar" with the same arguments list.
All the C++ types are admitted (function pointers included).

Some idea?

Since you have to separate names of arguments from their types in the
macro when it's generated, you need to separate them in the macro arg
list:

USEFULMACRO(foo, bar, type1, arg1, ...

Otherwise "type1 arg1" is a single preprocessing token, and there
are no means to "split" it into two using any preprocessor
mechanisms.

I think that when the argument is a function pointer (something like
float (*pt2Func)(float, float) ) it's not possible to separate the
tokens with commas.

Use a typedef, then it works.

regards
--
jb

(reply address in rot13, unscramble first)

[Victor Bazarov]

Roberto Gori wrote:

>Roberto Gori wrote:

>>i'm looking for a way, a tool or a macro like this:

USEFULMACRO(foo, bar, type1 arg1, type2 arg2, ..., typeN argN)

to generate the following code:

void foo(type1 arg1, type2 arg2, ..., typeN argN)
{
bar(arg1, arg2, ..., argN);
}

N is variable.
The function "foo" invokes "bar" with the same arguments list.
All the C++ types are admitted (function pointers included).

Some idea?

[..]

I think that when the argument is a function pointer (something like
float (*pt2Func)(float, float) ) it's not possible to separate the
tokens with commas.

Right. That's why using macro is not a good idea. Perhaps you could use
some custom pre-processor. Something like TrollTech's "moc"...

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Roberto Gori]

"Victor Bazarov" <v.********@comAcast.netwrote in message
news:ea**********@news.datemas.de...

Roberto Gori wrote:

>>Roberto Gori wrote:
i'm looking for a way, a tool or a macro like this:

USEFULMACRO(foo, bar, type1 arg1, type2 arg2, ..., typeN argN)

to generate the following code:

void foo(type1 arg1, type2 arg2, ..., typeN argN)
{
bar(arg1, arg2, ..., argN);
}

N is variable.
The function "foo" invokes "bar" with the same arguments list.
All the C++ types are admitted (function pointers included).

Some idea?
[..]

I think that when the argument is a function pointer (something like
float (*pt2Func)(float, float) ) it's not possible to separate the
tokens with commas.

Right. That's why using macro is not a good idea. Perhaps you could use
some custom pre-processor. Something like TrollTech's "moc"...

I suspect you are right and moc it's not free. :(

>
V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Victor Bazarov]

Roberto Gori wrote:

"Victor Bazarov" <v.********@comAcast.netwrote in message
news:ea**********@news.datemas.de...

>[..] Perhaps you
could use some custom pre-processor. Something like TrollTech's
"moc"...

I suspect you are right and moc it's not free. :(

I wasn't suggesting that you acquired (licensed) 'moc' from TrollTech.
But you can probably write your own, the tools to parse C++ source code
are all there, and there's probably plenty of free ones on the Web.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Roberto Gori]

"Victor Bazarov" <v.********@comAcast.netwrote in message
news:ea**********@news.datemas.de...

Roberto Gori wrote:

>"Victor Bazarov" <v.********@comAcast.netwrote in message
news:ea**********@news.datemas.de...

>>[..] Perhaps you
could use some custom pre-processor. Something like TrollTech's
"moc"...

I suspect you are right and moc it's not free. :(

I wasn't suggesting that you acquired (licensed) 'moc' from TrollTech.
But you can probably write your own, the tools to parse C++ source code
are all there, and there's probably plenty of free ones on the Web.

Many thanks Victor.

i'm searching in the Web.

>
V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Phlip]

Roberto Gori wrote:

Victor Bazarov wrote:

>I wasn't suggesting that you acquired (licensed) 'moc' from TrollTech.
But you can probably write your own, the tools to parse C++ source code
are all there, and there's probably plenty of free ones on the Web.

Many thanks Victor.

AI thought Trolltech's Moc system, itself, was Free as in Beer, and
that only the high-end Qt was payware. I could be wrong, but...

BAdding keywords to your language (that's what Moc does) is not
a healthy way to add variable arguments to your macro.

You could do this:

MACRO(target, (arg1, arg2, arg3, argN))

Then only one macro parameter can represent all the variable arguments, with
their ().

Next, you could answer my question about what problem you are trying to
solve. There could be a cleaner way to do it that doesn't need a macro.

(BTW: Add keywords to the language just so we can abuse a macro? There just
aren't words..!)

--
Phlip
http://c2.com/cgi/wiki?ZeekLand <-- NOT a blog!!!

[Roberto Gori]

"Phlip" <ph******@yahoo.comwrote in message
news:Kd*********************@newssvr21.news.prodig y.com...

Roberto Gori wrote:

>Victor Bazarov wrote:

>>I wasn't suggesting that you acquired (licensed) 'moc' from TrollTech.
But you can probably write your own, the tools to parse C++ source code
are all there, and there's probably plenty of free ones on the Web.

Many thanks Victor.

AI thought Trolltech's Moc system, itself, was Free as in Beer, and
that only the high-end Qt was payware. I could be wrong, but...

BAdding keywords to your language (that's what Moc does) is not
a healthy way to add variable arguments to your macro.

I agree with you but ...

>
You could do this:

MACRO(target, (arg1, arg2, arg3, argN))

Then only one macro parameter can represent all the variable arguments,
with their ().

.... this macro is able to generate (with all types and names):

foo(arg1, arg2, arg3, argN)

but not:

bar(name_of_arg1, name_of_arg2, name_of_arg3, name_of_argN);

>
Next, you could answer my question about what problem you are trying to
solve. There could be a cleaner way to do it that doesn't need a macro.

the problem is to generate a code like this:

void foo(int a, char b, void (*f)(int), double g[], float c=5)
{
bar(a, b, f, g, c);
}

starting from some function name (foo) and some arguments list (int a, char
b, void (*f)(int), double g[], float c=5)

Maybe your question is: why foo must invoke bar in this way, with the same
parameters?
Bacause i want to generate a class (the owner of foo) that support a typed
callback (bar).

>
(BTW: Add keywords to the language just so we can abuse a macro? There
just aren't words..!)

--
Phlip
http://c2.com/cgi/wiki?ZeekLand <-- NOT a blog!!!

[Phlip]

Roberto Gori wrote:

the problem is to generate a code like this:

What is the _outer_ problem? You envision a solution. What is the problem
that solution might solve?

Maybe your question is: why foo must invoke bar in this way, with the same
parameters?
Bacause i want to generate a class (the owner of foo) that support a
typed callback (bar).

Please provide some pseudo-code showing this rig in use, with its callers.

--
Phlip
http://c2.com/cgi/wiki?ZeekLand <-- NOT a blog!!!

[Howard]

"Roberto Gori" <r.****@cineca.itwrote in message
news:ea**********@news.cineca.it...

>

Maybe your question is: why foo must invoke bar in this way, with the same
parameters?
Bacause i want to generate a class (the owner of foo) that support a
typed callback (bar).

Then perhaps what you want is some kind of dispatch mechanism?

For example, we have some software which has a single global callback
function, which receives a pointer to an instance of the class in question.
This calback simply calls a "dispatcher" member function of the class using
that instance pointer, so that we can manipulate the specific instance as
needed.

We also pass a pointer to a structure containing information about what we
want the object to actually do. It contains an integer (enum) code that
tells us what we want to do, followed by the data we want to work on. We
use a short array of float values, but you could use a string, or a vector
of floats, or a vector of "generic" objects (I think Boost has some kind of
generic object holder).

The dispatcher uses a switch statement to call a sepcific function, passing
it the parameters from our array which are appropriate for the function
being performed.

Just a thought...

-Howard

[Roberto Gori]

"Phlip" <ph******@yahoo.comwrote in message
news:iI*********************@newssvr21.news.prodig y.com...

Roberto Gori wrote:

>the problem is to generate a code like this:

What is the _outer_ problem? You envision a solution. What is the problem
that solution might solve?

>Maybe your question is: why foo must invoke bar in this way, with the
same parameters?
Bacause i want to generate a class (the owner of foo) that support a
typed callback (bar).

Please provide some pseudo-code showing this rig in use, with its callers.

class Observer
{
virtual void OnEvent(arglist)
{
//do something
}
}

class Event
{
Observer *obs;
void Notify(arglist) {
obs->OnEvent(arglist)
}
}

void main ()
{
Event e;
Observer o;

e.obs = &o;

//in some case someone calls
e.Notify(arglist);
}

to give this example i simplified all the object interfaces but my aim is to
have multiple events with different arglists.

--
Phlip
http://c2.com/cgi/wiki?ZeekLand <-- NOT a blog!!!

[Roberto Gori]

"Howard" <al*****@hotmail.comwrote in message
news:wP********************@bgtnsc04-news.ops.worldnet.att.net...

>
"Roberto Gori" <r.****@cineca.itwrote in message
news:ea**********@news.cineca.it...

>>

>Maybe your question is: why foo must invoke bar in this way, with the
same parameters?
Bacause i want to generate a class (the owner of foo) that support a
typed callback (bar).

Then perhaps what you want is some kind of dispatch mechanism?

Exactly Howard!

>
For example, we have some software which has a single global callback
function, which receives a pointer to an instance of the class in
question. This calback simply calls a "dispatcher" member function of the
class using that instance pointer, so that we can manipulate the specific
instance as needed.

We also pass a pointer to a structure containing information about what we
want the object to actually do. It contains an integer (enum) code that
tells us what we want to do, followed by the data we want to work on. We
use a short array of float values, but you could use a string, or a vector
of floats, or a vector of "generic" objects (I think Boost has some kind
of generic object holder).

The dispatcher uses a switch statement to call a sepcific function,
passing it the parameters from our array which are appropriate for the
function being performed.

I understand this method but i would like to avoid the packing/unpacking of
parameters because this could be unefficient and error prone.
Moreover i would like to preserve legacy code by inserting only the call to
the notification routine.

for example:

if i have a Foo class i would like to extend them in this way

class NewFoo: public EventNotifier
{
void SomeMethod( ...)
{
.....
NotifyEvent(val1, val2, ....);
.....
}
}

>
Just a thought...

-Howard

[Phlip]

Roberto Gori wrote:

e.Notify(arglist);
}

to give this example i simplified all the object interfaces but my aim is
to have multiple events with different arglists.

So arglist is an object with a list of arguments inside it.

All GUIs use this pattern for their event queues. The raw event has a short
list of parameters, and custom events for advanced inputs, such as a list
box selection, have longer lists, such as the index of the selected item.

--
Phlip
http://c2.com/cgi/wiki?ZeekLand <-- NOT a blog!!!

[Roberto Gori]

"Phlip" <ph******@yahoo.comwrote in message
news:2O********************@newssvr29.news.prodigy .net...

Roberto Gori wrote:

>e.Notify(arglist);
}

to give this example i simplified all the object interfaces but my aim is
to have multiple events with different arglists.

So arglist is an object with a list of arguments inside it.

i would prefer arglist as a list of arguments and not an object because i
would like to reuse directly callbacks of a legacy code (like OnEvent(int x,
int y)) without packing/unpacking the parameters in some object/structure.

>
All GUIs use this pattern for their event queues. The raw event has a
short list of parameters, and custom events for advanced inputs, such as a
list box selection, have longer lists, such as the index of the selected
item.

>
--
Phlip
http://c2.com/cgi/wiki?ZeekLand <-- NOT a blog!!!

[Phlip]

Roberto Gori wrote:

i would prefer arglist as a list of arguments and not an object because i
would like to reuse directly callbacks of a legacy code (like OnEvent(int
x, int y)) without packing/unpacking the parameters in some
object/structure.

If a legacy code had a poor design, I would work harder to fix that than to
adapt to it.

However, you can easily get your technique here:

http://www.codeproject.com/macro/metamacros.asp

--
Phlip
http://c2.com/cgi/wiki?ZeekLand <-- NOT a blog!!!

[Roberto Gori]

"Phlip" <ph******@yahoo.comwrote in message
news:25*************@newssvr14.news.prodigy.com...

Roberto Gori wrote:

>i would prefer arglist as a list of arguments and not an object because i
would like to reuse directly callbacks of a legacy code (like OnEvent(int
x, int y)) without packing/unpacking the parameters in some
object/structure.

If a legacy code had a poor design, I would work harder to fix that than
to adapt to it.

However, you can easily get your technique here:

http://www.codeproject.com/macro/metamacros.asp

i'm already faced to this kind of approach to link an enum to a vector of
strings but ...

could you give me an example on how to apply it to my case?

Are you thinking to something like this?

META(foo, bar, _m(type1) ident1, _m(type2) ident2, ...)

in this case is up to the developer to establish what's the type e what's
the identifier of the argument. Moreover for some types as the function
pointer type it's not simple to use that syntax without a typedef.
Since a complex system could contains a lot of events i would like to
generate automatically all the interfaces.
I would like to write in a text file something like that:

event_a, arg1_of_a, arg2_of_a, arg3_of_a
event_b, arg1_of_b, arg2_of_b
event_c, arg1_of_c, arg2_of_c, arg3_of_c, arg4_of_c

and for each declaration i would like to generate a header and a source
files (event_?.h event_a.cpp) containing the implementation of the
event/observer pattern for each event. The classes differ for the argument
list only.

--
Phlip
http://c2.com/cgi/wiki?ZeekLand <-- NOT a blog!!!

[Christian Gollwitzer]

Roberto Gori wrote

the problem is to generate a code like this:

void foo(int a, char b, void (*f)(int), double g[], float c=5)
{
bar(a, b, f, g, c);
}

And what about a function template?

template <typename A,B,C,D,E>
void foo(A a, B b, C c, D d, E e)
{
bar (a,b,c,d,e);
}

should be typesafe and if you provide the same template with
zero,1,2,3... parameters you can pass anything. You can make these
templates out of a macro, or maybe some template guru knows how to do it
with metaprogramming.

Maybe have a look at libsigc++, which does something similiar, if I
understood it correctly, tom implement a GUI callback system for GTK.

Christian

[Victor Bazarov]

Christian Gollwitzer wrote:

Roberto Gori wrote

>the problem is to generate a code like this:

void foo(int a, char b, void (*f)(int), double g[], float c=5)
{
bar(a, b, f, g, c);
}

And what about a function template?

template <typename A,B,C,D,E>

A nit picked:

template<typename A, typename B, typename C, typename D, typename E>

void foo(A a, B b, C c, D d, E e)
{
bar (a,b,c,d,e);
}

should be typesafe and if you provide the same template with
zero,1,2,3... parameters you can pass anything. You can make these
templates out of a macro, or maybe some template guru knows how to do
it with metaprogramming.

If you wrap it in a macro (that I suppose will have to be variadic anyway)
is that it will provide the compiler with way too many functions than
maybe needed (a template is an rather large number when only one was
intended). And if I wanted to make sure that conversions are involved,
I'd have to wrap it again in something.

But, of course, let the OP decide...

Maybe have a look at libsigc++, which does something similiar, if I
understood it correctly, tom implement a GUI callback system for GTK.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask