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

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

James Kuyper <jameskuyper@alumni.caltech.edu> writes:
>

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

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

James Kuyper <jameskuyper@alumni.caltech.edu> writes:
[...]
>

It's main potential usefulness is not in the definition of the
function, but in calls to the function.  If the calls occur in
a different translation unit from the definition, the compiler
does not have the needed information.

>
It does if the visible declaration has the same information.

>
Like 'restrict', parameter array length information, specified by
way of 'static', is ignored outside of function definitions.  As
was intended (with 'restrict' also).

>
? What "static" does when applied to an array parameter's length is to
render the behavior undefined if the function is called with a pointer
that points to an array that is shorter than the specified length.  Are
you saying that it has no such effect except for inside the function
definition?  I'm not sure what that would even mean - is the behavior
undefined only for recursive calls to the function?

>
What I mean is that such uses of 'static' have no effect when
used in declarations that are not part of a definition.

I need to correct myself.  This statement is simply wrong.  Giving a
parameter declarator a 'static' length specification, as part of any
function declaration whatsoever, has the same effect as it would if
it had been given on the function definition.  To present an example,
if we have three source files, x.c, y.c, and z.c, with

   /* x.c */
   int foo( int v[] );

   int
   example(){
      return foo( 0 );
   }


   /* y.c */
   int
   foo( int v[] ){
      return  v ? v[0] : -1;
   }


   /* z.c */
   int foo( int v[ static 1 ] );


then because of the declaration of foo() in z.c, the call to foo()
in x.c has undefined behavior, because a "shall" requirement is
violated by passing a null pointer for parameter v, which must
point to an array with at least one element.

As best I can determine the description of how 'static' works in
such cases has not changed since its original introduction in C99
up to the present.