Re: Should Inline be private in the private part of a package spec?

[Georg Bauhaus <rm.dash-bauhaus@futureapps.de>]

On 08.08.12 03:48, Shark8 wrote:
>> it is not important to know
>> the convention of an import when writing the call (of the
>> Ada subprogram from the package spec).
>
> No, that's not only wrong but _very_ wrong. Conventions are *vital* to a specification.

Later, you said

> and is therefore properly placed into the specification (or possibly private section if you're providing an API layer).

Yes, these aspects could be written in the private part
of a package, which is what I had suggested. So that
compiler thingies and optimization issues and even compiler
specific pragmas would not litter the public part of a package spec.
They do that, IMHO, if you use aspect notation for pragma(tic) stuff.

> Let us consider just one subprogram:
>   Procedure Add(Object : In Out Our_Type; Value : In Integer);

Do the call statements change, though?

      Add (Some_Object, 42);

How do you, the programmer, have to change the above call
in order for the convention to be handled? You don't need to
change the way you write the call.

Calling conventions are for the compiler of high level languages,
for the most part. There are circumstances where the convention
becomes important, and the compiler should tell us.
Optimization can become important, too, and even then a compiler
like GNAT might warn about things that have been optimized away.
But both do not normally change the way a programmer writes
a correct call in source text. So, WRT writing call statements,
the interface of a subprogram can be understood without looking
at its calling convention, or considering implications for
speedier execution.

> That is, the convention drastically alters the interface,

Not at all. The calling convention alters the translation process,
and, possibly, its outcome. The convention does not alter the way
the programmer passes parameters in calls. The interface, in Ada,
would be a source text thing.

(And both Pascal compilers and C compilers might not even be
using a stack when translating the above call, for example, if both
parameters can be passed in registers, and the return address lives
in a special register, etc.. Or when the hardware does not even have
a stack, but still allows implementations of either language.)