From mboxrd@z Thu Jan  1 00:00:00 1970
X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on polar.synack.me
X-Spam-Level: 
X-Spam-Status: No, score=-1.3 required=5.0 tests=BAYES_00,INVALID_MSGID
	autolearn=no autolearn_force=no version=3.4.4
X-Google-Language: ENGLISH,ASCII-7-bit
X-Google-Thread: 103376,803df5f3f60558d5
X-Google-Attributes: gid103376,public
From: mfeldman@seas.gwu.edu (Michael Feldman)
Subject: Re: Uninitialized "out" parameters
Date: 1996/07/23
Message-ID: <4t3o3s$kt9@felix.seas.gwu.edu>#1/1
X-Deja-AN: 169796241
references: <4smh9i$gp5@krusty.irvine.com> <4ssn9r$p6e@mulga.cs.mu.OZ.AU>
 <4ste71$hg8@felix.seas.gwu.edu> <4svba5$j2i@mulga.cs.mu.OZ.AU>
organization: George Washington University
newsgroups: comp.lang.ada
Date: 1996-07-23T00:00:00+00:00
List-Id: <comp.lang.ada>


In article <4svba5$j2i@mulga.cs.mu.OZ.AU>,
Fergus Henderson <fjh@mundook.cs.mu.OZ.AU> wrote:

>Threads do have a habit of shifting topics.  When you started talking
>about what "cannot be", and referred to undecidability to justify your
>point, rather than referring to the RM, it seemed to me that you were
>talking about what is or is not logically possible, rather than what
>happens to be the case.  I seem to have misinterpreted you, so my
>apologies.

OK. I think the essence of the discussion is that in a language
(like Ada) that does not compel initialization, it is undecidable
whether a given variable has a well-defined (put there by the program)
value when it is used.
>
>If you're talking about Ada-as-it-is, then the compiler should issue a
>warning, but accept the code.  It should do the same thing even for
>a code fragment such as
>
>	    X: Integer;
>	  begin
>	    put(X);
>
>unless it can prove that this code fragment will be executed.

Indeed. A compiler should give a warning, and in my experience, does,
if it can make a reasonably good guess. Some compilers (I think)
provide a compile-time flag that the programmer wants to treat warnings 
as though they were fatal errors. I don;t see anything in gnatinfo to
suggest that GNAT does this, though.
>
>If you're talking about Ada-as-it-should-be, then the question is
>more debatable.  I think it is a good idea for compilers to warn
>about such constructs, and a good idea for programmers to always
>restructure their code to avoid such warnings.  If you accept that,
>it's only a short step from there to agreeing that these messages
>should be errors rather than warnings.

"Error" vs. "warning" is a bit arbitrary; I think it's really kind
of religious. We're talking Ada-as-it-should-be here. For example,
a friendly Ada-as-it-is compiler will give a warning if, say, it _knows_
that Constraint_Error will be raised. This cannot legally be an error,
and in fact, there are cases where the programmer _wants_ to force an
exception in an obvious way (say, to test his exception-handling code!).

So the programmer really should have the choice of handling here.
The treat-warnings-as-fatal flag would do this. Sure, we could take
a religious position that the _default_ should be a fatal error;
that would not bother me at all.
>
>If you transliterate that example from Ada to Mercury, and try
>compiling the resuling code, the Mercury compiler will report an error
>"mode mismatch in if-then-else", and will tell you that `X' is bound in
>one branch of the if-then-else, but not in the other.

So Mercury is producing an error where Ada would produce a warning.
As I said, I think this is just a matter of taste.
>
>>Does Java _compel_ initialization?
>
>My copy of the Java language specification is elsewhere at the moment,
>and I don't have a Java compiler at hand to test, so there is a quite
>large chance that I may be wrong about this, but I _think_ that
>Java does not require initialization at the point of declaration,
>but instead requires that a variable be initialized along all the
>execution paths leading to a possible use of a that variable;
>that would mean that if a variable wasn't used, there would be
>no requirement to initialize it.

And if it _was_ used? How does the JBC interpreter know whether it's 
been initialized? Possibly in the interpreter, there's a "this space 
is uninitialized" flag. As I recall, there have even been such bits
in certain hardware architectures. But the "undecidability" issue
was referring to the _general_ platform case for Ada-as-it-is.

Mike Feldman