Re: pragma import ambiguity

["Adam Beneschan" <adam@irvine.com>]

Frank J. Lhota wrote:
> tmoran@acm.org wrote:
> > One Ada compiler accepts this, another doesn't. I agree with the one that
> > objects.  Are we wrong?
> > procedure testimp is
> >   type logicopenm is ( clear, gl_and);
> >   procedure clear(mask:integer);
> >   pragma import(stdcall,clear,"glclear");
> > begin
> >   null;
> > end testimp;
>
> This is a tough call. Technically, an enumeration literal such as "clear" in
>
> 	type logicopenm is ( clear, gl_and);
>
> is an implicit, parameterless function. Section B.1 of the ARM states
> "If the local_name denotes more than one entity, then the pragma Import
> is the completion of all of them", so one could argue that the import
> clause imports a subprogram for *both* the clear procedure and the
> enumeration literal. This is clearly not possible: the "clear"
> enumeration literal must be implicit.

Not quite; 3.5.1(6) says that the declaration of "clear" is explicit.
This makes a difference because of 3.11.1, which says that implicit
declarations may not have completions, but completions are allowed "in
principle" for any kind of explicit declaration, but only if there is
an implementation for that sort of declaration (B.1(22)).  Also, 6.3.1
says that the function declaration that arises from the enumeration
literal declaration has a default calling convention of Intrinsic, but
it also says that default calling conventions can be overridden,
although I can't see how it could make sense to override the default
calling convention for an enumeration literal, or for that matter most
or all of the other types of subprograms whose default calling
convention is Intrinsic.  So I'm not sure why the language allows this
"in principle".  Anyway, the language isn't clear on whether Import can
be applied to an enumeration literal.

I do believe, though, that it would be wrong for a compiler to reject
this:

    type logicopennm is (clear, gl_and);
    pragma import (stdcall, clear, "glclear");

when there's no overloading involved, but to accept the same pragma
when it can be applied both to a subprogram named "clear" and to the
enumeration literal.  The language does say that Import is the
completion of all entities denoted by the name, and if such a
completion is illegal for any denoted entity, then the compiler has to
reject the pragma.

                             -- Adam