C has multiple ways to write function pointer parameters (name is
optional, functiond ecays to function pointer).

So, according to my understanding, these three are equivalent:

int f9 (int (*)(int), int);
int f9 (int (int), int);
int f9 (int f(int), int i);

However, I have also seen the followign as equivalent (and both GCC and
clang accept it wihout warning), but don't see what allows the extra
parentheses

int f9 (int ((int)), int);

Philipp Klaus Krause <pkk@spth.de> writes:

> C has multiple ways to write function pointer parameters (name is
> optional, functiond ecays to function pointer).
>
> So, according to my understanding, these three are equivalent:
>
> int f9 (int (*)(int), int);
> int f9 (int (int), int);
> int f9 (int f(int), int i);
>
> However, I have also seen the followign as equivalent (and both GCC
> and clang accept it wihout warning), but don't see what allows the
> extra parentheses
>
> int f9 (int ((int)), int);

The syntax for declarators, in 6.7.6 paragraph 1, obviously
allows

int x;
int (x);
int ((x));
int (((x)));

and so forth. Similarly the syntax for type names, in 6.7.7
paragraph 1, allows

int f ( int (int) );
int f ( int ((int)) );
int f ( int (((int))) );
int f ( int ((((int)))) );

Both of these are expectable because the corresponding
expressions are allowed:

x
(x)
((x))
(((x)))

g(x)
(g(x))
((g(x)))
(((g(x))))

Philipp Klaus Krause <pkk@spth.de> writes:
>int f9 (int ((int)), int);

I'm not able to parse

int f9 (int ((int)));

with the C grammar. I see that some compilers seem to accept it.

rule:

declaration:
declaration-specifiers init-declarator-listopt ;

application:

declaration-specifiers = int
init-declarator-list =? f9 (int ((int)))
; = ;

rule:

init-declarator-list:
init-declarator

application:

init-declarator =? f9 (int ((int)))

rule:

init-declarator:
declarator

application

declarator =? f9 (int ((int)))

rule:

declarator:
pointeropt direct-declarator

application:

pointeropt =
direct-declarator =? f9 (int ((int)))

rule:

direct-declarator:
direct-declarator ( parameter-type-list )

application:

direct-declarator = f9
( = (
parameter-type-list =? int ((int))
) = )

rule:

parameter-type-list:
parameter-list

application:

parameter-list =? int ((int))

rule:

parameter-list:
parameter-declaration

application:

parameter-declaration =? int ((int))

rule:

parameter-declaration:
declaration-specifiers abstract-declaratoropt

application:

declaration-specifiers = type-specifier = int
abstract-declarator =? ((int))

rule:

abstract-declarator:
pointeropt direct-abstract-declarator

application:

direct-abstract-declarator =? ((int))

rule:

direct-abstract-declarator:
( abstract-declarator )

application:

( = (
abstract-declarator =? (int)
) = )

rule:

abstract-declarator:
pointeropt direct-abstract-declarator

application:

direct-abstract-declarator =? (int)

rule:

direct-abstract-declarator:
( abstract-declarator )

application:

( = (
abstract-declarator =? int
) = )

rule:

abstract-declarator:
pointeropt direct-abstract-declarator

application:

direct-abstract-declarator =? int

This fails, because "int" is not a direct-abstract-declarator.
We can also try the other branch without "abstract":

application:

parameter-declaration =? int ((int))

rule:

parameter-declaration:
declaration-specifiers declarator

application:

declaration-specifiers = type-specifier = int
declarator =? ((int))

rule:

declarator:
pointeropt direct-declarator

application:

direct-declarator =? ((int))

rule:

direct-declarator:
( declarator )

application:

( = (
declarator =? (int)
) = )

rule

declarator:
pointeropt direct-declarator

application:

direct-declarator =? (int)

rule:

direct-declarator:
( declarator )

application:

( = (
declarator =? int
) = )

This also fails, because "int" is not a declarator
(it is not an identifier, but a keyword).

ram@zedat.fu-berlin.de (Stefan Ram) writes:

> Philipp Klaus Krause <pkk@spth.de> writes:
>>int f9 (int ((int)), int);
>
> I'm not able to parse
>
> int f9 (int ((int)));
>
> with the C grammar. I see that some compilers seem to accept it.
>
> rule:
>
> declaration:
> declaration-specifiers init-declarator-listopt ;
>
> application:
>
> declaration-specifiers = int
> init-declarator-list =? f9 (int ((int)))
> ; = ;

Yup.

> rule:
>
> init-declarator-list:
> init-declarator
>
> application:
>
> init-declarator =? f9 (int ((int)))
>
> rule:
>
> init-declarator:
> declarator
>
> application
>
> declarator =? f9 (int ((int)))
>
> rule:
>
> declarator:
> pointeropt direct-declarator
>
> application:
>
> pointeropt =
> direct-declarator =? f9 (int ((int)))

Yup.

> rule:
>
> direct-declarator:
> direct-declarator ( parameter-type-list )

OK, but a rule has been skipped (as far as C20 is concerned). This is a
function-declarator which can be a direct-declarator with a
parameter-type-list in parentheses. (The changes are for including
attributes.)

> application:
>
> direct-declarator = f9
> ( = (
> parameter-type-list =? int ((int))
> ) = )
>
> rule:
>
> parameter-type-list:
> parameter-list
>
> application:
>
> parameter-list =? int ((int))
>
> rule:
>
> parameter-list:
> parameter-declaration
>
> application:
>
> parameter-declaration =? int ((int))
>
> rule:
>
> parameter-declaration:
> declaration-specifiers abstract-declaratoropt
>
> application:
>
> declaration-specifiers = type-specifier = int
> abstract-declarator =? ((int))
>
> rule:
>
> abstract-declarator:
> pointeropt direct-abstract-declarator
>
> application:
>
> direct-abstract-declarator =? ((int))
>
> rule:
>
> direct-abstract-declarator:
> ( abstract-declarator )
>
> application:
>
> ( = (
> abstract-declarator =? (int)
> ) = )
>
> rule:
>
> abstract-declarator:
> pointeropt direct-abstract-declarator
>
> application:
>
> direct-abstract-declarator =? (int)
>
> rule:
>
> direct-abstract-declarator:
> ( abstract-declarator )

There is another rule here. We have (using ? for subscript opt):

direct-abstract-declarator:
( abstract-declarator )
array-abstract-declarator attribute-specifier-sequence?
function-abstract-declarator attribute-specifier-sequence?

so maybe (int) is a function-abstract-declarator. Let's see:

function-abstract-declarator:
direct-abstract-declarator? ( parameter-type-list? )

so is int a parameter-type_list, i.e. is it a parameter-list, i.e. is it
a parameter-declaration?

parameter-declaration:
attribute-specifier-sequence? declaration-specifiers declarator
attribute-specifier-sequence? declaration-specifiers abstract-declarator?

Yes. int is indeed a match for declaration-specifiers.

--
Ben.

On 2022-03-18, Philipp Klaus Krause <pkk@spth.de> wrote:
> C has multiple ways to write function pointer parameters (name is
> optional, functiond ecays to function pointer).
>
> So, according to my understanding, these three are equivalent:
>
> int f9 (int (*)(int), int);
> int f9 (int (int), int);
> int f9 (int f(int), int i);
>
> However, I have also seen the followign as equivalent (and both GCC and
> clang accept it wihout warning), but don't see what allows the extra
> parentheses
>
> int f9 (int ((int)), int);

This is because any declarator can have parentheses on it,
including one which already has parentheses.

As you know C declarators suppor parentheses in order to distinguish
cases like int *a[10] from int (*a)[10].

Here *a[10] is a declarator. But so is just the *a part.

Any of these can have parentheses: so we can have a full
parenthesization like this: int ((*a)[10]).

Declarators are de facto type constructing expressions which have unary
and postfix de facto operators. The postfix ones have higher precedence
than unary, which is sometimes what you don't want, so the syntax
features grouping parentheses, just like expression syntax.

Now as you know, the declared name can be omitted in declarators
in some situations, like when function parameters are being
declared:

// here we have a param name
f9(int fptr(int));

// now we heap superfluous parens on the declarator
f9(int ((fptr(int))));

// now we omit the name, as we may do in this context
f9(int (((int))));

That's it; (int) is a function declarator with omitted name, onto which
extra parentheses have been lavished.

--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal

Kaz Kylheku <480-992-1380@kylheku.com> writes:

> On 2022-03-18, Philipp Klaus Krause <pkk@spth.de> wrote:
>> C has multiple ways to write function pointer parameters (name is
>> optional, functiond ecays to function pointer).
>>
>> So, according to my understanding, these three are equivalent:
>>
>> int f9 (int (*)(int), int);
>> int f9 (int (int), int);
>> int f9 (int f(int), int i);
>>
>> However, I have also seen the followign as equivalent (and both GCC and
>> clang accept it wihout warning), but don't see what allows the extra
>> parentheses
>>
>> int f9 (int ((int)), int);
>
> This is because any declarator can have parentheses on it,
> including one which already has parentheses.

But int is not a declarator -- a declarator always has a name. int is
an abstract-declarator and, yes, that too can have arbitrary
parentheses, but even that does not explain this syntax.

You need to find a place where an abstract-declarator is allowed, and
that removes one pair of parentheses. It's the presence of the outer
int (...) part allows the inner (int) part to be parsed as an
abstract-declarator.

--
Ben.

On 3/18/2022 5:05 AM, Philipp Klaus Krause wrote:
> However, I have also seen the followign as equivalent (and both GCC and
> clang accept it wihout warning), but don't see what allows the extra
> parentheses
>
> int f9 (int ((int)), int);

What allows? The grammar allows. That's all.

--
Best regards,
Andrey Tarasevich

On Monday, March 21, 2022 at 8:25:45 PM UTC-4, Andrey Tarasevich wrote:
> On 3/18/2022 5:05 AM, Philipp Klaus Krause wrote:
> > However, I have also seen the followign as equivalent (and both GCC and
> > clang accept it wihout warning), but don't see what allows the extra
> > parentheses
> >
> > int f9 (int ((int)), int);
> What allows? The grammar allows. That's all.

That's not a particularly useful response. A citation of the specific grammar
rules used by this particular piece of syntax (which other people have already
provided) is a much more useful response.

For me, the trickiest aspect of this issue is the question of which pair of
parentheses are the redundant ones. My thought is that the innermost
parentheses were redundantly parenthesizing a parameter's type, and I
struggled to find the grammar rules that permitted it. After carefully studying
other people's responses, I realized that (int) is an abstract declaration of a
function type, and that the parentheses around that declaration are the
redundant ones.