Re: pragma convention

[Anonymous Coward <bogus_addy@bogus_domain.net>]

In article <cHcbf.204$c_1.175@newsread3.news.pas.earthlink.net>, 
Jeffrey R. Carter wrote:
> 
> pragma Convention (X, ...
> 
> really means the convention used by some specific X compiler chosen
> by the Ada compiler developers for those cases where the X language
> does not rigorously specify the characteristic in question.

I find it interesting that pragma Convention even appears in the ARM,
considering there is no definite behavior required for it.  It seems
it would be more appropriate to not even mention it in the ARM, and
let the compiler implementors decide whether to have it.  Or if pragma
Convention should be mentioned in the ARM, it should be rewritten.  I
would rewrite this:

   ARM B.1.21

   If pragma Convention applies to a type, then the type shall either
   be compatible with or eligible for the convention specified in the
   pragma.

to state something like:

   If pragma Convention applies to a type, then the type shall be
   compatible with conventions specified in the pragma for languages
   that have a convention.  For other languages, pragma Convention is
   to be offered at the discretion of the compiler authors.

From there, it would be useful to have a list of languages that have
default representations, so ADA programmers know when they can expect
some precise behavior from pragma convention.

> Convention C does do certain common things for you. For an access
> type, you insure that it is just a pointer, and doesn't contain any
> additional data (which Ada's access values can and sometimes do
> contain). 

That's useful to know.. but why doesn't the ARM lay down the rule on
that?  It seems largely like guesswork to know what to expect from
pragma convention.

Is there a way to explicitly define a pointer in ADA to be a raw
address as it is for C, without the pragma convention?  Is that what
system.address is?  

> For subprograms, you get automatic conversion of parameters to
> pointers to match C passing rules and make [in] out parameters work
> properly.
> 
> This latter is very useful; you can write
> 
> procedure C (X : out Interfaces.C.Int);
> pragma Import (C, X, "xInC");
> 
> and the compiler takes care of passing a pointer for you.

Parameter modes are handled entirely by pragma import, correct?  I'm
not sure what pragma convention does in that respect.

Someone stated earlier that pragma convention will ensure order is
preserved for records types passed to pragma convention, but the GNAT
manual states that pragma Convention has no effect on records:

http://gcc.gnu.org/onlinedocs/gcc-3.3.5/gnat_rm/Effect-of-Convention-on-Representation.html

I find it frustrating to work with loosely defined characteristics in
ADA.  At this point, I'll continue to use pragma convention for the
heck of it, but ultimately it seems I cannot solely rely on it to do
anything, and I should be rep specing records and enum sizes anyway.