Re: [RFA] Function return type checking

[Klee Dienes <kdienes at apple dot com>]

On Tuesday, February 5, 2002, at 08:07 AM, Daniel Jacobowitz wrote:

> Have you considered casting the function itself?  Something like:
> (gdb) print ((float (*)(float)) fabs) (3.0)
> $1 = 3.0
> (gdb) set fabs
>
> Which, I will note, already works except for the fact that we neglect
> the argument types on function pointers.  Or
> (gdb) set $fabs = (float (*)(float)) fabs
> (gdb) p $fabs(4.0)
> $2 = 4.0

We have; for a long time that was the answer we gave to people who were 
running into this problem.  Our experience was that it was a nightmare 
to explain to people how this mechanism worked, and that even for folks 
who did undertand it, they found it a major mental burden to use in 
practice.  C function casting syntax is neither intuitive nor pleasant 
to type.

The reason we chose the "cast" syntax wasn't so much to be cute, but 
because it was the first thing everyone tried when they were trying to 
get this to work.  People would try 'print (float) fabs (3.0)', followed 
by 'print {float} fabs (3.0)', usually followed by several unsuccessful 
attemtps to remember the correct syntax to cast the function pointer.

I also think there's a pretty solid rationale behind the syntax, and one 
that generalizes to argument-passing.  The theory goes:

All symbols without debugging information are assumed to be of type 
'unknown' (previously, they were assumed to be 'int', or (int (*) ())).  
When you cast an expression of type 'unknown' to anything else, GDB does 
no conversion, but simply interprets the data (or generates the data) 
according to the specified type.  So if you have 'f' with no symbols,

   print (long long) f ((long long) 7, (float) 3.0)

will generate a function call as if 'f' had been declared as

   long long f (long long, float)

For function arguments, I claim this is both intuitive and matches the 
behavior of the C compiler.  For function return values, wee have to 
choose something for what 'print (type) f ()' is to mean, and I claim 
that it's the best of the two alternatives (the other being "assume 
'int', then cast the 'int' to the specified type).