[cocci] match arbitrary argument position

[cocci] match arbitrary argument position

[Jakob Koschel]

Hi,

sorry if this question is not suiting here.

I went through the documentation and most of the examples I could find, but wasn't
able to easily answer my question I'm wondering about.

Basically: is there a way to match to *any* argument? E.g. make something match both of
the 'x' uses in the function calls here:

int x = 5;

function_call1(x, 12, 12);

function_call2(0, x);



Based on that I was wondering if there is a way to say: match if the expression is
within an expression list. So if I for instance have something like this:

  @main@
  type T;
  parameter list P;
  expression list E;
  expression E1;
  identifier func, func_call;
  @@

  T func(P@E) {
    ...
    func_call(E1 in E)
    ...
  }

(above is not valid syntax of course)

Ideally I would like to make and get the parameters of 'func' that are used in any position
as arguments in 'func_call' if that makes sense?


Any help is very much appreciated!

Thanks,
Jakob

Re: [cocci] match arbitrary argument position

[Julia Lawall]

On Tue, 16 Aug 2022, Jakob Koschel wrote:

> Hi,
>
> sorry if this question is not suiting here.
>
> I went through the documentation and most of the examples I could find, but wasn't
> able to easily answer my question I'm wondering about.
>
> Basically: is there a way to match to *any* argument? E.g. make something match both of
> the 'x' uses in the function calls here:
>
> int x = 5;
>
> function_call1(x, 12, 12);
>
> function_call2(0, x);

f(...,x,...)

or

f(...,<+...x...+>,...)

In the second case, x would be a subexpression of the considered argument.

julia


>
>
>
> Based on that I was wondering if there is a way to say: match if the expression is
> within an expression list. So if I for instance have something like this:
>
>   @main@
>   type T;
>   parameter list P;
>   expression list E;
>   expression E1;
>   identifier func, func_call;
>   @@
>
>   T func(P@E) {
>     ...
>     func_call(E1 in E)
>     ...
>   }
>
> (above is not valid syntax of course)
>
> Ideally I would like to make and get the parameters of 'func' that are used in any position
> as arguments in 'func_call' if that makes sense?
>
>
> Any help is very much appreciated!
>
> Thanks,
> Jakob
>

Re: [cocci] match arbitrary argument position

[Jakob Koschel]

> On 16. Aug 2022, at 13:37, Julia Lawall <Julia.Lawall@inria.fr> wrote:
> 
> 
> 
> On Tue, 16 Aug 2022, Jakob Koschel wrote:
> 
>> Hi,
>> 
>> sorry if this question is not suiting here.
>> 
>> I went through the documentation and most of the examples I could find, but wasn't
>> able to easily answer my question I'm wondering about.
>> 
>> Basically: is there a way to match to *any* argument? E.g. make something match both of
>> the 'x' uses in the function calls here:
>> 
>> int x = 5;
>> 
>> function_call1(x, 12, 12);
>> 
>> function_call2(0, x);
> 
> f(...,x,...)
> 
> or
> 
> f(...,<+...x...+>,...)
> 
> In the second case, x would be a subexpression of the considered argument.
> 
> julia
> 

Thanks! I really thought I tried that earlier but now it works.

> 
>> 
>> 
>> 
>> Based on that I was wondering if there is a way to say: match if the expression is
>> within an expression list. So if I for instance have something like this:
>> 
>>  @main@
>>  type T;
>>  parameter list P;
>>  expression list E;
>>  expression E1;
>>  identifier func, func_call;
>>  @@
>> 
>>  T func(P@E) {
>>    ...
>>    func_call(E1 in E)
>>    ...
>>  }
>> 
>> (above is not valid syntax of course)
>> 
>> Ideally I would like to make and get the parameters of 'func' that are used in any position
>> as arguments in 'func_call' if that makes sense?

Do you have any idea regarding the expression lists?

looking at the following code snippet:

test.c:

   int func1(int argc, char *argv) {
      func2(argc, argv);

      func3(argc, argv);

      func3(argv);
   }

what works is (only matches the first func3 call):

   @main4@
   expression list Es;
   @@

   func2(Es)

   @main5@
   expression list main4.Es;
   identifier func;
   @@

     func(Es);
   + // add comment


what doesn't work (matching on the expression list from the parameter list):

   @main4@
   expression list Es;
   @@

   int func1(Ps@Es) {
   ...
   }

   @main5@
   expression list main4.Es;
   identifier func;
   @@

     func(Es);
   + // add comment


Ideally I would like to 'find' all parameters used in a function call,
I also tried this:

   @main4@
   parameter P;
   expression E;
   @@

   int func1(..., P@E, ...) {
   ...
   }

   @main5@
   expression main4.E;
   identifier func;
   @@

     func(..., E, ...);
   + // add comment


But it throws: 'rule starting on line 41 contains unattached metavariables: main4.E'.

Any idea, why e.g. the second one doesn't work? If I print it with python the expression list
looks the same as for the first one.
Also in the end this boils down to: is it possible to match to any of the expression list elements?

Thanks,
Jakob

>> 
>> 
>> Any help is very much appreciated!
>> 
>> Thanks,
>> Jakob

Re: [cocci] match arbitrary argument position

[Markus Elfring]

> looking at the following code snippet:
>
> test.c:
…
>       func3(argc, argv);
>
>       func3(argv);


Would you like to handle function overloading here?



> what doesn't work (matching on the expression list from the parameter list):
>
>    @main4@
>    expression list Es;
>    @@
>
>    int func1(Ps@Es) {
>    ...
>    }


Which type would belong to the metavariable “Ps”?



> I also tried this:
>
>    @main4@
>    parameter P;
>    expression E;
>    @@
>
>    int func1(..., P@E, ...) {
>    ...
>    }


Does such SmPL code represent a contradiction?


Can any other descriptions indicate your data processing imaginations better?


>    @main5@
>    expression main4.E;
>    identifier func;
>    @@
>
>      func(..., E, ...);
>    + // add comment
>
>
> But it throws: 'rule starting on line 41 contains unattached metavariables: main4.E'.

Which software version did you try out here?

I am curious how corresponding considerations will evolve further.


Regards,
Markus

Re: [cocci] match arbitrary argument position

[Julia Lawall]

> >> Based on that I was wondering if there is a way to say: match if the expression is
> >> within an expression list. So if I for instance have something like this:
> >>
> >>  @main@
> >>  type T;
> >>  parameter list P;
> >>  expression list E;
> >>  expression E1;
> >>  identifier func, func_call;
> >>  @@
> >>
> >>  T func(P@E) {
> >>    ...
> >>    func_call(E1 in E)
> >>    ...
> >>  }
> >>
> >> (above is not valid syntax of course)
> >>
> >> Ideally I would like to make and get the parameters of 'func' that are used in any position
> >> as arguments in 'func_call' if that makes sense?
>
> Do you have any idea regarding the expression lists?
>
> looking at the following code snippet:
>
> test.c:
>
>    int func1(int argc, char *argv) {
>       func2(argc, argv);
>
>       func3(argc, argv);
>
>       func3(argv);
>    }
>
> what works is (only matches the first func3 call):
>
>    @main4@
>    expression list Es;
>    @@
>
>    func2(Es)
>
>    @main5@
>    expression list main4.Es;
>    identifier func;
>    @@
>
>      func(Es);
>    + // add comment
>
>
> what doesn't work (matching on the expression list from the parameter list):
>
>    @main4@
>    expression list Es;
>    @@
>
>    int func1(Ps@Es) {
>    ...
>    }
>
>    @main5@
>    expression list main4.Es;

Could you try

expression list main4.Ps;

It may transform the parameters into a list of expressions.

julia

>    identifier func;
>    @@
>
>      func(Es);
>    + // add comment
>
>
> Ideally I would like to 'find' all parameters used in a function call,
> I also tried this:
>
>    @main4@
>    parameter P;
>    expression E;
>    @@
>
>    int func1(..., P@E, ...) {
>    ...
>    }
>
>    @main5@
>    expression main4.E;
>    identifier func;
>    @@
>
>      func(..., E, ...);
>    + // add comment
>
>
> But it throws: 'rule starting on line 41 contains unattached metavariables: main4.E'.
>
> Any idea, why e.g. the second one doesn't work? If I print it with python the expression list
> looks the same as for the first one.
> Also in the end this boils down to: is it possible to match to any of the expression list elements?
>
> Thanks,
> Jakob
>
> >>
> >>
> >> Any help is very much appreciated!
> >>
> >> Thanks,
> >> Jakob
>
>

Re: [cocci] match arbitrary argument position

[Jakob Koschel]

> On 16. Aug 2022, at 23:07, Julia Lawall <Julia.Lawall@inria.fr> wrote:
> 
>>>> Based on that I was wondering if there is a way to say: match if the expression is
>>>> within an expression list. So if I for instance have something like this:
>>>> 
>>>> @main@
>>>> type T;
>>>> parameter list P;
>>>> expression list E;
>>>> expression E1;
>>>> identifier func, func_call;
>>>> @@
>>>> 
>>>> T func(P@E) {
>>>>   ...
>>>>   func_call(E1 in E)
>>>>   ...
>>>> }
>>>> 
>>>> (above is not valid syntax of course)
>>>> 
>>>> Ideally I would like to make and get the parameters of 'func' that are used in any position
>>>> as arguments in 'func_call' if that makes sense?
>> 
>> Do you have any idea regarding the expression lists?
>> 
>> looking at the following code snippet:
>> 
>> test.c:
>> 
>>   int func1(int argc, char *argv) {
>>      func2(argc, argv);
>> 
>>      func3(argc, argv);
>> 
>>      func3(argv);
>>   }
>> 
>> what works is (only matches the first func3 call):
>> 
>>   @main4@
>>   expression list Es;
>>   @@
>> 
>>   func2(Es)
>> 
>>   @main5@
>>   expression list main4.Es;
>>   identifier func;
>>   @@
>> 
>>     func(Es);
>>   + // add comment
>> 
>> 
>> what doesn't work (matching on the expression list from the parameter list):
>> 
>>   @main4@
>>   expression list Es;
>>   @@
>> 
>>   int func1(Ps@Es) {
>>   ...
>>   }
>> 
>>   @main5@
>>   expression list main4.Es;
> 
> Could you try
> 
> expression list main4.Ps;
> 
> It may transform the parameters into a list of expressions.

I just tried:

@main4@
parameter list Ps;
@@

int func1(Ps) {
...
}

@main5@
expression list main4.Ps;
identifier func;
@@

  func(Es);
+ // add comment

but that throws:

meta: semantic error: incompatible inheritance declaration Ps
  File "test.cocci", line 45, column 24, charpos = 539
  around = ';',
  whole content = expression list main4.Ps;

> 
> julia
> 
>>   identifier func;
>>   @@
>> 
>>     func(Es);
>>   + // add comment
>> 
>> 
>> Ideally I would like to 'find' all parameters used in a function call,
>> I also tried this:
>> 
>>   @main4@
>>   parameter P;
>>   expression E;
>>   @@
>> 
>>   int func1(..., P@E, ...) {
>>   ...
>>   }
>> 
>>   @main5@
>>   expression main4.E;
>>   identifier func;
>>   @@
>> 
>>     func(..., E, ...);
>>   + // add comment
>> 
>> 
>> But it throws: 'rule starting on line 41 contains unattached metavariables: main4.E'.
>> 
>> Any idea, why e.g. the second one doesn't work? If I print it with python the expression list
>> looks the same as for the first one.
>> Also in the end this boils down to: is it possible to match to any of the expression list elements?
>> 
>> Thanks,
>> Jakob
>> 
>>>> 
>>>> 
>>>> Any help is very much appreciated!
>>>> 
>>>> Thanks,
>>>> Jakob

Re: [cocci] match arbitrary argument position

[Jakob Koschel]

Hey,

> On 16. Aug 2022, at 19:55, Markus Elfring <Markus.Elfring@web.de> wrote:
> 
>> looking at the following code snippet:
>> 
>> test.c:
> …
>>      func3(argc, argv);
>> 
>>      func3(argv);
> 
> 
> Would you like to handle function overloading here?

I'm not exactly sure I understand what you mean here.

Finally I would like to archive something like this:

void func(void) {

    int x = 0;
    int y = 0;

    func1(x, 0);
    func2(0, y);
}

void func1(int arg1, int arg2) {
    interesting_func(arg1);
}

void func2(int arg1, int arg2) {
    interesting_func(arg2);
}

In the end I want to, for example, turn it into:

void func(void) {

    int x = 0;
    // 'x' was used as first argument to interesting_func
    int y = 0;
    // 'y' was used as first argument to interesting_func

    func1(x, 0);
    func2(0, y);
}

void func1(int arg1, int arg2) {
    interesting_func(arg1);
}

void func2(int arg1, int arg2) {
    interesting_func(arg2);
}

Basically I want to flag create the matching from 'x'/'y' to the argument to interesting_func.

I was imagining if I could match the parameter list of any function calling 'interesting_func'
then I can also create a matching from x to that function call and do the rest of the correlation
in python somehow.

However I'm still failing to detect if any argument (arg1 or arg2 in this case) is used as
any argument in 'interesting_func'.

I hope this makes more sense?

> 
> 
> 
>> what doesn't work (matching on the expression list from the parameter list):
>> 
>>   @main4@
>>   expression list Es;
>>   @@
>> 
>>   int func1(Ps@Es) {
>>   ...
>>   }
> 
> 
> Which type would belong to the metavariable “Ps”?

Ps should be an arbitrary length parameter list with arbitrary types.

> 
> 
> 
>> I also tried this:
>> 
>>   @main4@
>>   parameter P;
>>   expression E;
>>   @@
>> 
>>   int func1(..., P@E, ...) {
>>   ...
>>   }
> 
> 
> Does such SmPL code represent a contradiction?
> 
> 
> Can any other descriptions indicate your data processing imaginations better?

hopefully the example above makes it a bit more clear.

> 
> 
>>   @main5@
>>   expression main4.E;
>>   identifier func;
>>   @@
>> 
>>     func(..., E, ...);
>>   + // add comment
>> 
>> 
>> But it throws: 'rule starting on line 41 contains unattached metavariables: main4.E'.
> 
> Which software version did you try out here?

I'm guessing this will give you all the information you want:
spatch version 1.1.1-00124-ge93f5513 compiled with OCaml version 4.13.1


> 
> I am curious how corresponding considerations will evolve further.
> 
> 
> Regards,
> Markus
> 

Thanks!
Jakob

Re: [cocci] match arbitrary argument position

[Julia Lawall]

On Wed, 17 Aug 2022, Jakob Koschel wrote:

>
>
> > On 16. Aug 2022, at 23:07, Julia Lawall <Julia.Lawall@inria.fr> wrote:
> >
> >>>> Based on that I was wondering if there is a way to say: match if the expression is
> >>>> within an expression list. So if I for instance have something like this:
> >>>>
> >>>> @main@
> >>>> type T;
> >>>> parameter list P;
> >>>> expression list E;
> >>>> expression E1;
> >>>> identifier func, func_call;
> >>>> @@
> >>>>
> >>>> T func(P@E) {
> >>>>   ...
> >>>>   func_call(E1 in E)
> >>>>   ...
> >>>> }
> >>>>
> >>>> (above is not valid syntax of course)
> >>>>
> >>>> Ideally I would like to make and get the parameters of 'func' that are used in any position
> >>>> as arguments in 'func_call' if that makes sense?
> >>
> >> Do you have any idea regarding the expression lists?
> >>
> >> looking at the following code snippet:
> >>
> >> test.c:
> >>
> >>   int func1(int argc, char *argv) {
> >>      func2(argc, argv);
> >>
> >>      func3(argc, argv);
> >>
> >>      func3(argv);
> >>   }
> >>
> >> what works is (only matches the first func3 call):
> >>
> >>   @main4@
> >>   expression list Es;
> >>   @@
> >>
> >>   func2(Es)
> >>
> >>   @main5@
> >>   expression list main4.Es;
> >>   identifier func;
> >>   @@
> >>
> >>     func(Es);
> >>   + // add comment
> >>
> >>
> >> what doesn't work (matching on the expression list from the parameter list):
> >>
> >>   @main4@
> >>   expression list Es;
> >>   @@
> >>
> >>   int func1(Ps@Es) {
> >>   ...
> >>   }
> >>
> >>   @main5@
> >>   expression list main4.Es;
> >
> > Could you try
> >
> > expression list main4.Ps;
> >
> > It may transform the parameters into a list of expressions.
>
> I just tried:
>
> @main4@
> parameter list Ps;
> @@
>
> int func1(Ps) {
> ...
> }
>
> @main5@
> expression list main4.Ps;
> identifier func;
> @@
>
>   func(Es);
> + // add comment
>
> but that throws:
>
> meta: semantic error: incompatible inheritance declaration Ps
>   File "test.cocci", line 45, column 24, charpos = 539
>   around = ';',
>   whole content = expression list main4.Ps;

OK, there is a specific context in which this works, but it is only for
generating semantic patch rules.

You can do something like

@r@
parameter list [n] ps;
type t;
identifier i,f;
@@

f(ps,t i, ...) { ... }

@@
expression list[r.n] es;
identifier r.i, r.f;
expression e;
@@

(
f(es,i,...)
|
f(es,
- e
+ 0
  ,...)
)

I'm not sure if that is exactly what you want to do, but perhaps it will
give some ideas.

julia

>
> >
> > julia
> >
> >>   identifier func;
> >>   @@
> >>
> >>     func(Es);
> >>   + // add comment
> >>
> >>
> >> Ideally I would like to 'find' all parameters used in a function call,
> >> I also tried this:
> >>
> >>   @main4@
> >>   parameter P;
> >>   expression E;
> >>   @@
> >>
> >>   int func1(..., P@E, ...) {
> >>   ...
> >>   }
> >>
> >>   @main5@
> >>   expression main4.E;
> >>   identifier func;
> >>   @@
> >>
> >>     func(..., E, ...);
> >>   + // add comment
> >>
> >>
> >> But it throws: 'rule starting on line 41 contains unattached metavariables: main4.E'.
> >>
> >> Any idea, why e.g. the second one doesn't work? If I print it with python the expression list
> >> looks the same as for the first one.
> >> Also in the end this boils down to: is it possible to match to any of the expression list elements?
> >>
> >> Thanks,
> >> Jakob
> >>
> >>>>
> >>>>
> >>>> Any help is very much appreciated!
> >>>>
> >>>> Thanks,
> >>>> Jakob
>
>

Re: [cocci] match arbitrary argument position

[Jakob Koschel]

> On 17. Aug 2022, at 16:36, Julia Lawall <julia.lawall@inria.fr> wrote:
> 
> 
> 
> On Wed, 17 Aug 2022, Jakob Koschel wrote:
> 
>> 
>> 
>>> On 16. Aug 2022, at 23:07, Julia Lawall <Julia.Lawall@inria.fr> wrote:
>>> 
>>>>>> Based on that I was wondering if there is a way to say: match if the expression is
>>>>>> within an expression list. So if I for instance have something like this:
>>>>>> 
>>>>>> @main@
>>>>>> type T;
>>>>>> parameter list P;
>>>>>> expression list E;
>>>>>> expression E1;
>>>>>> identifier func, func_call;
>>>>>> @@
>>>>>> 
>>>>>> T func(P@E) {
>>>>>>  ...
>>>>>>  func_call(E1 in E)
>>>>>>  ...
>>>>>> }
>>>>>> 
>>>>>> (above is not valid syntax of course)
>>>>>> 
>>>>>> Ideally I would like to make and get the parameters of 'func' that are used in any position
>>>>>> as arguments in 'func_call' if that makes sense?
>>>> 
>>>> Do you have any idea regarding the expression lists?
>>>> 
>>>> looking at the following code snippet:
>>>> 
>>>> test.c:
>>>> 
>>>>  int func1(int argc, char *argv) {
>>>>     func2(argc, argv);
>>>> 
>>>>     func3(argc, argv);
>>>> 
>>>>     func3(argv);
>>>>  }
>>>> 
>>>> what works is (only matches the first func3 call):
>>>> 
>>>>  @main4@
>>>>  expression list Es;
>>>>  @@
>>>> 
>>>>  func2(Es)
>>>> 
>>>>  @main5@
>>>>  expression list main4.Es;
>>>>  identifier func;
>>>>  @@
>>>> 
>>>>    func(Es);
>>>>  + // add comment
>>>> 
>>>> 
>>>> what doesn't work (matching on the expression list from the parameter list):
>>>> 
>>>>  @main4@
>>>>  expression list Es;
>>>>  @@
>>>> 
>>>>  int func1(Ps@Es) {
>>>>  ...
>>>>  }
>>>> 
>>>>  @main5@
>>>>  expression list main4.Es;
>>> 
>>> Could you try
>>> 
>>> expression list main4.Ps;
>>> 
>>> It may transform the parameters into a list of expressions.
>> 
>> I just tried:
>> 
>> @main4@
>> parameter list Ps;
>> @@
>> 
>> int func1(Ps) {
>> ...
>> }
>> 
>> @main5@
>> expression list main4.Ps;
>> identifier func;
>> @@
>> 
>>  func(Es);
>> + // add comment
>> 
>> but that throws:
>> 
>> meta: semantic error: incompatible inheritance declaration Ps
>>  File "test.cocci", line 45, column 24, charpos = 539
>>  around = ';',
>>  whole content = expression list main4.Ps;
> 
> OK, there is a specific context in which this works, but it is only for
> generating semantic patch rules.
> 
> You can do something like
> 
> @r@
> parameter list [n] ps;
> type t;
> identifier i,f;
> @@
> 
> f(ps,t i, ...) { ... }
> 
> @@
> expression list[r.n] es;
> identifier r.i, r.f;
> expression e;
> @@
> 
> (
> f(es,i,...)
> |
> f(es,
> - e
> + 0
>  ,...)
> )
> 
> I'm not sure if that is exactly what you want to do, but perhaps it will
> give some ideas.

I just realized that you are no longer in the 'cc' in the email I send to Markus so I'm pasting
what I'm trying to do here:

Finally I would like to archive something like this:

void func(void) {

   int x = 0;
   int y = 0;

   func1(x, 0);
   func2(0, y);
}

void func1(int arg1, int arg2) {
   interesting_func(arg1);
}

void func2(int arg1, int arg2) {
   interesting_func(arg2);
}

In the end I want to, for example, turn it into:

void func(void) {

   int x = 0;
   // 'x' was used as first argument to interesting_func
   int y = 0;
   // 'y' was used as first argument to interesting_func

   func1(x, 0);
   func2(0, y);
}

void func1(int arg1, int arg2) {
   interesting_func(arg1);
}

void func2(int arg1, int arg2) {
   interesting_func(arg2);
}

Basically I want to flag create the matching from 'x'/'y' to the argument to interesting_func.

I was imagining if I could match the parameter list of any function calling 'interesting_func'
then I can also create a matching from x to that function call and do the rest of the correlation
in python somehow.

However I'm still failing to detect if any argument (arg1 or arg2 in this case) is used as
any argument in 'interesting_func'.

I hope this makes more sense?

I think I understand your example, and you are basically matching on the length of 'n' on the parameter list. I'm not exactly sure if that would work with what I'm trying to accomplish.

The more problematic case I *think* is matching the parameter list to the usage within that function.
In your example it is matching from a function definition to a call to that function.

so not matching:

f(x, y);

to 

void f(int arg1, int arg2) { ... }

but matching the parameter to a function call within:

void f(int arg1, int arg2) {

    insteresting_func(arg1); // match arg1 here

}

Thanks,
Jakob

> 
> julia
> 
>> 
>>> 
>>> julia
>>> 
>>>>  identifier func;
>>>>  @@
>>>> 
>>>>    func(Es);
>>>>  + // add comment
>>>> 
>>>> 
>>>> Ideally I would like to 'find' all parameters used in a function call,
>>>> I also tried this:
>>>> 
>>>>  @main4@
>>>>  parameter P;
>>>>  expression E;
>>>>  @@
>>>> 
>>>>  int func1(..., P@E, ...) {
>>>>  ...
>>>>  }
>>>> 
>>>>  @main5@
>>>>  expression main4.E;
>>>>  identifier func;
>>>>  @@
>>>> 
>>>>    func(..., E, ...);
>>>>  + // add comment
>>>> 
>>>> 
>>>> But it throws: 'rule starting on line 41 contains unattached metavariables: main4.E'.
>>>> 
>>>> Any idea, why e.g. the second one doesn't work? If I print it with python the expression list
>>>> looks the same as for the first one.
>>>> Also in the end this boils down to: is it possible to match to any of the expression list elements?
>>>> 
>>>> Thanks,
>>>> Jakob
>>>> 
>>>>>> 
>>>>>> 
>>>>>> Any help is very much appreciated!
>>>>>> 
>>>>>> Thanks,
>>>>>> Jakob

Re: [cocci] match arbitrary argument position

[Julia Lawall]

On Wed, 17 Aug 2022, Jakob Koschel wrote:

>
>
> > On 17. Aug 2022, at 16:36, Julia Lawall <julia.lawall@inria.fr> wrote:
> >
> >
> >
> > On Wed, 17 Aug 2022, Jakob Koschel wrote:
> >
> >>
> >>
> >>> On 16. Aug 2022, at 23:07, Julia Lawall <Julia.Lawall@inria.fr> wrote:
> >>>
> >>>>>> Based on that I was wondering if there is a way to say: match if the expression is
> >>>>>> within an expression list. So if I for instance have something like this:
> >>>>>>
> >>>>>> @main@
> >>>>>> type T;
> >>>>>> parameter list P;
> >>>>>> expression list E;
> >>>>>> expression E1;
> >>>>>> identifier func, func_call;
> >>>>>> @@
> >>>>>>
> >>>>>> T func(P@E) {
> >>>>>>  ...
> >>>>>>  func_call(E1 in E)
> >>>>>>  ...
> >>>>>> }
> >>>>>>
> >>>>>> (above is not valid syntax of course)
> >>>>>>
> >>>>>> Ideally I would like to make and get the parameters of 'func' that are used in any position
> >>>>>> as arguments in 'func_call' if that makes sense?
> >>>>
> >>>> Do you have any idea regarding the expression lists?
> >>>>
> >>>> looking at the following code snippet:
> >>>>
> >>>> test.c:
> >>>>
> >>>>  int func1(int argc, char *argv) {
> >>>>     func2(argc, argv);
> >>>>
> >>>>     func3(argc, argv);
> >>>>
> >>>>     func3(argv);
> >>>>  }
> >>>>
> >>>> what works is (only matches the first func3 call):
> >>>>
> >>>>  @main4@
> >>>>  expression list Es;
> >>>>  @@
> >>>>
> >>>>  func2(Es)
> >>>>
> >>>>  @main5@
> >>>>  expression list main4.Es;
> >>>>  identifier func;
> >>>>  @@
> >>>>
> >>>>    func(Es);
> >>>>  + // add comment
> >>>>
> >>>>
> >>>> what doesn't work (matching on the expression list from the parameter list):
> >>>>
> >>>>  @main4@
> >>>>  expression list Es;
> >>>>  @@
> >>>>
> >>>>  int func1(Ps@Es) {
> >>>>  ...
> >>>>  }
> >>>>
> >>>>  @main5@
> >>>>  expression list main4.Es;
> >>>
> >>> Could you try
> >>>
> >>> expression list main4.Ps;
> >>>
> >>> It may transform the parameters into a list of expressions.
> >>
> >> I just tried:
> >>
> >> @main4@
> >> parameter list Ps;
> >> @@
> >>
> >> int func1(Ps) {
> >> ...
> >> }
> >>
> >> @main5@
> >> expression list main4.Ps;
> >> identifier func;
> >> @@
> >>
> >>  func(Es);
> >> + // add comment
> >>
> >> but that throws:
> >>
> >> meta: semantic error: incompatible inheritance declaration Ps
> >>  File "test.cocci", line 45, column 24, charpos = 539
> >>  around = ';',
> >>  whole content = expression list main4.Ps;
> >
> > OK, there is a specific context in which this works, but it is only for
> > generating semantic patch rules.
> >
> > You can do something like
> >
> > @r@
> > parameter list [n] ps;
> > type t;
> > identifier i,f;
> > @@
> >
> > f(ps,t i, ...) { ... }
> >
> > @@
> > expression list[r.n] es;
> > identifier r.i, r.f;
> > expression e;
> > @@
> >
> > (
> > f(es,i,...)
> > |
> > f(es,
> > - e
> > + 0
> >  ,...)
> > )
> >
> > I'm not sure if that is exactly what you want to do, but perhaps it will
> > give some ideas.
>
> I just realized that you are no longer in the 'cc' in the email I send to Markus so I'm pasting
> what I'm trying to do here:
>
> Finally I would like to archive something like this:
>
> void func(void) {
>
>    int x = 0;
>    int y = 0;
>
>    func1(x, 0);
>    func2(0, y);
> }
>
> void func1(int arg1, int arg2) {
>    interesting_func(arg1);
> }
>
> void func2(int arg1, int arg2) {
>    interesting_func(arg2);
> }
>
> In the end I want to, for example, turn it into:
>
> void func(void) {
>
>    int x = 0;
>    // 'x' was used as first argument to interesting_func
>    int y = 0;
>    // 'y' was used as first argument to interesting_func
>
>    func1(x, 0);
>    func2(0, y);
> }
>
> void func1(int arg1, int arg2) {
>    interesting_func(arg1);
> }
>
> void func2(int arg1, int arg2) {
>    interesting_func(arg2);
> }
>
> Basically I want to flag create the matching from 'x'/'y' to the argument to interesting_func.
>
> I was imagining if I could match the parameter list of any function calling 'interesting_func'
> then I can also create a matching from x to that function call and do the rest of the correlation
> in python somehow.
>
> However I'm still failing to detect if any argument (arg1 or arg2 in this case) is used as
> any argument in 'interesting_func'.
>
> I hope this makes more sense?
>
> I think I understand your example, and you are basically matching on the length of 'n' on the parameter list. I'm not exactly sure if that would work with what I'm trying to accomplish.
>
> The more problematic case I *think* is matching the parameter list to the usage within that function.
> In your example it is matching from a function definition to a call to that function.
>
> so not matching:
>
> f(x, y);
>
> to
>
> void f(int arg1, int arg2) { ... }
>
> but matching the parameter to a function call within:
>
> void f(int arg1, int arg2) {
>
>     insteresting_func(arg1); // match arg1 here
>
> }

How many insteresting_funcs do you have?

How about:

@ok exists@
position p; // add other metavariables as needed
@@

f(...,t i,...) {
  ... when any
  interesting_func@p(i)
  ... when any
}

@@
position p1 != ok.p;
@@

*interesting_func@p1(...)

If you know the maximum number of arguments of insteresting_func, then you
can make a series of rules, for the first argument, for the second
argument, etc.

julia

>
> Thanks,
> Jakob
>
> >
> > julia
> >
> >>
> >>>
> >>> julia
> >>>
> >>>>  identifier func;
> >>>>  @@
> >>>>
> >>>>    func(Es);
> >>>>  + // add comment
> >>>>
> >>>>
> >>>> Ideally I would like to 'find' all parameters used in a function call,
> >>>> I also tried this:
> >>>>
> >>>>  @main4@
> >>>>  parameter P;
> >>>>  expression E;
> >>>>  @@
> >>>>
> >>>>  int func1(..., P@E, ...) {
> >>>>  ...
> >>>>  }
> >>>>
> >>>>  @main5@
> >>>>  expression main4.E;
> >>>>  identifier func;
> >>>>  @@
> >>>>
> >>>>    func(..., E, ...);
> >>>>  + // add comment
> >>>>
> >>>>
> >>>> But it throws: 'rule starting on line 41 contains unattached metavariables: main4.E'.
> >>>>
> >>>> Any idea, why e.g. the second one doesn't work? If I print it with python the expression list
> >>>> looks the same as for the first one.
> >>>> Also in the end this boils down to: is it possible to match to any of the expression list elements?
> >>>>
> >>>> Thanks,
> >>>> Jakob
> >>>>
> >>>>>>
> >>>>>>
> >>>>>> Any help is very much appreciated!
> >>>>>>
> >>>>>> Thanks,
> >>>>>> Jakob
>
>

Re: [cocci] match arbitrary argument position

[Markus Elfring]

>>> looking at the following code snippet:
>>>
>>> test.c:
>> …
>>>      func3(argc, argv);
>>>
>>>      func3(argv);
>>
>> Would you like to handle function overloading here?
> I'm not exactly sure I understand what you mean here.


I suggest to take another look at the implementation detail that it was specified
to call a function with different number of expressions.


> Finally I would like to archive something like this:


You would probably like to achieve special source code transformations
instead of archiving items.



> In the end I want to, for example, turn it into:
>
> void func(void) {
>
>     int x = 0;
>     // 'x' was used as first argument to interesting_func
>     int y = 0;
>     // 'y' was used as first argument to interesting_func
>
>     func1(x, 0);
>     func2(0, y);
> }
>
> void func1(int arg1, int arg2) {
>     interesting_func(arg1);
> }
>
> void func2(int arg1, int arg2) {
>     interesting_func(arg2);
> }


Will any filters (or related SmPL constraints) be relevant for such function names?


> Basically I want to flag create the matching from 'x'/'y' to the argument to interesting_func.


How do you think about further possibilities to choose which function argument
should be passed as an expression for corresponding computations?


> I was imagining if I could match the parameter list of any function calling 'interesting_func'
> then I can also create a matching from x to that function call and do the rest of the correlation
> in python somehow.


I propose to reconsider also the need for extra scripting according to
the discussed use case.



> However I'm still failing to detect if any argument (arg1 or arg2 in this case) is used as
> any argument in 'interesting_func'.


Multiple SmPL rules can be applied on demand for desirable data processing results.


> I hope this makes more sense?


It can be challenging to express special imaginations by the means of
the semantic patch language.



> hopefully the example above makes it a bit more clear.


It seems so.

Regards,
Markus

Re: [cocci] Working with parameter/expression lists by SmPL

[Markus Elfring]

>> I just tried:
>>
>> @main4@
>> parameter list Ps;
>> @@
>>
>> int func1(Ps) {
>> ...
>> }
>>
>> @main5@
>> expression list main4.Ps;
>> identifier func;
>> @@
>>
>>   func(Es);
>> + // add comment
>>
>> but that throws:
>>
>> meta: semantic error: incompatible inheritance declaration Ps
>>   File "test.cocci", line 45, column 24, charpos = 539
>>   around = ';',
>>   whole content = expression list main4.Ps;
> OK, there is a specific context in which this works, but it is only for
> generating semantic patch rules.


I would appreciate further explanations for such information.

Regards,
Markus

Re: [cocci] Working with parameter/expression lists by SmPL

[Jakob Koschel]

Hey,

> On 17. Aug 2022, at 21:48, Markus Elfring <Markus.Elfring@web.de> wrote:
> 
>>> I just tried:
>>> 
>>> @main4@
>>> parameter list Ps;
>>> @@
>>> 
>>> int func1(Ps) {
>>> ...
>>> }
>>> 
>>> @main5@
>>> expression list main4.Ps;
>>> identifier func;
>>> @@
>>> 
>>>  func(Es);
>>> + // add comment
>>> 
>>> but that throws:
>>> 
>>> meta: semantic error: incompatible inheritance declaration Ps
>>>  File "test.cocci", line 45, column 24, charpos = 539
>>>  around = ';',
>>>  whole content = expression list main4.Ps;
>> OK, there is a specific context in which this works, but it is only for
>> generating semantic patch rules.
> 
> 
> I would appreciate further explanations for such information.

I've finally managed to get it working. Always when I struggle with coccinelle
and get it working in the end it looks completely obvious. 

Thanks a lot of for all the help Markus & Julia!

Let me show what I was trying to archive and how I solved it:

    @r1@
    parameter list [n] ps;
    type t;
    identifier i,f;
    position p;
    @@

    f(ps, t i, ...) {
    ... when any
    interesting_func@p(..., i, ...)
    ... when any
    }

    @r2@
    identifier r1.f;
    expression list [r1.n] es;
    expression e, e1;
    position p;
    @@

    e = e1
    + // here the argument to interesting_func was assigned
    ... when any
    f(es, e, ...)@p;


I'm running it with this sample code:


    int interesting_func(int argc, char *str) {

    }

    int main(int argc, char *argv[]) {
      int x = 0;

      func1(x, "asdf");
    }

    int func1(int number, char *str) {
      int y = 0;
      char *x = "x";

      interesting_func(number, str);

      interesting_func(number, x);

      interesting_func(y, str);

      interesting_func(y, x);

      return 0;
    }

with the desired result:

diff =
--- test1.c
+++ /tmp/cocci-output-test1.c
@@ -6,7 +6,8 @@ int interesting_func(int argc, char *str
 }

 int main(int argc, char *argv[]) {
-  int x = 0;
+  int x = 0
+    // test;

   func1(x, "asdf");
 }

Thanks,
Jakob

> 
> Regards,
> Markus
> 
> 

Re: [cocci] Working with parameter/expression lists by SmPL

[Markus Elfring]

> Let me show what I was trying to archive and how I solved it:


How do you think about to achieve further software adjustments?


…

>     interesting_func@p(..., i, ...)
…

I interpret such SmPL code in the way that the specified position variable
could be omitted because it was not used by another subsequent SmPL rule.


…

>     e = e1
>     + // here the argument to interesting_func was assigned
…
> +++ /tmp/cocci-output-test1.c
> @@ -6,7 +6,8 @@ int interesting_func(int argc, char *str
>  }
>
>  int main(int argc, char *argv[]) {
> -  int x = 0;
> +  int x = 0
> +    // test;
>
>    func1(x, "asdf");
>  }


Do you vary comment additions for your test results?

Regards,
Markus

Re: [cocci] Checking a comment addition

[Markus Elfring]

> +++ /tmp/cocci-output-test1.c
> @@ -6,7 +6,8 @@ int interesting_func(int argc, char *str
>  }
>
>  int main(int argc, char *argv[]) {
> -  int x = 0;
> +  int x = 0
> +    // test;
>
>    func1(x, "asdf");
>  }


I find such a comment addition questionable.

Do you expect that a semicolon should be used for the variable definition here?

Regards,
Markus

Re: [cocci] Working with parameter/expression lists by SmPL

[Jakob Koschel]

> On 18. Aug 2022, at 19:42, Markus Elfring <Markus.Elfring@web.de> wrote:
> 
>> Let me show what I was trying to archive and how I solved it:
> 
> 
> How do you think about to achieve further software adjustments?

I'm trying to detect certain code patterns spanning across files with this.
They will *probably* not easily be automatically patchable since I'm trying to
find bugs with this in an ongoing research project.

> 
> 
> …
> 
>>    interesting_func@p(..., i, ...)
> …
> 
> I interpret such SmPL code in the way that the specified position variable
> could be omitted because it was not used by another subsequent SmPL rule.

You're right, the positions can be omitted here, but I'm using them with a
simple python script afterwards to report the matches I found where the positions
will be useful.

> 
> 
> …
> 
>>    e = e1
>>    + // here the argument to interesting_func was assigned
> …
>> +++ /tmp/cocci-output-test1.c
>> @@ -6,7 +6,8 @@ int interesting_func(int argc, char *str
>> }
>> 
>> int main(int argc, char *argv[]) {
>> -  int x = 0;
>> +  int x = 0
>> +    // test;
>> 
>>   func1(x, "asdf");
>> }
> 
> 
> Do you vary comment additions for your test results?

yes exactly.

Only issue I'm having now is that it doesn't work across files.

I've found this [Link], suggesting to use '--file-groups' or '--kbuild-info' to 
o analysis across multiple files. I've managed to get '--file-groups' working
on a small example but it will get challenging to do on the entire kernel.
The '--kbuild-info' option *looks* outdated at least I couldn't find an easy way to get
it running on the kernel.

- jakob

> 
> Regards,
> Markus
> 

Link: https://lore.kernel.org/all/alpine.DEB.2.20.1711300716120.2079@hadrien/t/#u

Re: [cocci] Working with parameter/expression lists by SmPL

[Julia Lawall]

> I've found this [Link], suggesting to use '--file-groups' or '--kbuild-info' to
> o analysis across multiple files. I've managed to get '--file-groups' working
> on a small example but it will get challenging to do on the entire kernel.
> The '--kbuild-info' option *looks* outdated at least I couldn't find an easy way to get
> it running on the kernel.

--file-groups is a better option.

The other option is to use iteration, and collect information on one
iteration and use it on the next one.  That would give a completely global
analysis that might not scale.  You can see an example in
demos/iteration.cocci

julia

Re: [cocci] Working with parameter/expression lists by SmPL

[Jakob Koschel]

> On 19. Aug 2022, at 11:57, Julia Lawall <julia.lawall@inria.fr> wrote:
> 
>> I've found this [Link], suggesting to use '--file-groups' or '--kbuild-info' to
>> o analysis across multiple files. I've managed to get '--file-groups' working
>> on a small example but it will get challenging to do on the entire kernel.
>> The '--kbuild-info' option *looks* outdated at least I couldn't find an easy way to get
>> it running on the kernel.
> 
> --file-groups is a better option.
> 
> The other option is to use iteration, and collect information on one
> iteration and use it on the next one.  That would give a completely global
> analysis that might not scale.  You can see an example in
> demos/iteration.cocci

The option to collection information and then do a separate run, is precisely
what I was intending to do now. Since I don't see an easy way to use '--file-groups'
on the entire kernel.

thanks for the pointer to the suitable example.

- jakob

> 
> julia

Re: [cocci] Working with parameter/expression lists by SmPL

[Markus Elfring]

> I'm trying to detect certain code patterns spanning across files with this.
> They will *probably* not easily be automatically patchable since I'm trying to
> find bugs with this in an ongoing research project.


Would you like to add a link for this evolving information source?



> You're right, the positions can be omitted here, but I'm using them with a
> simple python script afterwards to report the matches I found where the positions
> will be useful.


Would you like to improve the distinction for the usages of mentioned variables
any further by using operation modes (or variants) for SmPL scripts?

Would it become helpful to use the name ”interesting_func” as another metavariable?



>> …
>>> +++ /tmp/cocci-output-test1.c
>>> @@ -6,7 +6,8 @@ int interesting_func(int argc, char *str
>>> }
>>>
>>> int main(int argc, char *argv[]) {
>>> -  int x = 0;
>>> +  int x = 0
>>> +    // test;
>>>
>>>   func1(x, "asdf");
>>> }
>> Do you vary comment additions for your test results?
> yes exactly.


Do you stumble on any more development challenges for adding comments
by the Coccinelle software?

How do you think about possibilities to add multi-line comments
(instead of specifying desirable messages behind double slashes)?
https://en.cppreference.com/w/c/comment

Are you looking for better source code formatting according to semicolons?


> Only issue I'm having now is that it doesn't work across files.


Would you like to explain remaining development concerns any more?

Regards,
Markus

Re: [cocci] Working with parameter/expression lists by SmPL

[Jakob Koschel]

> On 19. Aug 2022, at 19:00, Markus Elfring <Markus.Elfring@web.de> wrote:
> 
>> I'm trying to detect certain code patterns spanning across files with this.
>> They will *probably* not easily be automatically patchable since I'm trying to
>> find bugs with this in an ongoing research project.
> 
> 
> Would you like to add a link for this evolving information source?

I'm not sure what you mean "link for this evolving information source". There is no
public information on this yet since it's an ongoing project.

> 
> 
> 
>> You're right, the positions can be omitted here, but I'm using them with a
>> simple python script afterwards to report the matches I found where the positions
>> will be useful.
> 
> 
> Would you like to improve the distinction for the usages of mentioned variables
> any further by using operation modes (or variants) for SmPL scripts?
> 
> Would it become helpful to use the name ”interesting_func” as another metavariable?

yes I've done that afterwards but for my use case it doesn't matter since it will only be
one specific function regardless.

> 
> 
> 
>>> …
>>>> +++ /tmp/cocci-output-test1.c
>>>> @@ -6,7 +6,8 @@ int interesting_func(int argc, char *str
>>>> }
>>>> 
>>>> int main(int argc, char *argv[]) {
>>>> -  int x = 0;
>>>> +  int x = 0
>>>> +    // test;
>>>> 
>>>>  func1(x, "asdf");
>>>> }
>>> Do you vary comment additions for your test results?
>> yes exactly.
> 
> 
> Do you stumble on any more development challenges for adding comments
> by the Coccinelle software?
> 
> How do you think about possibilities to add multi-line comments
> (instead of specifying desirable messages behind double slashes)?
> https://en.cppreference.com/w/c/comment
> 
> Are you looking for better source code formatting according to semicolons?

I'm not exactly sure what you mean with that? I've only used adding the
comment to see if the matching works correctly, I'm not intending to
do anything with comments in the final version.

> 
> 
>> Only issue I'm having now is that it doesn't work across files.
> 
> 
> Would you like to explain remaining development concerns any more?
> 
> Regards,
> Markus
> 

Re: [cocci] Working with parameter/expression lists by SmPL

[Markus Elfring]

> I'm not sure what you mean "link for this evolving information source". There is no
> public information on this yet since it's an ongoing project.


Are you looking for contributions from related research groups?



>> Are you looking for better source code formatting according to semicolons?
> I'm not exactly sure what you mean with that?


Do you care if a bit of code which is probably relevant for the programming
language syntax would be commented out as it was indicated by the diff fragment
“+    // test;”?


> I've only used adding the comment to see if the matching works correctly,


Would other code variants (than C++-style comments) be more helpful for
the demonstration of desirable transformation effects?


> I'm not intending to do anything with comments in the final version.


My software application expectations evolved into additional directions
according to mentioned change specifications (in SmPL code).

Regards,
Markus

Re: [cocci] Working with parameter/expression lists by SmPL

[Julia Lawall]

[-- Attachment #1: Type: text/plain, Size: 1255 bytes --]

Jakob,

Despite the bizarre way in which Markus asks the question, the ; at the
end of the comment could be a serious problem.  Could you repost your
semantic patch and test code?

thanks,
julia






On Sun, 21 Aug 2022, Markus Elfring wrote:

> > I'm not sure what you mean "link for this evolving information source". There is no
> > public information on this yet since it's an ongoing project.
>
>
> Are you looking for contributions from related research groups?
>
>
>
> >> Are you looking for better source code formatting according to semicolons?
> > I'm not exactly sure what you mean with that?
>
>
> Do you care if a bit of code which is probably relevant for the programming
> language syntax would be commented out as it was indicated by the diff fragment
> “+    // test;”?
>
>
> > I've only used adding the comment to see if the matching works correctly,
>
>
> Would other code variants (than C++-style comments) be more helpful for
> the demonstration of desirable transformation effects?
>
>
> > I'm not intending to do anything with comments in the final version.
>
>
> My software application expectations evolved into additional directions
> according to mentioned change specifications (in SmPL code).
>
> Regards,
> Markus
>
>

Re: [cocci] Working with parameter/expression lists by SmPL

[Markus Elfring]

> Despite the bizarre way in which Markus asks the question,


I find such a view also interesting.



> the ; at the end of the comment could be a serious problem.


Thanks for your wording variant about the usage of semicolons.



> Could you repost your semantic patch and test code?


I imagine that a semantic match (with the application of SmPL asterisks)
could be also helpful for the desired understanding of the discussed
transformation approach.

Regards,
Markus

Re: [cocci] Working with parameter/expression lists by SmPL

[Julia Lawall]

On Sun, 21 Aug 2022, Markus Elfring wrote:

> > Despite the bizarre way in which Markus asks the question,
>
>
> I find such a view also interesting.
>
>
>
> > the ; at the end of the comment could be a serious problem.
>
>
> Thanks for your wording variant about the usage of semicolons.
>
>
>
> > Could you repost your semantic patch and test code?
>
>
> I imagine that a semantic match (with the application of SmPL asterisks)
> could be also helpful for the desired understanding of the discussed
> transformation approach.

I don't see why.  I'm only concerned about why a // comment was added at
the front of a line containing real code.  Perhaps the pretty printer
treats all comments the same...

julia

Re: [cocci] Working with parameter/expression lists by SmPL

[Markus Elfring]

>>> Could you repost your semantic patch and test code?
>>
>> I imagine that a semantic match (with the application of SmPL asterisks)
>> could be also helpful for the desired understanding of the discussed
>> transformation approach.
> I don't see why.  I'm only concerned about why a // comment was added at
> the front of a line containing real code.


Jakob Koschel provided the following information yesterday.
https://sympa.inria.fr/sympa/arc/cocci/2022-08/msg00025.html
https://lore.kernel.org/cocci/5369B40D-9EA4-401F-A9CB-2CA1C0E3332E@gmail.com/

“…
I've only used adding the comment to see if the matching works correctly,
I'm not intending to do anything with comments in the final version.
…”



> Perhaps the pretty printer treats all comments the same...

How do you think about increasing case distinctions also for further improvements
of the Coccinelle software?

* Under which circumstances may comment additions influence the control flow?

* Should the addition of a C++-style comment (before an SmPL ellipsis)
  eventually trigger the appending of a line break?

* Would you like to extend the test case collection accordingly?

Regards,
Markus

[cocci] match arbitrary argument position

[Jakob Koschel]

Hi,

(resending be cause I accidently included a private email address in cc,
can the duplicate be removed/rejected from the mailing list archive?)

sorry if this question is not suiting here.

I went through the documentation and most of the examples I could find, but wasn't
able to easily answer my question I'm wondering about.

Basically: is there a way to match to *any* argument? E.g. make something match both of
the 'x' uses in the function calls here:

int x = 5;

function_call1(x, 12, 12);

function_call2(0, x);



Based on that I was wondering if there is a way to say: match if the expression is
within an expression list. So if I for instance have something like this:

  @main@
  type T;
  parameter list P;
  expression list E;
  expression E1;
  identifier func, func_call;
  @@

  T func(P@E) {
    ...
    func_call(E1 in E)
    ...
  }

(above is not valid syntax of course)

Ideally I would like to make and get the parameters of 'func' that are used in any position
as arguments in 'func_call' if that makes sense?


Any help is very much appreciated!

Thanks,
Jakob