Keep in mind that environment variables are not yet set at the time of BEGIN, which also means they aren't set at the time of any use. If you're setting variables based on that, you'll be very confused.

Keep in mind that environment variables are not yet set at the time of BEGIN

I'm not sure what you mean by that.

$ perl -we'BEGIN{print $ENV{MANPATH}}'
/usr/man:/usr/local/man:/usr/share/man:/usr/autotool/devel/man:
[download]

Here's code that illustrates the question. I start with "Foo.pm":

# Foo.pm

my $shell = $ENV{'SHELL'} || "";

BEGIN {
    if ( $ENV{'SHELL'}) {
        print "\$ENV{'SHELL'} is $ENV{'SHELL'}...\n";
    } else {
        print "\$ENV{'SHELL'} is not set...\n";
    }
    if ( $shell ) {
        print "\$shell is $shell...\n";
    } else {
        print "\$shell is not set...\n";
    }
}

1;
[download]

Now, the perl script, "foo" has nothing but:

#!/usr/bin/perl
use Foo;
print "done.\n";
[download]

Running the program should be self-explanitory. The question is: if "use" is an implicit BEGIN, and there is no precedence to the orders of the BEGIN blocks, then why isn't "$shell" set outside of the BEGIN block on Foo.pm?

And, as far as Randall's comment about environment variables not set at the time of BEGIN, then what explains the behavior of this sample program?

Dan Heller
http://www.danheller.com

Perl scripts are read by perl one line at a time and the code is compiled as it is read. Right after the '}' that ends a BEGIN block is read (compiled), the code inside the block is run. require causes a different file to be read. use does a require inside of a BEGIN block. After the last line of code of a Perl file is read (either the main script or a required module), the code in that file starts running from the top. Code in subroutines isn't run until the subroutine is called, of course. my $var= EXPR; declares $var when that statement is compiled but evaluates EXPR and assigns it to $var only when that statement is run.

That is all you need to know to trace the execution order of Perl code (things like END, INIT blocks, and string-eval require additional specific knowledge, of course).

Each statement has it's own specific "compile time" and zero or more specific "run times". People often talk about "run-time" or "compile-time" actions in broad-sounding terms and even sometimes make the mistake of talking about some global "run time" or global "compile time". But each statement has its own time when it gets compiled and own time(s) when it gets run. They can interleave in interesting ways because of things like BEGIN, use, require, and eval.

So just follow the order in which Perl reads the lines and the order things get done is quite clear.

For "use Foo;", the order is:

Compile: use Foo;
Compile: BEGIN { require Foo; import Foo; }
Run:     require Foo;
         (starts compiling Foo.pm)
Compile: my $shell = $ENV{'SHELL'} || "";
         (my $shell; gets declared)
Compile: BEGIN { ... }
Run:     Code from above BEGIN block
         ($shell is declared but uninitialized here)
Compile: 1;
         (Foo.pm fully compiled, start running it)
Run:     my $shell = $ENV{'SHELL'} || "";
Run:     1;
         (require Foo; returns)
Run:     import Foo;
...
[download]

Clearer?

- tye        

Sorry, I really can't follow your argument. Could you please show some concrete code (all in one place)? In particular, I would like to know (1) what module contains what variable-initialization code that is tested in a BEGIN block; and (2) where exactly is this BEGIN block relative to the use or require statement responsible for loading the module.