Re: gnade error

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

Jeffrey R. Carter wrote:
> Stephen Leake wrote:
> > Brian May <bam@snoopy.apana.org.au> writes:
> >
> >> gnu-db-sqlcli.adb:134:42: cannot inline "To_Ada" (call returns
> >> unconstrained type)
> >
> > That seems clear to me.
> >
> > It's _legal_, but somewhere the code requests inlining of To_Ada,
> > which GNAT can't do, for the reason stated.
> >
> > The fix is to remove the 'pragma Inline'.
>
> A pragma Inline should not cause a compilation error. The presence or
> absence of a pragma should not change a legal program to an illegal
> program nor illegal to legal.

This really isn't true.  First of all, many pragmas defined by the
language have legality rules, and using a pragma that violates the
legality rules makes your program illegal.  As for Inline, there's a
legality rule that the names listed need to be callable entities, plus
there are rules about where Inline pragmas can be placed.  Violating
those rules will make your program illegal.

  The RM says that Inline is a recommendation that an implementation is
free to ignore.  Using an Inline that will get ignored will not make
your program illegal according to the RM, but that is *not* the same as
saying that it shouldn't cause a compilation error; there are plenty of
reasons why users might want a compiler to reject a legal program, and
using an ignored Inline might be one reason, especially if a warning
message might get missed during a "make".  Maybe one of the GNAT flags
Brian used told it to reject pragmas it couldn't handle.  I don't know
GNAT very well so I can't say.

Finally, the statement "The presence or absence of a pragma should not
change a legal program to an illegal program nor illegal to legal"
isn't true even for implementation-defined pragmas.  2.8(17) does say
an implementation-defined pragma should not make an illegal program
legal, but it also lists a couple exceptions to this rule.  2.8 also
implies that a pragma that is not defined by the language nor by the
implementation is ignored, but syntax rules still apply.  However, if
you use an implementation-defined pragma but violate the
implementation-defined rules for that pragma, there's nothing I can see
in 2.8 that says your program is still legal.  That decision is left up
to the implementation.

                          -- Adam