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
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
module or by doing fork() on win32 (fake fork() support). When a
thread is cloned all Perl data is cloned, however non-Perl data cannot
be cloned automatically. Perl after 5.7.2 has support for the C<CLONE>
-special subroutine . In C<CLONE> you can do whatever you need to do,
+and C<CLONE_SKIP> special subroutines. In C<CLONE> you can do whatever
+you need to do,
like for example handle the cloning of non-Perl data, if necessary.
-C<CLONE> will be executed once for every package that has it defined
-(or inherits it). It will be called in the context of the new thread,
-so all modifications are made in the new area.
+C<CLONE> will be called once as a class method for every package that has it
+defined (or inherits it). It will be called in the context of the new thread,
+so all modifications are made in the new area. Currently CLONE is called with
+no parameters other than the invocant package name, but code should not assume
+that this will remain unchanged, as it is likely that in future extra parameters
+will be passed in to give more information about the state of cloning.
If you want to CLONE all objects you will need to keep track of them per
package. This is simply done using a hash and Scalar::Util::weaken().
+Like C<CLONE>, C<CLONE_SKIP> is called once per package; however, it is
+called just before cloning starts, and in the context of the parent
+thread. If it returns a true value, then no objects of that class will
+be cloned; or rather, they will be copied as unblessed, undef values.
+This provides a simple mechanism for making a module threadsafe; just add
+C<sub CLONE_SKIP { 1 }> at the top of the class, and C<DESTROY()> will be
+now only be called once per object. Of course, if the child thread needs
+to make use of the objects, then a more sophisticated approach is
+needed.
+
+Like C<CLONE>, C<CLONE_SKIP> is currently called with no parameters other
+than the invocant package name, although that may change. Similarly, to
+allow for future expansion, the return value should be a single C<0> or
+C<1> value.
+
=head1 SEE ALSO
See L<perlmodlib> for general style issues related to building Perl
projects / p5sagit/p5-mst-13.2.git / blobdiff