Re: Uninitialized "out" parameters

[mfeldman@seas.gwu.edu (Michael Feldman)]

In article <4ssn9r$p6e@mulga.cs.mu.OZ.AU>,
Fergus Henderson <fjh@mundook.cs.mu.OZ.AU> wrote:
>mfeldman@seas.gwu.edu (Michael Feldman) writes:
>
>>It _cannot_ be a compiler error, because in general it is undecidable
>>whether a variable is used before it is initialized.
>
>Sure it could be a compiler error.  I know of at least one language
>for which that is the case, and there are probably others.
>(I'm not sure, but Java may be one of them?)

I'm not sure about Java either, but you quoted me out of context; we
were talking about Ada, in which there is no _required_ initialization
of variables. In that context, my statement is correct.

If the language rules required that each variable must be initialized
at elaboration (say, either by an initialization expression or by
default using some value within the type of that variable), then
there would be no uninitialized-variable problem because all variables 
were guaranteed to be initialized.
>
>Note that type correctness (defined in the dynamic sense) is also
>undecidable -- yet there are certainly *lots* of languages for which
>the compiler enforces type safety at compile time.

That is a different issue. If Ada _compelled_ initialization, it would be
trivial to determine whether all variables were initialized. Certainly the
compiler could "enforce" initialization; if you failed to supply an
initializer, the compiler would supply a default. There have been
earlier threads on why Ada does not compel initialization.

This is NOT what we were talking about. The thread was about Ada as 
it is, not as we might like it to be. Given that Ada does _not_ compel
initialization, it is undeciable for a compiler to catch all cases
of use-before-initialize. Some trivial cases can be caught; others
can be warned as "_might_ be used before initialization".

Consider a trivial case:

  X: Integer;
  Y: Character;

begin

  get(Y);
  if Y = 'a' then
    X := -3274;
  else
    code not involving X
  end if;
  put(X);

What should the compiler do here? _Maybe_ X will be used before
initialization. We cannot know with confidence whether it _will_ be.

Does Java _compel_ initialization? Which languages do, in your experience?

Mike Feldman