legality of forward declaration

[Martin Eisenberg]

Hi Antoine, just redirecting you...

Antoine Trux wrote:

Hi,

Is the following code legal:

------> code starts here <------
#include <stddef.h>
struct ForwardDeclared;
void foo(struct ForwardDeclared[]);
/* Dummy function, so this module contains some code. */
void dummy(void)
{
foo(NULL);
}
------> code ends here <------
?

I can see no reason why this code would not be legal, and indeed
gcc (version 3.4.5) and Microsoft C compiler (.NET) compile it
without a glitch.

Code Warrior (version 3.2.5), though, produces the following
error message:

------> CW problem starts here <------
C:\temp>mwccsym2.exe -g -O0 -inline
off -wchar_t off -align 4 -warnings on -w
nohidevirtual,nounusedexpr -msgstyle
gcc -enum int -str pool -exc ms -trigraphs on -stdinc -d _DEBUG
-d _UNICODE -d "
__SYMBIAN32__" -d "__SERIES60_30__" -d "__SERIES60_3X__" -d
"__CW32__" -d "__WIN
S__" -d "__WINSCW__" -d "WIN32" -d "_WINDOWS" -d
"__SUPPORT_CPP_EXCEPTIONS__" -c
wd source -i- -o forwardDeclaration.o -c forwardDeclaration.c
forwardDeclaration.c:5: illegal use of incomplete
struct/union/class 'struct For
wardDeclared'
Errors caused tool to abort.
------> CW problem ends here <------

Changing this line:
void foo(struct ForwardDeclared[]);
to:
void foo(struct ForwardDeclared*);
however, corrects the "problem".

So, is this (as I believe) a bug in Code Warrior (incorrectly
complains about correct code), or a bug in gcc and MS compilers
(do not detect code that is in error)?

Antoine Trux

[Vladimir Oka]

Martin Eisenberg wrote:

Hi Antoine, just redirecting you...

Antoine Trux wrote:

Hi,

Is the following code legal:

------> code starts here <------
#include <stddef.h>
struct ForwardDeclared;
void foo(struct ForwardDeclared[]);
/* Dummy function, so this module contains some code. */
void dummy(void)
{
foo(NULL);
}
------> code ends here <------
?

I can see no reason why this code would not be legal, and indeed
gcc (version 3.4.5) and Microsoft C compiler (.NET) compile it
without a glitch.

Code Warrior (version 3.2.5), though, produces the following
error message:

------> CW problem starts here <------
C:\temp>mwccsym2.exe -g -O0 -inline
off -wchar_t off -align 4 -warnings on -w
nohidevirtual,nounusedexpr -msgstyle
gcc -enum int -str pool -exc ms -trigraphs on -stdinc -d _DEBUG
-d _UNICODE -d "
__SYMBIAN32__" -d "__SERIES60_30__" -d "__SERIES60_3X__" -d
"__CW32__" -d "__WIN
S__" -d "__WINSCW__" -d "WIN32" -d "_WINDOWS" -d
"__SUPPORT_CPP_EXCEPTIONS__" -c
wd source -i- -o forwardDeclaration.o -c forwardDeclaration.c
forwardDeclaration.c:5: illegal use of incomplete
struct/union/class 'struct For
wardDeclared'
Errors caused tool to abort.
------> CW problem ends here <------

Changing this line:
void foo(struct ForwardDeclared[]);
to:
void foo(struct ForwardDeclared*);
however, corrects the "problem".

So, is this (as I believe) a bug in Code Warrior (incorrectly
complains about correct code), or a bug in gcc and MS compilers
(do not detect code that is in error)?

Well, if the code above is the *only* code in your compilation unit,
then I'm afraid the CodeWarrior is right. What you need is a proper
declaration of your `struct`. Perhaps you're missing an `#include`
containing the declaration? Arrays and pointers are not the same thing
in C (despite what some sources say).

PS
Posting full compilable example is, as always, the best policy when
asking this sort of question.

[Kenneth Brody]

Vladimir Oka wrote:

Martin Eisenberg wrote:

Hi Antoine, just redirecting you...

Antoine Trux wrote:

Hi,

Is the following code legal:

------> code starts here <------
#include <stddef.h>
struct ForwardDeclared;
void foo(struct ForwardDeclared[]); [...] forwardDeclaration.c:5: illegal use of incomplete
struct/union/class 'struct For
wardDeclared'
Errors caused tool to abort.
------> CW problem ends here <------

Changing this line:
void foo(struct ForwardDeclared[]);
to:
void foo(struct ForwardDeclared*);
however, corrects the "problem".

So, is this (as I believe) a bug in Code Warrior (incorrectly
complains about correct code), or a bug in gcc and MS compilers
(do not detect code that is in error)?

Well, if the code above is the *only* code in your compilation unit,
then I'm afraid the CodeWarrior is right. What you need is a proper
declaration of your `struct`. Perhaps you're missing an `#include`
containing the declaration? Arrays and pointers are not the same thing
in C (despite what some sources say).

But, given that a function prototype of:

void foo(struct ForwardDeclared[]);
and
void foo(struct ForwardDeclared *);

are the same thing, I don't see why CodeWarrior is complaining. You
can have pointers to incomplete types as long as you don't try to use
them for anything other than passing along elsewhere.

Or is there a difference between a function parameter declared as an
array versus a pointer?
PS
Posting full compilable example is, as always, the best policy when
asking this sort of question.

It looks like a compilable example to me. It compiles just fine on
my system, even with warnings turned up to the max.
--
+-------------------------+--------------------+-----------------------------+
| Kenneth J. Brody | www.hvcomputer.com | |
| kenbrody/at\spamcop.net | www.fptech.com | #include <std_disclaimer.h> |
+-------------------------+--------------------+-----------------------------+
Don't e-mail me at: <mailto:Th*************@gmail.com>

[Vladimir Oka]

Kenneth Brody wrote:

Vladimir Oka wrote:

Martin Eisenberg wrote:

Hi Antoine, just redirecting you...

Antoine Trux wrote:

> Hi,
>
> Is the following code legal:
>
> ------> code starts here <------
> #include <stddef.h>
> struct ForwardDeclared;
> void foo(struct ForwardDeclared[]); [...] > forwardDeclaration.c:5: illegal use of incomplete
> struct/union/class 'struct For
> wardDeclared'
> Errors caused tool to abort.
> ------> CW problem ends here <------
>
> Changing this line:
> void foo(struct ForwardDeclared[]);
> to:
> void foo(struct ForwardDeclared*);
> however, corrects the "problem".
>
> So, is this (as I believe) a bug in Code Warrior (incorrectly
> complains about correct code), or a bug in gcc and MS compilers
> (do not detect code that is in error)?

Well, if the code above is the *only* code in your compilation unit,
then I'm afraid the CodeWarrior is right. What you need is a proper
declaration of your `struct`. Perhaps you're missing an `#include`
containing the declaration? Arrays and pointers are not the same thing
in C (despite what some sources say).

But, given that a function prototype of:

void foo(struct ForwardDeclared[]);
and
void foo(struct ForwardDeclared *);

are the same thing, I don't see why CodeWarrior is complaining. You
can have pointers to incomplete types as long as you don't try to use
them for anything other than passing along elsewhere.

Or is there a difference between a function parameter declared as an
array versus a pointer?

PS
Posting full compilable example is, as always, the best policy when
asking this sort of question.

It looks like a compilable example to me. It compiles just fine on
my system, even with warnings turned up to the max.

Hmmm. I may have messed this one up.

The only *warning* I get is:

main.c:3: warning: array type has incomplete element type

Which I don't think is required by the standard.

I think you're right, and I was wrong.

Unfortunately, I don't have time at the moment to dig deeper into it
(train timetables don't care about C), but I'm sure someone will.

PS
I still think parameter declaration should have used pointers instead
of arrays, though. A matter of style, I know, but...

[Flash Gordon]

Vladimir Oka wrote:

Martin Eisenberg wrote:

Hi Antoine, just redirecting you...

Antoine Trux wrote:

Hi,

Is the following code legal:

------> code starts here <------
#include <stddef.h>
struct ForwardDeclared;
void foo(struct ForwardDeclared[]);
/* Dummy function, so this module contains some code. */
void dummy(void)
{
foo(NULL);
}
------> code ends here <------
?

I can see no reason why this code would not be legal, and indeed
gcc (version 3.4.5) and Microsoft C compiler (.NET) compile it
without a glitch.
Try harder with gcc and you might get it to generate a warning.
markg@markgordon-lp ~
$ cat t.c
#include <stddef.h>
struct ForwardDeclared;
void foo(struct ForwardDeclared[]);
/* Dummy function, so this module contains some code. */
void dummy(void)
{
foo(NULL);
}

markg@markgordon-lp ~
$ gcc -c t.c -ansi -pedantic
t.c:3: warning: array type has incomplete element type
Code Warrior (version 3.2.5), though, produces the following
error message:
<snip>
Changing this line:
void foo(struct ForwardDeclared[]);
to:
void foo(struct ForwardDeclared*);
however, corrects the "problem".
This is a sensible change if it is meant to be a pointer to an
incomplete type. If, however, the definition of the struct is meant to
be visible in the file, making it visible before this function
declaration would be sensible.
So, is this (as I believe) a bug in Code Warrior (incorrectly
complains about correct code), or a bug in gcc and MS compilers
(do not detect code that is in error)?

Well, if the code above is the *only* code in your compilation unit,
then I'm afraid the CodeWarrior is right. What you need is a proper
declaration of your `struct`. Perhaps you're missing an `#include`
containing the declaration? Arrays and pointers are not the same thing
in C (despite what some sources say).

Yes. However, in every other respect in a function declaration
void foo(struct ForwardDeclared[]);
and
void foo(struct ForwardDeclared*);
are equivalent since both specify that foo takes a pointer to struct
ForwardDeclared as a parameter.
PS
Posting full compilable example is, as always, the best policy when
asking this sort of question.

Not when the problem is that it won't compile as in this case! That's a
bit like saying to someone they should not go to the doctor for advice
until they have recovered from whatever they are suffering from!
--
Flash Gordon, living in interesting times.
Web site - http://home.flash-gordon.me.uk/
comp.lang.c posting guidelines and intro:
http://clc-wiki.net/wiki/Intro_to_clc

[Harald van Dijk]

Vladimir Oka wrote:

Kenneth Brody wrote:

Vladimir Oka wrote:

Martin Eisenberg wrote:
> Hi Antoine, just redirecting you...
>
> Antoine Trux wrote:
>
> > Hi,
> >
> > Is the following code legal:
> >
> > ------> code starts here <------
> > #include <stddef.h>
> > struct ForwardDeclared;
> > void foo(struct ForwardDeclared[]); [...]

> > forwardDeclaration.c:5: illegal use of incomplete
> > struct/union/class 'struct For
> > wardDeclared'
> > Errors caused tool to abort.
> > ------> CW problem ends here <------
> >
> > Changing this line:
> > void foo(struct ForwardDeclared[]);
> > to:
> > void foo(struct ForwardDeclared*);
> > however, corrects the "problem".
> >
> > So, is this (as I believe) a bug in Code Warrior (incorrectly
> > complains about correct code), or a bug in gcc and MS compilers
> > (do not detect code that is in error)?
Current versions of gcc will reject it as well.
Well, if the code above is the *only* code in your compilation unit,
then I'm afraid the CodeWarrior is right. What you need is a proper
declaration of your `struct`. Perhaps you're missing an `#include`
containing the declaration? Arrays and pointers are not the same thing
in C (despite what some sources say).

But, given that a function prototype of:

void foo(struct ForwardDeclared[]);
and
void foo(struct ForwardDeclared *);

are the same thing, I don't see why CodeWarrior is complaining. You
can have pointers to incomplete types as long as you don't try to use
them for anything other than passing along elsewhere.

Or is there a difference between a function parameter declared as an
array versus a pointer?
When you are able to declare a parameter as either an array type or as
a pointer type, there is absolutely no difference in its meaning.
However, that does not mean you will always be able to declare a
parameter as an array type, just because you can declare it as a
pointer type.

PS
Posting full compilable example is, as always, the best policy when
asking this sort of question.

It looks like a compilable example to me. It compiles just fine on
my system, even with warnings turned up to the max.

Hmmm. I may have messed this one up.

No, I think you were right the first time.
The only *warning* I get is:

main.c:3: warning: array type has incomplete element type

Which I don't think is required by the standard.
Any array of incomplete (or function) type is a constraint violation
(6.7.5.2), and so a diagnostic is required. There is no exception for
array types for function parameters.
I think you're right, and I was wrong.

Unfortunately, I don't have time at the moment to dig deeper into it
(train timetables don't care about C), but I'm sure someone will.

PS
I still think parameter declaration should have used pointers instead
of arrays, though. A matter of style, I know, but...

[Jack Klein]

On Wed, 31 May 2006 12:57:19 +0000 (UTC), Martin Eisenberg
<ma**************@udo.edu> wrote in comp.dsp:

Hi Antoine, just redirecting you...

Antoine Trux wrote:

Hi,

Is the following code legal:

------> code starts here <------
#include <stddef.h>
struct ForwardDeclared;
void foo(struct ForwardDeclared[]);
/* Dummy function, so this module contains some code. */
void dummy(void)
{
foo(NULL);
}
------> code ends here <------
?

I can see no reason why this code would not be legal, and indeed
gcc (version 3.4.5) and Microsoft C compiler (.NET) compile it
without a glitch.

Code Warrior (version 3.2.5), though, produces the following
error message:

------> CW problem starts here <------
C:\temp>mwccsym2.exe -g -O0 -inline
off -wchar_t off -align 4 -warnings on -w
nohidevirtual,nounusedexpr -msgstyle
gcc -enum int -str pool -exc ms -trigraphs on -stdinc -d _DEBUG
-d _UNICODE -d "
__SYMBIAN32__" -d "__SERIES60_30__" -d "__SERIES60_3X__" -d
"__CW32__" -d "__WIN
S__" -d "__WINSCW__" -d "WIN32" -d "_WINDOWS" -d
"__SUPPORT_CPP_EXCEPTIONS__" -c
wd source -i- -o forwardDeclaration.o -c forwardDeclaration.c
forwardDeclaration.c:5: illegal use of incomplete
struct/union/class 'struct For
wardDeclared'
Errors caused tool to abort.
------> CW problem ends here <------

Changing this line:
void foo(struct ForwardDeclared[]);
to:
void foo(struct ForwardDeclared*);
however, corrects the "problem".

So, is this (as I believe) a bug in Code Warrior (incorrectly
complains about correct code), or a bug in gcc and MS compilers
(do not detect code that is in error)?

Antoine Trux

Absolutely a bug in Code Warrior. In function declarations, "type
name []" is exactly equivalent to "type *name", with the exception of
a special case for compilers conforming to the 1999 or later version
of the C standard, and that special case does not apply here.

So I would suggest submitting a bug report to Metrowerks.

But I would also suggest using "struct ForwardDeclared*", both to get
on with your work immediately, and because I don't like the [] syntax
in declarations because it misleads newbies, and obviously at least
one compiler's parser.

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://c-faq.com/
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.learn.c-c++
http://www.contrib.andrew.cmu.edu/~a...FAQ-acllc.html

[Antoine Trux]

> Absolutely a bug in Code Warrior. In function declarations, "type

name []" is exactly equivalent to "type *name", with the exception of
a special case for compilers conforming to the 1999 or later version
of the C standard, and that special case does not apply here.
Then, how do you interpret the following paragraph from the C99 Standard
(thanks to Harald van Dijk for pointing it out):

------> start of C99 Standard excerpt <------
6.7.5.2 Array declarators
Constraints
1 In addition to optional type qualifiers and the keyword static, the [
and ] may delimit
an expression or *. If they delimit an expression (which specifies the size
of an array), the
expression shall have an integer type. If the expression is a constant
expression, it shall
have a value greater than zero. The element type shall not be an incomplete
or function
type. The optional type qualifiers and the keyword static shall appear only
in a
declaration of a function parameter with an array type, and then only in the
outermost
array type derivation.

------> end of C99 Standard excerpt <------
?

Antoine

"Jack Klein" <ja*******@spamcop.net> wrote in message
news:rd********************************@4ax.com... On Wed, 31 May 2006 12:57:19 +0000 (UTC), Martin Eisenberg
<ma**************@udo.edu> wrote in comp.dsp:

Hi Antoine, just redirecting you...

Antoine Trux wrote:

> Hi,
>
> Is the following code legal:
>
> ------> code starts here <------
> #include <stddef.h>
> struct ForwardDeclared;
> void foo(struct ForwardDeclared[]);
> /* Dummy function, so this module contains some code. */
> void dummy(void)
> {
> foo(NULL);
> }
> ------> code ends here <------
> ?
>
> I can see no reason why this code would not be legal, and indeed
> gcc (version 3.4.5) and Microsoft C compiler (.NET) compile it
> without a glitch.
>
> Code Warrior (version 3.2.5), though, produces the following
> error message:
>
> ------> CW problem starts here <------
> C:\temp>mwccsym2.exe -g -O0 -inline
> off -wchar_t off -align 4 -warnings on -w
> nohidevirtual,nounusedexpr -msgstyle
> gcc -enum int -str pool -exc ms -trigraphs on -stdinc -d _DEBUG
> -d _UNICODE -d "
> __SYMBIAN32__" -d "__SERIES60_30__" -d "__SERIES60_3X__" -d
> "__CW32__" -d "__WIN
> S__" -d "__WINSCW__" -d "WIN32" -d "_WINDOWS" -d
> "__SUPPORT_CPP_EXCEPTIONS__" -c
> wd source -i- -o forwardDeclaration.o -c forwardDeclaration.c
> forwardDeclaration.c:5: illegal use of incomplete
> struct/union/class 'struct For
> wardDeclared'
> Errors caused tool to abort.
> ------> CW problem ends here <------
>
> Changing this line:
> void foo(struct ForwardDeclared[]);
> to:
> void foo(struct ForwardDeclared*);
> however, corrects the "problem".
>
> So, is this (as I believe) a bug in Code Warrior (incorrectly
> complains about correct code), or a bug in gcc and MS compilers
> (do not detect code that is in error)?
>
> Antoine Trux

Absolutely a bug in Code Warrior. In function declarations, "type
name []" is exactly equivalent to "type *name", with the exception of
a special case for compilers conforming to the 1999 or later version
of the C standard, and that special case does not apply here.

So I would suggest submitting a bug report to Metrowerks.

But I would also suggest using "struct ForwardDeclared*", both to get
on with your work immediately, and because I don't like the [] syntax
in declarations because it misleads newbies, and obviously at least
one compiler's parser.

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://c-faq.com/
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.learn.c-c++
http://www.contrib.andrew.cmu.edu/~a...FAQ-acllc.html

[Vladimir Oka]

Flash Gordon wrote:

Vladimir Oka wrote:

PS
Posting full compilable example is, as always, the best policy when
asking this sort of question.

Not when the problem is that it won't compile as in this case! That's a
bit like saying to someone they should not go to the doctor for advice
until they have recovered from whatever they are suffering from!

You're quite right, and I apologise to the OP.

In my defence, I dropped the code into IDE, and, by mistake, chose
Build instead of Compile Only. Then, I mixed up linker and compiler
messages. I should increase the font size and/or get new glasses.

[santosh]

Jack Klein wrote:
.... snip ...

--
Jack Klein
Home: http://JK-Technology.Com

FYI, the above site seems to be unavailable.

.... snip ...

[Jack Klein]

On Thu, 01 Jun 2006 07:46:36 GMT, "Antoine Trux"
<an**********@nokia.com> wrote in comp.lang.c:

Absolutely a bug in Code Warrior. In function declarations, "type
name []" is exactly equivalent to "type *name", with the exception of
a special case for compilers conforming to the 1999 or later version
of the C standard, and that special case does not apply here.

Then, how do you interpret the following paragraph from the C99 Standard
(thanks to Harald van Dijk for pointing it out):

------> start of C99 Standard excerpt <------
6.7.5.2 Array declarators
Constraints
1 In addition to optional type qualifiers and the keyword static, the [
and ] may delimit
an expression or *. If they delimit an expression (which specifies the size
of an array), the
expression shall have an integer type. If the expression is a constant
expression, it shall
have a value greater than zero. The element type shall not be an incomplete
or function
type. The optional type qualifiers and the keyword static shall appear only
in a
declaration of a function parameter with an array type, and then only in the
outermost
array type derivation.

------> end of C99 Standard excerpt <------
?

Antoine

The issue is not how I interpret this clause of the C standard, but
rather how I determine that this clause does not apply. In the
parameter section of a function declarator, this is _not_ an array
declarator.

That is made clear by the following:

6.7.5.3 Function declarators (including prototypes)

[snip]

7 A declaration of a parameter as ‘‘array of type’’ shall be adjusted
to ‘‘qualified pointer to type’’, where the type qualifiers (if any)
are those specified within the [ and ] of the array type derivation.
If the keyword static also appears within the [ and ] of the array
type derivation, then for each call to the function, the value of the
corresponding actual argument shall provide access to the first
element of an array with at least as many elements as specified by the
size expression.

So the standard requires that this:

return_type func_name(type param_name [])

....be adjusted to, and compiled exactly the same as:

return_type func_name(type *param_name)

Of course, "param_name" is optional if the declaration is not the
definition of the function.

So any compiler that complains that "type param_name []" in a function
declaration is violating the constraint against declaring an array of
incomplete type, it is the compiler that is in error. The compiler is
failing to perform the adjustment that 6.7.5.3 p7 requires of it. The
"shall" in this sentence is a requirement on the compiler, not the
programmer.

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://c-faq.com/
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.learn.c-c++
http://www.contrib.andrew.cmu.edu/~a...FAQ-acllc.html

[Harald van Dijk]

Jack Klein wrote:

On Thu, 01 Jun 2006 07:46:36 GMT, "Antoine Trux"
<an**********@nokia.com> wrote in comp.lang.c:

Absolutely a bug in Code Warrior. In function declarations, "type
name []" is exactly equivalent to "type *name", with the exception of
a special case for compilers conforming to the 1999 or later version
of the C standard, and that special case does not apply here.

Then, how do you interpret the following paragraph from the C99 Standard
(thanks to Harald van Dijk for pointing it out):

------> start of C99 Standard excerpt <------
6.7.5.2 Array declarators
Constraints
1 In addition to optional type qualifiers and the keyword static, the [
and ] may delimit
an expression or *. If they delimit an expression (which specifies the size
of an array), the
expression shall have an integer type. If the expression is a constant
expression, it shall
have a value greater than zero. The element type shall not be an incomplete
or function
type. The optional type qualifiers and the keyword static shall appear only
in a
declaration of a function parameter with an array type, and then only in the
outermost
array type derivation.

------> end of C99 Standard excerpt <------
?

Antoine

The issue is not how I interpret this clause of the C standard, but
rather how I determine that this clause does not apply. In the
parameter section of a function declarator, this is _not_ an array
declarator.

An array declarator is a syntactic construct, and also, 6.7.5.2
explicitly addresses function parameters declared as an array type,
even in the quoted text.