Re: GNAT parameter passing, C-style?

[Keith Thompson <kst-u@mib.org>]

"Frank J. Lhota" <NOSPAM.lhota.adarose@verizon.net> writes:
[...]
> In vanilla (i.e. original K&R) C, there are no argument lists in function
> declarations. For that matter, vanilla C does NOT even require functions
> declarations. If an undeclared function is called in vanilla C, the
> unconverted argument list is assumed to be OK, the calling convention is
> assumed to be C, and it is assumed that the function returns an int.

The term "vanilla" implies that the original K&R C is the default
version of the language.  It isn't.  The 1990 ISO C standard is almost
universally implemented these days (though not always perfectly); it's
difficult to find a C compiler that doesn't implement prototypes, for
example.  (My ancient SunOS 4.1.3 box has a K&R C compiler, but I
rarely use it, since I've also installed gcc.)

> ANSI C depreciates this loose approach to functions. ANSI C strongly
> encourages the full declaration of all functions used, including argument
> lists. For compatability, however, ANSI C accepts function declarations with
> no argument lists (e.g. "double sin();"), as well as the calling of
> undeclared functions. Since there is no requirement that the user will
> declare a function's argument list (or the function for that matter), a C
> compiler may not be able to tell whether a function accepts a variable
> argument list or not. For that reason, C compilers have to assume the C
> calling convention, unless the user indicates via declaration or command
> line options.

Nitpick: it's "deprecates".

The latest ISO C standard, C99, requires full declarations for
functions, but it's not widely implemented yet; so far, it's not
catching on as quickly as C90 did.  (C90, the 1990 ISO C standard, is
essentially identical to C89, the 1989 ANSI C standard.)

If a function takes a variable number of arguments, any call to that
function without a prototype in scope invokes undefined behavior.
That means the implementation isn't required to diagnose the problem,
but the standard places no constraints on the program's behavior.
(Over in comp.lang.c, we traditionally say that it's allowed to make
demons fly out your nose.)

One of the biggest advantages of Ada over C is that it has far fewer
instances of undefined behavior.  An advantage of C over Ada is that
it uses the straightforward term "undefined behavior" rather than
"erroneous execution".

> Every C compiler that I have worked with uses the C calling convention by
> default when compiling C (as opposed to C++) code.
[...]

There is no such thing as "the C calling convention", though some
implementations may (misleadingly) use the phrase to refer to the
default calling convention used by a particular C compiler on a
particular system.

-- 
Keith Thompson (The_Other_Keith) kst-u@mib.org  <http://www.ghoti.net/~kst>
San Diego Supercomputer Center             <*>  <http://www.sdsc.edu/~kst>
Schroedinger does Shakespeare: "To be *and* not to be"