Re: Ada Java question => clarification

[dewar@merv.cs.nyu.edu (Robert Dewar)]

Brad said

<<Despite the two RM95 references quoted above, the real reason is found in
4.9(24) which let's us know that a static constant must be a full constant
declaration or a renaming. java.awt.event.UP is a constant integer whose
value is supplied via a pragma Import. This means that it is constant, but
*not* a static constant.

So, unfortunately, you need to change the case statement into an if statement.>>

Two comments. First, it is always hard to guess why someone may not understand
something. Whether Brad's *real* reference is any more correct than the
RM references given depends on what you do and do not understand. If your
problem was that you did not realize that case statements required static
constants, then the original reference was fine. if you knew that, but
did not know what a static constant is, then some other RM reference is
right, if you know what a static constant is, but had forgotten that a
pragma Import does not make a constant static, then some other reference
is right, if you want to know WHY a pragma Import does not make a constant
static ("Hey, look at my Java code, it is obviously a static constant there"),
then some other RM reference is appropriate. That's the trouble with giving
an RM reference. You will never know which is the right one, and if you give
a wrong one, you waste the programmer's time on a wild goose chase.

Second, I don't see what is so unfortunate about this, it seems, if you think
about it, a natural restriction. I guess you could say it is unfortunate that
we do not have a kind of combined Ada-Java standard, with combined semantics,
and a combined compiler, but that would be asking a lot :-)

Generally, you cannot expect an Ada compiler to understand anything about
a foreign language unit that would require looking inside the unit and
understanding it in foreign language terms. Yes one can imagine an
Ada-to-Java compiler that would have this capability, but it is certainly
not something you are likely to encounter. Such a compiler could have given
a more informative message, something like:

    "static constant required in case statement"
    "constant "xxx" is static in Java, but not considered static on the Ada side"

or somesuch. I am not sure that any specific RM refernce is particularly
helpful here. There is no specific statement in the RM that a constant
completed by pragma Import is not-constant, it is the absence of a statement
to the contrary that is significant, and it is hard to give negative
references to the RM :-)