Better docs for the special code blocks, based on :

Subject: [DOCPATCH] BEGIN, CHECK, INIT, END explained more
Message-Id: <p05111b01bbeec2e8bf30@[192.168.56.3]>

p4raw-id: //depot/perl@21832

1 files changed, 38 insertions, 22 deletions

diff --git a/pod/perlmod.pod b/pod/perlmod.pod
index c80836c752..752d1f3a19 100644
--- a/pod/perlmod.pod
+++ b/pod/perlmod.pod
@@ -253,23 +253,34 @@ rather than:
 This also has implications for the use of the SUPER:: qualifier
 (see L<perlobj>).
 
-=head2 Package Constructors and Destructors
-
-Four special subroutines act as package constructors and destructors.
-These are the C<BEGIN>, C<CHECK>, C<INIT>, and C<END> routines.  The
-C<sub> is optional for these routines. See the B<begincheck> program, at
-the end of this section, to see them in action.
-
-A C<BEGIN> subroutine is executed as soon as possible, that is, the moment
-it is completely defined, even before the rest of the containing file
-is parsed.  You may have multiple C<BEGIN> blocks within a file--they
-will execute in order of definition.  Because a C<BEGIN> block executes
-immediately, it can pull in definitions of subroutines and such from other
-files in time to be visible to the rest of the file.  Once a C<BEGIN>
-has run, it is immediately undefined and any code it used is returned to
-Perl's memory pool.  This means you can't ever explicitly call a C<BEGIN>.
-
-An C<END> subroutine is executed as late as possible, that is, after
+=head2 BEGIN, CHECK, INIT and END
+
+Four specially named code blocks are executed at the beginning and at the end
+of a running Perl program.  These are the C<BEGIN>, C<CHECK>, C<INIT>, and
+C<END> blocks.
+
+These code blocks can be prefixed with C<sub> to give the appearance of a
+subroutine (although this is not considered good style).  One should note
+that these code blocks don't really exist as named subroutines (despite
+their appearance). The thing that gives this away is the fact that you can
+have B<more than one> of these code blocks in a program, and they will get
+B<all> executed at the appropriate moment.  So you can't execute any of
+these code blocks by name.
+
+A C<BEGIN> code block is executed as soon as possible, that is, the moment
+it is completely defined, even before the rest of the containing file (or
+string) is parsed.  You may have multiple C<BEGIN> blocks within a file (or
+eval'ed string) -- they will execute in order of definition.  Because a C<BEGIN>
+code block executes immediately, it can pull in definitions of subroutines
+and such from other files in time to be visible to the rest of the compile
+and run time.  Once a C<BEGIN> has run, it is immediately undefined and any
+code it used is returned to Perl's memory pool.
+
+It should be noted that C<BEGIN> code blocks B<are> executed inside string
+C<eval()>'s.  The C<CHECK> and C<INIT> code blocks are B<not> executed inside
+a string eval, which e.g. can be a problem in a mod_perl environment.
+
+An C<END> code block is executed as late as possible, that is, after
 perl has finished running the program and just before the interpreter
 is being exited, even if it is exiting as a result of a die() function.
 (But not if it's polymorphing into another program via C<exec>, or
@@ -279,17 +290,22 @@ will execute in reverse order of definition; that is: last in, first
 out (LIFO).  C<END> blocks are not executed when you run perl with the
 C<-c> switch, or if compilation fails.
 
-Inside an C<END> subroutine, C<$?> contains the value that the program is
+Note that C<END> code blocks are B<not> executed at the end of a string
+C<eval()>: if any C<END> code blocks are created in a string C<eval()>,
+they will be executed just as any other C<END> code block of that package
+in LIFO order just before the interpreter is being exited.
+
+Inside an C<END> code block, C<$?> contains the value that the program is
 going to pass to C<exit()>.  You can modify C<$?> to change the exit
 value of the program.  Beware of changing C<$?> by accident (e.g. by
 running something via C<system>).
 
-C<CHECK> and C<INIT> blocks are useful to catch the transition between
+C<CHECK> and C<INIT> code blocks are useful to catch the transition between
 the compilation phase and the execution phase of the main program.
 
-C<CHECK> blocks are run just after the Perl compile phase ends and before
-the run time begins, in LIFO order.  C<CHECK> blocks are used in
-the Perl compiler suite to save the compiled state of the program.
+C<CHECK> code blocks are run just after the B<initial> Perl compile phase ends
+and before the run time begins, in LIFO order.  C<CHECK> code blocks are used
+in the Perl compiler suite to save the compiled state of the program.
 
 C<INIT> blocks are run just before the Perl runtime begins execution, in
 "first in, first out" (FIFO) order. For example, the code generators