Re: Loops (was Re: do { quit; } else { })

Tim Rentsch <tr.17687@z991.linuxsc.com> writes:

Keith Thompson <Keith.S.Thompson+u@gmail.com> writes:

Tim Rentsch <tr.17687@z991.linuxsc.com> writes:

Keith Thompson <Keith.S.Thompson+u@gmail.com> writes:

[...]
>

My personal interpretation is that this:
>
void func(int arr[static 5]) {
}
>
int main(void) {
    int arr[10];
    func(arr+5);    // OK
    // func(arr+6); // UB
}
>
is valid, because, for example, the last 5 elements of a 10-element
array object can be treated as a 5-element array object.  gcc seems
to agree, based on the fact that it warns about func(arr+6) but
not about func(arr+5).
>
This is a fundamental part of my mental model of C, but in a few
minutes of searching I wasn't able to find explicit wording in the
standard that supports it.

>
In N1570, 6.7.6.3 p7.

>
Did you mean to imply that that paragraph supports (or refutes) my
statement?  [...]

>
No.  I posted the reference to say that the cited paragraph supports
the conclusion that 'func(arr+6)' is undefined behavior.

I wish you had said so in the first place.  Of course func(arr+6) has
undefined behavior.  Did anyone in this thread say or imply otherwise?

"""
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.
"""
>
The question is whether, for example, the last 5 elements of a
10-element array object can be treated as a 5-element array object.
If someone can cite wording in the standard that answers that
question, I'd appreciate it.  (I'll be happier if the answer is yes.)

>
To me it seems obvious that 6.7.6.3 p7 is meant to cover the
case of 'func(arr+6)' as being undefined behavior.

But that's not the question I was addressing.  My question is whether
func(arr+5) has defined behavior, based on whether or not a+5 points to
the *first element* of an array.

Note that 6.7.6.3 p7 doesn't say "array object", it says just
"array".  I believe the choice of wording is neither an accident nor
an oversight.

Then please explain what you see as the difference.  Wording in the
standard to support the distinction would be welcome.

Given `int arr[10];`, do the last 5 elements of arr constitute an
"array"?   Do they constitute an "array object"?  And the same
questions for arr as a whole.

Looking into this a bit more, I realize that the question doesn't
matter if there's no "static" keyword between the [ and ].  In that
case, the parameter is of pointer type, and the description of
pointer arithmetic (N1570 6.5.6p8) explicitly allows the pointer
to point to the i-th element of an array object.  The wording for
[static N] is the only place I've seen (so far) that specifically
refers to the *first* element of an array object, raising the
question of whether a subobject of an array object is itself an
array object.

>
Again, not an array object, just an array.
>

This might just be some slightly sloppy wording that was
introduced in C99 and never corrected.

>
I draw the opposite conclusion.  The wording of 6.7.6.3 p7 was
carefully chosen so that it would cover cases like 'func(arr+6)'.

But func(arr+5) is the case I was wondering about.  (That's why I
commented out the func(arr+6) call.)

[snip]

--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
void Void(void) { Void(); } /* The recursive call of the void */