Hi folks,

We all know that when one writes code like this:

```
int main(void)
{ int x;
x = 42;
int y = 5;

return 0;
} ```

....under strict C89/90, one will get a warning or error with, eg, GCC
(depending on the flags, of course. However, I thought the reference
to this rule in the ANSI C89 standard would be easy to find, but I was
perusing the full text of the C89 standard the other day and I couldn't
find it anywhere.

(eg: `gcc -Wall -std=c89 -pedantic-errors`)

Does anyone have a paragraph/section reference number for this rule
under the ANSI C89 or ISO C90 standard?

I'd like to make reference to it in a stream I'm working on, next time
I'm live.

Thanks in advance!

--
Poprocks

Poprocks <please@replytogroup.com> writes:
>Hi folks,
>
>We all know that when one writes code like this:
>
>```
>int main(void)
>{
> int x;
> x = 42;
> int y = 5;
>
> return 0;
>}
>```
>
>...under strict C89/90, one will get a warning or error with, eg, GCC
>(depending on the flags, of course. However, I thought the reference
>to this rule in the ANSI C89 standard would be easy to find, but I was
>perusing the full text of the C89 standard the other day and I couldn't
>find it anywhere.
>
>(eg: `gcc -Wall -std=c89 -pedantic-errors`)
>
>Does anyone have a paragraph/section reference number for this rule
>under the ANSI C89 or ISO C90 standard?
>
>I'd like to make reference to it in a stream I'm working on, next time
>I'm live.

Looking at n1256 (C99 draft), the productions in 6.8.2 (Compound Statement)
cover the mixing of code and declaration by allowing either in 'block-item'.
C99 draft:

Syntax

compound-statement:
{ block-item-listopt }

block-item-list:
block-item
block-item-list block-item

block-item:
declaration
statement

C89:

3.6.2 Compound statement, or block

Syntax

compound-statement:
{ declaration-list<opt> statement-list<opt> }

declaration-list:
declaration
declaration-list declaration

statement-list:
statement
statement-list statement

Le 09/05/2022 à 21:57, Scott Lurndal a écrit :
> Poprocks <please@replytogroup.com> writes:
>> Hi folks,
>>
>> We all know that when one writes code like this:
>>
>> ```
>> int main(void)
>> {
>> int x;
>> x = 42;
>> int y = 5;
>>
>> return 0;
>> }
>> ```
>>
>> ...under strict C89/90, one will get a warning or error with, eg, GCC
>> (depending on the flags, of course. However, I thought the reference
>> to this rule in the ANSI C89 standard would be easy to find, but I was
>> perusing the full text of the C89 standard the other day and I couldn't
>> find it anywhere.
>>
>> (eg: `gcc -Wall -std=c89 -pedantic-errors`)
>>
>> Does anyone have a paragraph/section reference number for this rule
>> under the ANSI C89 or ISO C90 standard?
>>
>> I'd like to make reference to it in a stream I'm working on, next time
>> I'm live.
>
> Looking at n1256 (C99 draft), the productions in 6.8.2 (Compound Statement)
> cover the mixing of code and declaration by allowing either in 'block-item'.
> C99 draft:
>
> Syntax
>
> compound-statement:
> { block-item-listopt }
>
> block-item-list:
> block-item
> block-item-list block-item
>
> block-item:
> declaration
> statement
>
> C89:
>
> 3.6.2 Compound statement, or block
>
> Syntax
>
> compound-statement:
> { declaration-list<opt> statement-list<opt> }
>
> declaration-list:
> declaration
> declaration-list declaration
>
> statement-list:
> statement
> statement-list statement

Yes. It's not *explicitely* stated in the C90 std other than from the
grammar, which defines compound statements as a declaration list
(optional) followed by a statement list (optional). Thus, as per the
grammar, declarations can't come after statements.

And function bodies are defined as compound statements, so you have your
whole case.

There's a summary of the grammar in annex B of ISO C90 and annex A of
C99 and upwards. I find it unfortunate that the grammar is not expressed
as BNF or something similar, but we have to do with what's available. As
it is given it lacks a synthetic, hierarchical view. IMHO.

On 2022-05-09, Poprocks <please@replytogroup.com> wrote:
> ...under strict C89/90, one will get a warning or error with, eg, GCC
> (depending on the flags, of course. However, I thought the reference
> to this rule in the ANSI C89 standard would be easy to find, but I was
> perusing the full text of the C89 standard the other day and I couldn't
> find it anywhere.

The rule is that in a compound statement, there is a list of zero or
more declarations, followed by zero or more statements.

Look for the compound statement syntax.

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

Guillaume <message@bottle.org> writes:

[.. regarding C grammar rules ..]

> There's a summary of the grammar in annex B of ISO C90 and annex A
> of C99 and upwards. I find it unfortunate that the grammar is not
> expressed as BNF or something similar, [...]

The C90 and C99 grammar rules are not written in BNF, but surely
they deserve to be termed something similar. They can easily
be mapped to BNF, for example, if one wants to do that.

> As it is given it lacks a synthetic, hierarchical view. IMHO.

I don't know what you mean by those two adjectives here. Can you
give an example illustrating a hierarchical view? And also an
example illustrating a synthetic view? To keep things relatively
simple, let's say for the syntactic category 'expression' in C90,
and omitting anything having to do with type names more than just
a single identifier.

On Wednesday, May 11, 2022 at 9:55:07 AM UTC-5, Tim Rentsch wrote:
> Guillaume <mes...@bottle.org> writes:
>
> [.. regarding C grammar rules ..]
> > There's a summary of the grammar in annex B of ISO C90 and annex A
> > of C99 and upwards. I find it unfortunate that the grammar is not
> > expressed as BNF or something similar, [...]
>
> The C90 and C99 grammar rules are not written in BNF, but surely
> they deserve to be termed something similar. They can easily
> be mapped to BNF, for example, if one wants to do that.

Mapping to BNF is easy enough, true. I (and I suspect others) would have
an easier time with it if it were left factored so it can be used directly by
the simpler parsing algorithms. Left factoring by hand I've found to be
tedious and error prone. And if you make a tool to do it, then you're not
in "simple parsing algorithm" territory anymore, sigh.

luser droog <luser.droog@gmail.com> writes:

> On Wednesday, May 11, 2022 at 9:55:07 AM UTC-5, Tim Rentsch wrote:
>
>> Guillaume <mes...@bottle.org> writes:
>>
>> [.. regarding C grammar rules ..]
>>
>>> There's a summary of the grammar in annex B of ISO C90 and annex A
>>> of C99 and upwards. I find it unfortunate that the grammar is not
>>> expressed as BNF or something similar, [...]
>>
>> The C90 and C99 grammar rules are not written in BNF, but surely
>> they deserve to be termed something similar. They can easily
>> be mapped to BNF, for example, if one wants to do that.
>
> Mapping to BNF is easy enough, true. I (and I suspect others)
> would have an easier time with it if it were left factored so it
> can be used directly by the simpler parsing algorithms. [...]

But doing that would make it harder for people to read and
understand, which is after all the primary purpose of the C
standard.