Re: GNAT parameter passing, C-style?

["Frank J. Lhota" <NOSPAM.lhota.adarose@verizon.net>]

"Hyman Rosen" <hyrosen@mail.com> wrote in message
news:1072883131.278899@master.nyc.kbcfp.com...
> Frank J. Lhota wrote:
> The upshot is that even when calling a function without a prototype, the
> compiler may pass arguments any way it likes, and it is absolutely not
> required to "push" them onto a "stack" in any particular order.

It may not be required by the standard, but it is required to support legacy
code. Certainly any C code written after ANSI C became widely available
should use prototypes, but for many years there was plenty of maintained K&R
C code written like this:

    extern int futz();
    {
        ...
        if ( futz( name, count ) ) ...
    }

where there is no indication as to whether or not the function takes a
variable argument list. You can argue all you want that a compiler is not
required to generate correct code for such a program, but the sheer weight
of legacy code forces the compiler manufactures to not break code like this.

I go back to my original question: does anyone know of a C compiler which,
when compiling C (not C++) does not default to the C calling convention
(i.e. arguments pushed on the stack in reverse order, and popped off by
calling function) in the absence of any indication of another convention?
The two C compilers I am currently using (GCC version 3.3.1, MSVC Version 6)
both default to the C convention. I recall that every Borland compiler up to
4.0 defaulted to the C convention as well, as did the early Zortech /
Symantec compilers.

Again, I am not saying this out of fondness for the C calling convention.
The original K&R specification, unfortunately, forced the undesirable use of
this convention for many years. The C++ people should be congraduated for
making a bold enough break from the past to eliminate almost all need for
this convention.

I should also note that this has never been an issue in Ada. (This is an Ada
newsgroup, after all).