Re: What can we assume in a BEGIN block ?

[dave_the_m]

In the following,

$foo = 1;
BEGIN { $foo = 2 }

The BEGIN block is executed first, so $foo is first set to 2, and then to 1. On the other hand,

BEGIN { $foo = 1; $foo = 2 }

$foo is set to 1 and then 2.

Dave.

[leriksen]

I suppose this just highlights my difficulty

I 'expect' the opposite.

$foo = 1; this has been parsed first, hasn't it ? So $foo == 1, right ?

THEN the BEGIN is parsed, and so now $foo == 2, right ?

[hv]

The code under discussion is effectively this:

  our $initialized = 0;
  BEGIN { $initialized = 1; }
  more stuff

The significant information is that our $variable = value has both a compile-time and a runtime effect.

When Perl parses the first line, it sees the variable declaration - the compile-time effect - and therefore knows how to interpret other references to this variable in the rest of the lexical scope (file scope in this case). It also sees the assignment, and compiles that to be executed at runtime (the runtime effect).

When it parses the second line it sees the BEGIN block, so as soon as it has reached the end of the block it suspends parsing to execute the block. At this point the runtime assignment $initialized = 0 has not yet happened.

It then resumes parsing the file, and once the entire file has been compiled it then executes the top-level code. This is the point at which the variable gets set to zero.

Hugo

[leriksen]

Thank you hv, that helps a lot.

I suppose that begs the next point - say you have a whole bunch of modules with runtime initialisations, assignments and method/sub calls - is there anything documented as to the order these get done (the same order as the sequence of 'use' statements would be a first guess) ?

[fergal]

I think you're reading

our $foo = 1;
BEGIN {...}

as: allocate some memory and initialise it to 1 and you expect it to happen at parse/compile time but you should think of it as just a shorthand for

our $foo;
$foo = 1;
BEGIN {...}

so the memory is allocated at compile time but the initialisation happens at runtime, which will be after all the BEGIN blocks have run.

It might seem like a good idea to initialise $foo to 1 at the same time as allocating the space but then you run into problems like

our $foo=sub_which_hasnt_been_compiled_yet();