Re: Partial function types

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

[I am responding to a post in comp.lang.c++, but the subject is
C, so the response is directed to comp.lang.c.]
>
Keith Thompson <Keith.S.Thompson+u@gmail.com> writes:
>

wij <wyniijj5@gmail.com> writes:
[...]
>

typedef int (*ptr)();  // ptr is pointer to int function
int H(ptr x, ptr y);
int D(ptr x)
{
  int Halt_Status = H(x, x);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
}
>
int main()
{
  H(D,D);
  return 0;
}
>
The code above does not compile:

>
Yes, it does (as you acknowledge in a later post).
>
This:
    typedef int (*ptr)();
defines "ptr" as an alias for a type that can be described in English
as "pointer to function returning int".  The empty parentheses
indicate that the function takes an unspecified but fixed number
and type(s) of arguments;  this is an old-style declaration.  [...]
>
The function H is declared but not defined.  [...]

>

I'll note that the code (declares and) defines the function D,
but never calls it.  The address of D is passed to H, but without
a definition of H we can't guess what it does with that address.

>
All good up to this point.
>

It's possible to rewrite the code to (a) avoid the use of old-style
function declarations [...]

>
Not without radically altering the code.  Because D is passed
as an argument to H, and because of how H and D are declared,
the type of (the address of) D has to match the type of D's
first parameter.  It isn't possible to do this in C without
resorting to a partial function type somewhere (because the
type of D is infinitely recursive).

What I had in mind, though I didn't take the time to dig into it,
was to define a "generic" pointer-to-function type and use casts
where necessary.

But I don't understand the intended semantics well enough to be sure
of how to rewrite it.  (I don't consider this lack of understanding
to be a problem.)

There are other ways to work around this problem, for example
involving having a pointer-to-function member in a struct,
but that would entail changing either the declarations or
the call of H() with D as an argument, which seems to be
stretching the bounds of "rewrite the code".
>

The code as presented is a valid C *translation unit*, but it
is not a valid *program*,

>
It might be better to say it's a valid partial program, but not
a complete program.

I don't see how that's better.

and it has no behavior.

>
It doesn't have behavior in the sense that it doesn't do anything.
It does have behavior in the sense that the C standard prescribes
a meaning for the declarations and definitions given.  I believe
the C standard uses the term "behavior" in both of those senses.

I believe it does not.  N1570 3.4 defines "behavior" as "external
appearance or action".  Behavior does not occur until execution time.

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