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.
-
-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>).
-Similar to C<BEGIN> blocks, C<INIT> blocks are run just before the
-Perl runtime begins execution, in "first in, first out" (FIFO) order.
-For example, the code generators documented in L<perlcc> make use of
-C<INIT> blocks to initialize and resolve pointers to XSUBs.
+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> 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.
-Similar to C<END> blocks, 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 again useful 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
+documented in L<perlcc> make use of C<INIT> blocks to initialize and
+resolve pointers to XSUBs.
When you use the B<-n> and B<-p> switches to Perl, C<BEGIN> and
C<END> work just as they do in B<awk>, as a degenerate case.
switch for a compile-only syntax check, although your main code
is not.
+The B<begincheck> program makes it all clear, eventually:
+
+ #!/usr/bin/perl
+
+ # begincheck
+
+ print " 8. Ordinary code runs at runtime.\n";
+
+ END { print "14. So this is the end of the tale.\n" }
+ INIT { print " 5. INIT blocks run FIFO just before runtime.\n" }
+ CHECK { print " 4. So this is the fourth line.\n" }
+
+ print " 9. It runs in order, of course.\n";
+
+ BEGIN { print " 1. BEGIN blocks run FIFO during compilation.\n" }
+ END { print "13. Read perlmod for the rest of the story.\n" }
+ CHECK { print " 3. CHECK blocks run LIFO at compilation's end.\n" }
+ INIT { print " 6. Run this again, using Perl's -c switch.\n" }
+
+ print "10. This is anti-obfuscated code.\n";
+
+ END { print "12. END blocks run LIFO at quitting time.\n" }
+ BEGIN { print " 2. So this line comes out second.\n" }
+ INIT { print " 7. You'll see the difference right away.\n" }
+
+ print "11. It merely _looks_ like it should be confusing.\n";
+
+ __END__
+
=head2 Perl Classes
There is no special class syntax in Perl, but a package may act
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