diff options
| author | Gurusamy Sarathy <gsar@cpan.org> | 2000-03-03 18:58:45 +0000 |
|---|---|---|
| committer | Gurusamy Sarathy <gsar@cpan.org> | 2000-03-03 18:58:45 +0000 |
| commit | c47ff5f1a1ef5d0daccf1724400a446cd8e93573 (patch) | |
| tree | 8a136c0e449ebac6ea6e35898b5ae06788800c41 | |
| parent | 10c8fecdc2f0a2ef9c548abff5961fa25cd83eca (diff) | |
| download | perl-c47ff5f1a1ef5d0daccf1724400a446cd8e93573.tar.gz | |
whitespace and readabiliti nits in the pods (from Michael G Schwern
and Robin Barker)
p4raw-id: //depot/perl@5493
40 files changed, 586 insertions, 332 deletions
@@ -55,7 +55,7 @@ current addresses (as of February 2000): Hugo van der Sanden <hv@crypt0.demon.co.uk> Michael G Schwern <schwern@pobox.com> Roderick Schertler <roderick@argon.org> - Kurt D. Starsinic <kstar@isinet.com> + Kurt D. Starsinic <kstar@chapin.edu> Benjamin Stuhl <sho_pi@hotmail.com> Dan Sugalski <sugalskd@osshe.edu> Nathan Torkington <gnat@frii.com> @@ -95,6 +95,261 @@ Version v5.6.0 -------------- ____________________________________________________________________________ +[ 5492] By: gsar on 2000/03/03 17:48:31 + Log: support for list assignment to pseudohashes (from John Tobey + <jtobey@john-edwin-tobey.org>) + Branch: perl + ! av.c dump.c embed.h embed.pl global.sym objXSUB.h op.c op.h + ! perlapi.c pp_hot.c proto.h t/op/avhv.t t/op/hashwarn.t +____________________________________________________________________________ +[ 5491] By: gsar on 2000/03/03 16:45:49 + Log: add MakeMaker caveat to INSTALL (from Andy Dougherty) + Branch: perl + ! INSTALL +____________________________________________________________________________ +[ 5490] By: gsar on 2000/03/03 16:44:42 + Log: perldelta tweaks + Branch: perl + ! pod/perldelta.pod +____________________________________________________________________________ +[ 5489] By: gsar on 2000/03/03 16:26:52 + Log: /dev/console may not be writable in Syslog.pm (from Ask Bjoern Hansen + <ask@valueclick.com>) + Branch: perl + ! ext/Sys/Syslog/Syslog.pm +____________________________________________________________________________ +[ 5488] By: gsar on 2000/03/03 16:21:34 + Log: OS/2 patches for dlclose() support (from Yitzchak Scott-Thoennes + <sthoenna@efn.org>) + Branch: perl + ! makedef.pl os2/diff.configure os2/dl_os2.c os2/dlfcn.h + ! os2/os2.sym +____________________________________________________________________________ +[ 5487] By: gsar on 2000/03/03 16:16:34 + Log: skip test on AFS (from Hans Ranke <Hans.Ranke@ei.tum.de>) + Branch: perl + ! t/lib/glob-basic.t +____________________________________________________________________________ +[ 5486] By: gsar on 2000/03/03 15:42:28 + Log: integrate cfgperl and vmsperl contents into mainline + Branch: perl + ! pod/perl.pod + !> (integrate 38 files) +____________________________________________________________________________ +[ 5485] By: jhi on 2000/03/03 15:21:40 + Log: pull the sparcv9 workshop libraries in front of loclibpth + Branch: cfgperl + ! hints/solaris_2.sh +____________________________________________________________________________ +[ 5484] By: jhi on 2000/03/03 15:09:03 + Log: Introduce i_ieefp because FreeBSD on ix86 needs that + for ftpsetmask(0); regen Configure. + Branch: cfgperl + ! Configure Porting/Glossary Porting/config.sh Porting/config_H + ! config_h.SH epoc/config.sh perl.h vms/subconfigure.com + ! vos/config.def vos/config.h vos/config_h.SH_orig + ! win32/config.bc win32/config.gc win32/config.vc + ! win32/config_H.bc win32/config_H.gc win32/config_H.vc +____________________________________________________________________________ +[ 5483] By: jhi on 2000/03/03 05:37:58 + Log: The _cflags must be left-aligned. + Branch: cfgperl + ! hints/irix_6.sh +____________________________________________________________________________ +[ 5482] By: bailey on 2000/03/03 04:42:45 + Log: Once more unto resync + Branch: vmsperl + !> (integrate 48 files) +____________________________________________________________________________ +[ 5481] By: bailey on 2000/03/03 04:36:46 + Log: VMS-specific perldelta update + Branch: vmsperl + ! pod/perldelta.pod +____________________________________________________________________________ +[ 5480] By: bailey on 2000/03/03 04:05:28 + Log: Set up Perl invocation method during configuration (Peter Prymmer) + Add missing bits to various utilities and install them (ditto) + Branch: vmsperl + ! configure.com pod/pod2usage.PL pod/podselect.PL + ! utils/dprofpp.PL vms/descrip_mms.template +____________________________________________________________________________ +[ 5479] By: bailey on 2000/03/03 04:01:48 + Log: Fix test to match new behavior of vmsify() (Craig Berry) + Branch: vmsperl + ! vms/ext/filespec.t +____________________________________________________________________________ +[ 5478] By: bailey on 2000/03/03 03:54:10 + Log: Try to intuit whether typeless file invoked in subprocess + is an executable image or DCL procedure. + Branch: vmsperl + ! vms/perlvms.pod vms/vms.c +____________________________________________________________________________ +[ 5477] By: bailey on 2000/03/03 03:37:18 + Log: Remove leftover bits of VAXC support (Dan Sugalski) + Branch: vmsperl + ! vms/gen_shrfls.pl +____________________________________________________________________________ +[ 5476] By: bailey on 2000/03/03 03:34:51 + Log: Add missing declaration (Dan Sugalski) + Branch: vmsperl + ! vms/vms.c +____________________________________________________________________________ +[ 5475] By: gsar on 2000/03/03 03:27:52 + Log: warn about /(?p{})/ (from Simon Cozens) + Branch: perl + ! regcomp.c toke.c +____________________________________________________________________________ +[ 5474] By: bailey on 2000/03/03 03:27:05 + Log: Ad hoc patch for duping stdout into stderr + Branch: vmsperl + ! vms/vms.c +____________________________________________________________________________ +[ 5473] By: bailey on 2000/03/03 03:23:29 + Log: Bypass PERL_INC_VERSION_LIST until we support in in Configure.Com + Branch: vmsperl + ! vms/subconfigure.com vms/vmsish.h +____________________________________________________________________________ +[ 5472] By: gsar on 2000/03/03 02:58:49 + Log: File::Spec bugs (spotted by Hack Kampbjorn <hack@hackdata.com>) + Branch: perl + ! lib/File/Spec/Mac.pm lib/File/Spec/Unix.pm + ! lib/File/Spec/VMS.pm lib/File/Spec/Win32.pm +____________________________________________________________________________ +[ 5471] By: jhi on 2000/03/03 02:38:23 + Log: more todo + Branch: cfgperl + ! Todo-5.6 +____________________________________________________________________________ +[ 5470] By: gsar on 2000/03/03 02:36:02 + Log: skip test if db doesn't have null key support + Branch: perl + ! t/lib/anydbm.t +____________________________________________________________________________ +[ 5469] By: jhi on 2000/03/03 02:26:53 + Log: Integrate with Sarathy. + Branch: cfgperl + !> INSTALL lib/AutoSplit.pm lib/ExtUtils/xsubpp lib/SelfLoader.pm + !> lib/Test/Harness.pm lib/constant.pm pod/perl.pod + !> pod/perldelta.pod pod/perlpod.pod pod/perlre.pod + !> pod/perltoc.pod regcomp.c t/op/misc.t t/op/pat.t toke.c + !> utils/h2xs.PL win32/Makefile win32/makefile.mk +____________________________________________________________________________ +[ 5468] By: jhi on 2000/03/03 02:24:05 + Log: irix hints tweak + Branch: cfgperl + ! hints/irix_6.sh +____________________________________________________________________________ +[ 5467] By: gsar on 2000/03/03 02:19:50 + Log: /(?p{})/ changed to /(??{})/, per Larry's suggestion (from + Simon Cozens <simon@othersideofthe.earth.li>) + Branch: perl + ! lib/AutoSplit.pm lib/ExtUtils/xsubpp lib/SelfLoader.pm + ! pod/perlre.pod pod/perltoc.pod regcomp.c t/op/misc.t + ! t/op/pat.t toke.c +____________________________________________________________________________ +[ 5466] By: jhi on 2000/03/03 02:12:41 + Log: in words order bad + Branch: cfgperl + ! pod/perlre.pod +____________________________________________________________________________ +[ 5465] By: jhi on 2000/03/03 02:09:45 + Log: /[[:alpha]/ now dies on unmatched [] instead of + "an unknown character class" (spotted by Tom Christiansen) + Branch: cfgperl + ! regcomp.c t/pragma/warn/regcomp +____________________________________________________________________________ +[ 5464] By: gsar on 2000/03/03 02:04:48 + Log: perldelta notes about IO::Socket changes (from Graham Barr) + Branch: perl + ! pod/perldelta.pod +____________________________________________________________________________ +[ 5463] By: gsar on 2000/03/03 02:02:50 + Log: relax restrictions on constant names a bit (from M J T Guy) + Branch: perl + ! lib/constant.pm +____________________________________________________________________________ +[ 5462] By: gsar on 2000/03/03 01:59:49 + Log: support for generation of accessor functions (from Hugo van der + Sanden) + Branch: perl + ! utils/h2xs.PL +____________________________________________________________________________ +[ 5461] By: jhi on 2000/03/03 01:51:53 + Log: cosmetics + Branch: cfgperl + ! t/op/pack.t +____________________________________________________________________________ +[ 5460] By: jhi on 2000/03/03 01:50:07 + Log: detypo + Branch: cfgperl + ! t/op/pack.t +____________________________________________________________________________ +[ 5459] By: gsar on 2000/03/03 01:46:35 + Log: pod tweaks + Branch: perl + ! pod/perl.pod pod/perlpod.pod +____________________________________________________________________________ +[ 5458] By: jhi on 2000/03/03 01:25:21 + Log: solaris hints tweak + Branch: cfgperl + ! hints/solaris_2.sh +____________________________________________________________________________ +[ 5457] By: jhi on 2000/03/02 22:56:49 + Log: detypo + Branch: cfgperl + ! hints/solaris_2.sh +____________________________________________________________________________ +[ 5456] By: gsar on 2000/03/02 21:15:11 + Log: Test::Harness uses $ENV{HARNESS_PERL_SWITCHES} when running perl; + add test targets for -C switch on windows + Branch: perl + ! lib/Test/Harness.pm win32/Makefile win32/makefile.mk +____________________________________________________________________________ +[ 5455] By: gsar on 2000/03/02 21:06:49 + Log: add note about failed tests on memory starved systems (from + Andy Dougherty) + Branch: perl + ! INSTALL +____________________________________________________________________________ +[ 5454] By: jhi on 2000/03/02 21:03:35 + Log: Integrate with Sarathy. + Branch: cfgperl + !> Changes lib/Pod/Find.pm lib/Pod/Html.pm lib/Pod/Man.pm + !> lib/Term/Cap.pm lib/Test/Harness.pm lib/blib.pm + !> pod/perldata.pod pod/perldelta.pod pod/perlop.pod +____________________________________________________________________________ +[ 5453] By: jhi on 2000/03/02 20:58:43 + Log: Further long double patches from Spider Boardman. + Branch: cfgperl + ! t/comp/use.t t/lib/bigfltpm.t t/op/pack.t t/op/universal.t +____________________________________________________________________________ +[ 5452] By: gsar on 2000/03/02 20:52:08 + Log: move doc about v-strings from perlop to perldata (suggested by + David Dyck <dcd@tc.fluke.com>) + Branch: perl + ! pod/perldata.pod pod/perldelta.pod pod/perlop.pod +____________________________________________________________________________ +[ 5451] By: gsar on 2000/03/02 20:30:29 + Log: integrate cfgperl changes into mainline + Branch: perl + !> Configure hints/irix_6.sh pp.c +____________________________________________________________________________ +[ 5450] By: gsar on 2000/03/02 20:08:10 + Log: still other multiline match cleanups (from Greg Bacon) + Branch: perl + ! Changes lib/Pod/Find.pm lib/Pod/Html.pm lib/Pod/Man.pm + ! lib/Term/Cap.pm lib/Test/Harness.pm lib/blib.pm +____________________________________________________________________________ +[ 5449] By: jhi on 2000/03/02 20:01:58 + Log: Integrate with Sarathy. + Branch: cfgperl + !> configure.com ext/File/Glob/Glob.pm ext/File/Glob/bsd_glob.c + !> lib/ExtUtils/MM_VMS.pm lib/Test/Harness.pm t/lib/glob-basic.t + !> t/pragma/warn/8signal t/pragma/warn/pp_ctl + !> vms/descrip_mms.template vms/gen_shrfls.pl + !> vms/subconfigure.com vms/vms.c win32/Makefile + !> win32/makefile.mk win32/perllib.c win32/win32.c win32/win32.h +____________________________________________________________________________ [ 5448] By: jhi on 2000/03/02 20:00:37 Log: workaround for Tru64 compiler bug (cleaner fix will have to wait until 5.6.1), from Spider Boardman diff --git a/pod/perl.pod b/pod/perl.pod index a66e2c812a..7e940adae0 100644 --- a/pod/perl.pod +++ b/pod/perl.pod @@ -246,12 +246,12 @@ http://www.perl.com/CPAN/src/index.html 2) formerly known as MVS 3) formerly known as Digital UNIX and before that DEC OSF/1 4) compilers: Borland, Cygwin, Mingw32 EGCS/GCC, VC++ - + The following platforms have been known to build Perl from source, but we haven't been able to verify their status for the current release, either because the hardware/software platforms are rare or because we don't have an active champion on these platforms--or both. - + 3b1 FPS Plan 9 AmigaOS GENIX PowerUX ConvexOS Greenhills RISC/os diff --git a/pod/perl5004delta.pod b/pod/perl5004delta.pod index 43bfb51c66..85a8f96161 100644 --- a/pod/perl5004delta.pod +++ b/pod/perl5004delta.pod @@ -79,7 +79,7 @@ your scripts. Before Perl 5.004, C<AUTOLOAD> functions were looked up as methods (using the C<@ISA> hierarchy), even when the function to be autoloaded was called as a plain function (e.g. C<Foo::bar()>), not a method -(e.g. C<Foo-E<gt>bar()> or C<$obj-E<gt>bar()>). +(e.g. C<< Foo->bar() >> or C<< $obj->bar() >>). Perl 5.005 will use method lookup only for methods' C<AUTOLOAD>s. However, there is a significant base of existing code that may be using @@ -266,11 +266,11 @@ A subroutine reference may now be suffixed with an arrow and a (possibly empty) parameter list. This syntax denotes a call of the referenced subroutine, with the given parameters (if any). -This new syntax follows the pattern of S<C<$hashref-E<gt>{FOO}>> and -S<C<$aryref-E<gt>[$foo]>>: You may now write S<C<&$subref($foo)>> as -S<C<$subref-E<gt>($foo)>>. All these arrow terms may be chained; -thus, S<C<&{$table-E<gt>{FOO}}($bar)>> may now be written -S<C<$table-E<gt>{FOO}-E<gt>($bar)>>. +This new syntax follows the pattern of S<C<< $hashref->{FOO} >>> and +S<C<< $aryref->[$foo] >>>: You may now write S<C<&$subref($foo)>> as +S<C<< $subref->($foo) >>>. All these arrow terms may be chained; +thus, S<C<< &{$table->{FOO}}($bar) >>> may now be written +S<C<< $table->{FOO}->($bar) >>>. =back @@ -1290,7 +1290,7 @@ likely to eliminate these arbitrary limitations. (F) A carriage return character was found in the input. This is an error, and not a warning, because carriage return characters can break -multi-line strings, including here documents (e.g., C<print E<lt>E<lt>EOF;>). +multi-line strings, including here documents (e.g., C<print <<EOF;>). =item Illegal switch in PERL5OPT: %s @@ -1312,7 +1312,7 @@ architecture. On a 32-bit architecture the largest octal literal is =item internal error: glob failed (P) Something went wrong with the external program(s) used for C<glob> -and C<E<lt>*.cE<gt>>. This may mean that your csh (C shell) is +and C<< <*.c> >>. This may mean that your csh (C shell) is broken. If so, you should change all of the csh-related variables in config.sh: If you have tcsh, make the variables refer to it as if it were csh (e.g. C<full_csh='/usr/bin/tcsh'>); otherwise, make them all diff --git a/pod/perl5005delta.pod b/pod/perl5005delta.pod index ca9f185bc5..b133c0dd81 100644 --- a/pod/perl5005delta.pod +++ b/pod/perl5005delta.pod @@ -482,10 +482,10 @@ magic lvalue too. For instance, this code now acts differently: In previous versions, this would print "hello", but it now prints "g'bye". -=head2 E<lt>E<gt> now reads in records +=head2 <> now reads in records If C<$/> is a reference to an integer, or a scalar that holds an integer, -E<lt>E<gt> will read in records instead of lines. For more info, see +<> will read in records instead of lines. For more info, see L<perlvar/$/>. =head1 Supported Platforms @@ -759,10 +759,10 @@ only with arrays that have a hash reference at index 0. =item Can't localize pseudo-hash element -(F) You said something like C<local $ar-E<gt>{'key'}>, where $ar is +(F) You said something like C<< local $ar->{'key'} >>, where $ar is a reference to a pseudo-hash. That hasn't been implemented yet, but you can get a similar effect by localizing the corresponding array -element directly -- C<local $ar-E<gt>[$ar-E<gt>[0]{'key'}]>. +element directly -- C<< local $ar->[$ar->[0]{'key'}] >>. =item Can't use %%! because Errno.pm is not available diff --git a/pod/perlboot.pod b/pod/perlboot.pod index dbf4fc998c..bab365609e 100644 --- a/pod/perlboot.pod +++ b/pod/perlboot.pod @@ -67,7 +67,7 @@ Or is it? =head2 Introducing the method invocation arrow -For now, let's say that C<Class-E<gt>method> invokes subroutine +For now, let's say that C<< Class->method >> invokes subroutine C<method> in package C<Class>. (Here, "Class" is used in its "category" meaning, not its "scholastic" meaning.) That's not completely accurate, but we'll do this one step at a time. Now let's @@ -176,8 +176,8 @@ This method provides the constant text for the sound itself. } } -Now, when we call C<Cow-E<gt>speak>, we get a C<$class> of C<Cow> in -C<speak>. This in turn selects the C<Cow-E<gt>sound> method, which +Now, when we call C<< Cow->speak >>, we get a C<$class> of C<Cow> in +C<speak>. This in turn selects the C<< Cow->sound >> method, which returns C<moooo>. But how different would this be for the C<Horse>? { package Horse; @@ -214,7 +214,7 @@ with the animal-specific sound: Note the added C<@ISA> array. We'll get to that in a minute. -But what happens when we invoke C<Cow-E<gt>speak> now? +But what happens when we invoke C<< Cow->speak >> now? First, Perl constructs the argument list. In this case, it's just C<Cow>. Then Perl looks for C<Cow::speak>. But that's not there, so @@ -227,7 +227,7 @@ with the already frozen argument list. Inside the C<Animal::speak> subroutine, C<$class> becomes C<Cow> (the first argument). So when we get to the step of invoking -C<$class-E<gt>sound>, it'll be looking for C<Cow-E<gt>sound>, which +C<< $class->sound >>, it'll be looking for C<< Cow->sound >>, which gets it on the first try without looking at C<@ISA>. Success! =head2 A few notes about @ISA @@ -295,13 +295,13 @@ which results in: a Mouse goes squeak! [but you can barely hear it!] -Here, C<Mouse> has its own speaking routine, so C<Mouse-E<gt>speak> -doesn't immediately invoke C<Animal-E<gt>speak>. This is known as +Here, C<Mouse> has its own speaking routine, so C<< Mouse->speak >> +doesn't immediately invoke C<< Animal->speak >>. This is known as "overriding". In fact, we didn't even need to say that a C<Mouse> was an C<Animal> at all, since all of the methods needed for C<speak> are completely defined with C<Mouse>. -But we've now duplicated some of the code from C<Animal-E<gt>speak>, +But we've now duplicated some of the code from C<< Animal->speak >>, and this can once again be a maintenance headache. So, can we avoid that? Can we say somehow that a C<Mouse> does everything any other C<Animal> does, but add in the extra comment? Sure! @@ -322,7 +322,7 @@ First, we can invoke the C<Animal::speak> method directly: Note that we have to include the C<$class> parameter (almost surely the value of C<"Mouse">) as the first parameter to C<Animal::speak>, since we've stopped using the method arrow. Why did we stop? Well, -if we invoke C<Animal-E<gt>speak> there, the first parameter to the +if we invoke C<< Animal->speak >> there, the first parameter to the method will be C<"Animal"> not C<"Mouse">, and when time comes for it to call for the C<sound>, it won't have the right class to come back to this package. @@ -429,7 +429,7 @@ and the C<Horse> class: sub sound { "neigh" } } -This lets us invoke C<Horse-E<gt>speak> to ripple upward to +This lets us invoke C<< Horse->speak >> to ripple upward to C<Animal::speak>, calling back to C<Horse::sound> to get the specific sound, and the output of: @@ -506,7 +506,7 @@ the name: $$self; } } - + Now we call for the name: print $talking->name, " says ", $talking->sound, "\n"; @@ -695,8 +695,8 @@ Let's make a sheep that has a name and a color: my $bad = bless { Name => "Evil", Color => "black" }, Sheep; -so C<$bad-E<gt>{Name}> has C<Evil>, and C<$bad-E<gt>{Color}> has -C<black>. But we want to make C<$bad-E<gt>name> access the name, and +so C<< $bad->{Name} >> has C<Evil>, and C<< $bad->{Color} >> has +C<black>. But we want to make C<< $bad->name >> access the name, and that's now messed up because it's expecting a scalar reference. Not to worry, because that's pretty easy to fix up: diff --git a/pod/perldata.pod b/pod/perldata.pod index 4dbc76564e..e3361e4dad 100644 --- a/pod/perldata.pod +++ b/pod/perldata.pod @@ -109,14 +109,14 @@ list context to each of its arguments. For example, if you say int( <STDIN> ) -the integer operation provides scalar context for the E<lt><gt> +the integer operation provides scalar context for the <> operator, which responds by reading one line from STDIN and passing it back to the integer operation, which will then find the integer value of that line and return that. If, on the other hand, you say sort( <STDIN> ) -then the sort operation provides list context for E<lt><gt>, which +then the sort operation provides list context for <>, which will proceed to read every line available up to the end of file, and pass that list of lines back to the sort routine, which will then sort those lines and return them as a list to whatever the context @@ -398,13 +398,13 @@ plain paranoid, you can force the correct interpretation with curly braces as above. A line-oriented form of quoting is based on the shell "here-document" -syntax. Following a C<E<lt>E<lt>> you specify a string to terminate +syntax. Following a C<< << >> you specify a string to terminate the quoted material, and all lines following the current line down to the terminating string are the value of the item. The terminating string may be either an identifier (a word), or some quoted text. If quoted, the type of quotes you use determines the treatment of the text, just as in regular quoting. An unquoted identifier works like -double quotes. There must be no space between the C<E<lt>E<lt>> and +double quotes. There must be no space between the C<< << >> and the identifier. (If you put a space it will be treated as a null identifier, which is valid, and matches the first empty line.) The terminating string must appear by itself (unquoted and with no @@ -576,8 +576,8 @@ hash. Likewise, hashes included as parts of other lists (including parameters lists and return lists from functions) always flatten out into key/value pairs. That's why it's good to use references sometimes. -It is often more readable to use the C<=E<gt>> operator between key/value -pairs. The C<=E<gt>> operator is mostly just a more visually distinctive +It is often more readable to use the C<< => >> operator between key/value +pairs. The C<< => >> operator is mostly just a more visually distinctive synonym for a comma, but it also arranges for its left-hand operand to be interpreted as a string--if it's a bareword that would be a legal identifier. This makes it nice for initializing hashes: diff --git a/pod/perldebug.pod b/pod/perldebug.pod index 841ad752f3..f89e67fbfb 100644 --- a/pod/perldebug.pod +++ b/pod/perldebug.pod @@ -126,7 +126,7 @@ of the next statement. If an expression is supplied that includes function calls, those functions will be executed with stops before each statement. -=item E<lt>CRE<gt> +=item <CR> Repeat last C<n> or C<s> command. @@ -145,7 +145,7 @@ List C<incr+1> lines starting at C<min>. =item l min-max -List lines C<min> through C<max>. C<l E<45>> is synonymous to C<E<45>>. +List lines C<min> through C<max>. C<l -> is synonymous to C<->. =item l line @@ -506,25 +506,25 @@ corresponds to F</dev/ttyc>, say, by issuing a command like See L<"Debugger Internals"> below for more details. -=item E<lt> [ command ] +=item < [ command ] Set an action (Perl command) to happen before every debugger prompt. A multi-line command may be entered by backslashing the newlines. If C<command> is missing, resets the list of actions. -=item E<lt>E<lt> command +=item << command Add an action (Perl command) to happen before every debugger prompt. A multi-line command may be entered by backslashing the newlines. -=item E<gt> command +=item > command Set an action (Perl command) to happen after the prompt when you've just given a command to return to executing the script. A multi-line command may be entered by backslashing the newlines. If C<command> is missing, resets the list of actions. -=item E<gt>E<gt> command +=item >> command Adds an action (Perl command) to happen after the prompt when you've just given a command to return to executing the script. A multi-line @@ -701,7 +701,7 @@ Listing given via different flavors of C<l> command looks like this: Note that the breakable lines are marked with C<:>, lines with breakpoints are marked by C<b>, with actions by C<a>, and the -next executed line is marked by C<==E<gt>>. +next executed line is marked by C<< ==> >>. =item Frame listing @@ -979,14 +979,14 @@ application. =item * -The array C<@{"_E<lt>$filename"}> is the line-by-line contents of +The array C<@{"_<$filename"}> is the line-by-line contents of $filename for all the compiled files. Same for C<eval>ed strings which contain subroutines, or which are currently executed. The $filename for C<eval>ed strings looks like C<(eval 34)>. =item * -The hash C<%{"_E<lt>$filename"}> contains breakpoints and action (it is +The hash C<%{"_<$filename"}> contains breakpoints and action (it is keyed by line number), and individual entries are settable (as opposed to the whole hash). Only true/false is important to Perl, though the values used by F<perl5db.pl> have the form @@ -999,7 +999,7 @@ C<(eval 34)>. =item * -The scalar C<${"_E<lt>$filename"}> contains C<"_E<lt>$filename">. Same for +The scalar C<${"_<$filename"}> contains C<"_<$filename">. Same for evaluated strings which contain subroutines, or which are currently executed. The $filename for C<eval>ed strings looks like C<(eval 34)>. @@ -1007,7 +1007,7 @@ executed. The $filename for C<eval>ed strings looks like C<(eval =item * After each C<require>d file is compiled, but before it is executed, -C<DB::postponed(*{"_E<lt>$filename"})> is called (if subroutine +C<DB::postponed(*{"_<$filename"})> is called (if subroutine C<DB::postponed> exists). Here the $filename is the expanded name of the C<require>d file (as found in values of %INC). @@ -1031,7 +1031,7 @@ a breakpoint, a call to C<DB::DB()> is performed if any one of variables $DB::trace, $DB::single, or $DB::signal is true. (Note that these variables are not C<local>izable.) This feature is disabled when the control is inside C<DB::DB()> or functions called from it (unless -C<$^D & (1E<lt>E<lt>30)>). +C<$^D & (1<<30)>). =item * @@ -1104,7 +1104,7 @@ C<line>. The function C<DB::print_trace(FH, skip[, count[, short]])> prints formatted info about caller frames. The last two functions may be -convenient as arguments to C<E<lt>>, C<E<lt>E<lt>> commands. +convenient as arguments to C<< < >>, C<< << >> commands. =head2 Other resources diff --git a/pod/perldelta.pod b/pod/perldelta.pod index 6f24ddb291..2a29f8aded 100644 --- a/pod/perldelta.pod +++ b/pod/perldelta.pod @@ -590,10 +590,10 @@ C<oct()>: Perl now allows the arrow to be omitted in many constructs involving subroutine calls through references. For example, -C<$foo[10]-E<gt>('foo')> may now be written C<$foo[10]('foo')>. +C<< $foo[10]->('foo') >> may now be written C<$foo[10]('foo')>. This is rather similar to how the arrow may be omitted from -C<$foo[10]-E<gt>{'foo'}>. Note however, that the arrow is still -required for C<foo(10)-E<gt>('bar')>. +C<< $foo[10]->{'foo'} >>. Note however, that the arrow is still +required for C<< foo(10)->('bar') >>. =head2 exists() is supported on subroutine names @@ -627,7 +627,7 @@ The length argument of C<syswrite()> has become optional. =head2 File and directory handles can be autovivified -Similar to how constructs such as C<$x-E<gt>[0]> autovivify a reference, +Similar to how constructs such as C<< $x->[0] >> autovivify a reference, handle constructors (open(), opendir(), pipe(), socketpair(), sysopen(), socket(), and accept()) now autovivify a file or directory handle if the handle passed to them is an uninitialized scalar variable. This @@ -943,7 +943,7 @@ See F<INSTALL> and F<README.Y2K>. =head1 Significant bug fixes -=head2 E<lt>HANDLEE<gt> on empty files +=head2 <HANDLE> on empty files With C<$/> set to C<undef>, "slurping" an empty file returns a string of zero length (instead of C<undef>, as it used to) the first time the @@ -1001,14 +1001,14 @@ handles I/O. =head2 Better diagnostics on meaningless filehandle operations -Constructs such as C<open(E<lt>FHE<gt>)> and C<close(E<lt>FHE<gt>)> +Constructs such as C<< open(<FH>) >> and C<< close(<FH>) >> are compile time errors. Attempting to read from filehandles that were opened only for writing will now produce warnings (just as writing to read-only filehandles does). =head2 Where possible, buffered data discarded from duped input filehandle -C<open(NEW, "E<lt>&OLD")> now attempts to discard any data that +C<< open(NEW, "<&OLD") >> now attempts to discard any data that was previously read and buffered in C<OLD> before duping the handle. On platforms where doing this is allowed, the next read operation on C<NEW> will return the same data as the corresponding operation @@ -1017,9 +1017,9 @@ of the following disk block instead. =head2 eof() has the same old magic as <> -C<eof()> would return true if no attempt to read from C<E<lt>E<gt>> had +C<eof()> would return true if no attempt to read from C<< <> >> had yet been made. C<eof()> has been changed to have a little magic of its -own, it now opens the C<E<lt>E<gt>> files. +own, it now opens the C<< <> >> files. =head2 system(), backticks and pipe open now reflect exec() failure @@ -1046,7 +1046,7 @@ array element in that slot. =head2 Pseudo-hashes work better Dereferencing some types of reference values in a pseudo-hash, -such as C<$ph-E<gt>{foo}[1]>, was accidentally disallowed. This has +such as C<< $ph->{foo}[1] >>, was accidentally disallowed. This has been corrected. When applied to a pseudo-hash element, exists() now reports whether @@ -1645,12 +1645,11 @@ messages. For example: See L<Pod::Usage> for details. -A bug that prevented the non-option call-back E<lt>E<gt> from being +A bug that prevented the non-option call-back <> from being specified as the first argument has been fixed. -To specify the characters E<lt> and E<gt> as option starters, use -E<gt>E<lt>. Note, however, that changing option starters is strongly -deprecated. +To specify the characters < and > as option starters, use ><. Note, +however, that changing option starters is strongly deprecated. =item IO @@ -1685,7 +1684,7 @@ C<no lib> removes all named entries. =item Math::BigInt -The bitwise operations C<E<lt>E<lt>>, C<E<gt>E<gt>>, C<&>, C<|>, +The bitwise operations C<<< << >>>, C<<< >> >>>, C<&>, C<|>, and C<~> are now supported on bigints. =item Math::Complex @@ -1733,7 +1732,7 @@ translators. L<Pod::Find|Pod::Find> traverses directory structures and returns found pod files, along with their canonical names (like C<File::Spec::Unix>). L<Pod::ParseUtils|Pod::ParseUtils> contains B<Pod::List> (useful for storing pod list information), B<Pod::Hyperlink> -(for parsing the contents of C<LE<gt>E<lt>> sequences) and B<Pod::Cache> +(for parsing the contents of C<LE<lt>E<gt>> sequences) and B<Pod::Cache> (for caching information about pod files, e.g. link nodes). =item Pod::Select, podselect @@ -2038,7 +2037,7 @@ could also result in this warning. See L<perlcall/G_KEEPERR>. =item <> should be quotes -(F) You wrote C<require E<lt>fileE<gt>> when you should have written +(F) You wrote C<< require <file> >> when you should have written C<require 'file'>. =item Attempt to join self @@ -2216,8 +2215,8 @@ See L<perlre>. (W) You tried to read from a filehandle opened only for writing. If you intended it to be a read/write filehandle, you needed to open it with -"+E<lt>" or "+E<gt>" or "+E<gt>E<gt>" instead of with "E<lt>" or nothing. If -you intended only to read from the file, use "E<lt>". See +"+<" or "+>" or "+>>" instead of with "<" or nothing. If +you intended only to read from the file, use "<". See L<perlfunc/open>. =item flock() on closed filehandle %s @@ -2455,8 +2454,8 @@ L<perlvms>) so that the environ array isn't the target of the change to =item Unknown open() mode '%s' (F) The second argument of 3-argument open() is not among the list -of valid modes: C<E<lt>>, C<E<gt>>, C<E<gt>E<gt>>, C<+E<lt>>, -C<+E<gt>>, C<+E<gt>E<gt>>, C<-|>, C<|E<45>>. +of valid modes: C<< < >>, C<< > >>, C<<< >> >>>, C<< +< >>, +C<< +> >>, C<<< +>> >>>, C<-|>, C<|->. =item Unknown process %x sent message to prime_env_iter: %s diff --git a/pod/perldiag.pod b/pod/perldiag.pod index f95c7d5920..23c376b0b0 100644 --- a/pod/perldiag.pod +++ b/pod/perldiag.pod @@ -298,7 +298,7 @@ the string being unpacked. See L<perlfunc/pack>. =item <> should be quotes -(F) You wrote C<require E<lt>fileE<gt>> when you should have written +(F) You wrote C<< require <file> >> when you should have written C<require 'file'>. =item accept() on closed socket %s @@ -771,7 +771,7 @@ your sysadmin why he and/or she removed it. (F) This machine doesn't have either waitpid() or wait4(), so only waitpid() without flags is emulated. -=item Can't do {n,m} with n E<gt> m +=item Can't do {n,m} with n > m (F) Minima must be less than or equal to maxima. If you really want your regexp to match something 0 times, just put {0}. See L<perlre>. @@ -897,10 +897,10 @@ package name. =item Can't localize pseudo-hash element -(F) You said something like C<local $ar-E<gt>{'key'}>, where $ar is +(F) You said something like C<< local $ar->{'key'} >>, where $ar is a reference to a pseudo-hash. That hasn't been implemented yet, but you can get a similar effect by localizing the corresponding array -element directly -- C<local $ar-E<gt>[$ar-E<gt>[0]{'key'}]>. +element directly -- C<< local $ar->[$ar->[0]{'key'}] >>. =item Can't locate auto/%s.al in @INC @@ -956,7 +956,7 @@ buffer. =item Can't open %s: %s -(S inplace) The implicit opening of a file through use of the C<E<lt>E<gt>> +(S inplace) The implicit opening of a file through use of the C<< <> >> filehandle, either implicitly under the C<-n> or C<-p> command-line switches, or explicitly, failed for the indicated reason. Usually this is because you don't have read permission for a file which you named @@ -966,24 +966,24 @@ on the command line. (W pipe) You tried to say C<open(CMD, "|cmd|")>, which is not supported. You can try any of several modules in the Perl library to do this, such as -IPC::Open2. Alternately, direct the pipe's output to a file using "E<gt>", +IPC::Open2. Alternately, direct the pipe's output to a file using ">", and then read it in under a different file handle. =item Can't open error file %s as stderr (F) An error peculiar to VMS. Perl does its own command line redirection, and -couldn't open the file specified after '2E<gt>' or '2E<gt>E<gt>' on the +couldn't open the file specified after '2>' or '2>>' on the command line for writing. =item Can't open input file %s as stdin (F) An error peculiar to VMS. Perl does its own command line redirection, and -couldn't open the file specified after 'E<lt>' on the command line for reading. +couldn't open the file specified after '<' on the command line for reading. =item Can't open output file %s as stdout (F) An error peculiar to VMS. Perl does its own command line redirection, and -couldn't open the file specified after 'E<gt>' or 'E<gt>E<gt>' on the command +couldn't open the file specified after '>' or '>>' on the command line for writing. =item Can't open output pipe (name: %s) @@ -1090,7 +1090,7 @@ provide symbolic names for C<$!> errno values. =item Can't use "my %s" in sort comparison (F) The global variables $a and $b are reserved for sort comparisons. -You mentioned $a or $b in the same line as the E<lt>=E<gt> or cmp operator, +You mentioned $a or $b in the same line as the <=> or cmp operator, and the variable had earlier been declared as a lexical variable. Either qualify the sort variable with the package name, or rename the lexical variable. @@ -1208,7 +1208,7 @@ backslash: "\[=" and "=\]". not realizing that 777 will be interpreted as a decimal number, equivalent to 01411. Octal constants are introduced with a leading 0 in Perl, as in C. -=item Close on unopened file E<lt>%sE<gt> +=item Close on unopened file <%s> (W unopened) You tried to close a filehandle that was never opened. @@ -1304,7 +1304,7 @@ just use C<if (%hash) { # not empty }> for example. =item Delimiter for here document is too long -(F) In a here document construct like C<E<lt>E<lt>FOO>, the label +(F) In a here document construct like C<<<FOO>, the label C<FOO> is too long for Perl to handle. You have to be seriously twisted to write code that triggers this error. @@ -1480,16 +1480,16 @@ the FileHandle package. (W io) You tried to write on a read-only filehandle. If you intended it to be a read-write filehandle, you needed to open it with -"+E<lt>" or "+E<gt>" or "+E<gt>E<gt>" instead of with "E<lt>" or nothing. If -you intended only to write the file, use "E<gt>" or "E<gt>E<gt>". See +"+<" or "+>" or "+>>" instead of with "<" or nothing. If +you intended only to write the file, use ">" or ">>". See L<perlfunc/open>. =item Filehandle %s opened only for output (W io) You tried to read from a filehandle opened only for writing. If you intended it to be a read/write filehandle, you needed to open it with -"+E<lt>" or "+E<gt>" or "+E<gt>E<gt>" instead of with "E<lt>" or nothing. If -you intended only to read from the file, use "E<lt>". See +"+<" or "+>" or "+>>" instead of with "<" or nothing. If +you intended only to read from the file, use "<". See L<perlfunc/open>. =item Final $ should be \$ or $name @@ -1561,7 +1561,7 @@ C<getpwnam> operator returned an invalid UIC. =item glob failed (%s) (W glob) Something went wrong with the external program(s) used for C<glob> -and C<E<lt>*.cE<gt>>. Usually, this means that you supplied a C<glob> +and C<< <*.c> >>. Usually, this means that you supplied a C<glob> pattern that caused the external program to fail and exit with a nonzero status. If the message indicates that the abnormal exit resulted in a coredump, this may also mean that your csh (C shell) is broken. If so, @@ -2003,28 +2003,28 @@ but for some reason the perl5db.pl file (or some facsimile thereof) didn't define a DB::sub routine to be called at the beginning of each ordinary subroutine call. -=item No error file after 2E<gt> or 2E<gt>E<gt> on command line +=item No error file after 2> or 2>> on command line (F) An error peculiar to VMS. Perl handles its own command line redirection, -and found a '2E<gt>' or a '2E<gt>E<gt>' on the command line, but can't find +and found a '2>' or a '2>>' on the command line, but can't find the name of the file to which to write data destined for stderr. -=item No input file after E<lt> on command line +=item No input file after < on command line (F) An error peculiar to VMS. Perl handles its own command line redirection, -and found a 'E<lt>' on the command line, but can't find the name of the file +and found a '<' on the command line, but can't find the name of the file from which to read data for stdin. -=item No output file after E<gt> on command line +=item No output file after > on command line (F) An error peculiar to VMS. Perl handles its own command line redirection, -and found a lone 'E<gt>' at the end of the command line, so it doesn't know +and found a lone '>' at the end of the command line, so it doesn't know where you wanted to redirect stdout. -=item No output file after E<gt> or E<gt>E<gt> on command line +=item No output file after > or >> on command line (F) An error peculiar to VMS. Perl handles its own command line redirection, -and found a 'E<gt>' or a 'E<gt>E<gt>' on the command line, but can't find the +and found a '>' or a '>>' on the command line, but can't find the name of the file to which to write data destined for stdout. =item No package name allowed for variable %s in "our" @@ -2766,7 +2766,7 @@ think so. =item seteuid() not implemented -(F) You tried to assign to C<$E<gt>>, and your operating system doesn't support +(F) You tried to assign to C<< $> >>, and your operating system doesn't support the seteuid() system call (or equivalent), or at least Configure didn't think so. @@ -2783,7 +2783,7 @@ think so. =item setruid() not implemented -(F) You tried to assign to C<$E<lt>>, and your operating system doesn't support +(F) You tried to assign to C<$<>, and your operating system doesn't support the setruid() system call (or equivalent), or at least Configure didn't think so. @@ -2813,7 +2813,7 @@ But before sort was a keyword, people sometimes used it as a filehandle. =item Sort subroutine didn't return a numeric value (F) A sort comparison routine must return a number. You probably blew -it by not using C<E<lt>=E<gt>> or C<cmp>, or by not using them correctly. +it by not using C<< <=> >> or C<cmp>, or by not using them correctly. See L<perlfunc/sort>. =item Sort subroutine didn't return single value @@ -2827,7 +2827,7 @@ or less than one element. See L<perlfunc/sort>. more times than there are characters of input, which is what happened.) See L<perlfunc/split>. -=item Stat on unopened file E<lt>%sE<gt> +=item Stat on unopened file <%s> (W unopened) You tried to use the stat() function (or an equivalent file test) on a filehandle that was either never opened or has since been closed. @@ -2949,7 +2949,7 @@ nested for Perl to reach. Perl is doing you a favor by refusing. (W unopened) You tried to use the tell() function on a filehandle that was either never opened or has since been closed. -=item Test on unopened file E<lt>%sE<gt> +=item Test on unopened file <%s> (W unopened) You tried to invoke a file test operator on a filehandle that isn't open. Check your logic. See also L<perlfunc/-X>. @@ -3156,8 +3156,8 @@ representative, who probably put it there in the first place. =item Unknown open() mode '%s' (F) The second argument of 3-argument open() is not among the list -of valid modes: C<E<lt>>, C<E<gt>>, C<E<gt>E<gt>>, C<+E<lt>>, -C<+E<gt>>, C<+E<gt>E<gt>>, C<-|>, C<|E<45>>. +of valid modes: C<< < >>, C<< > >>, C<<< >> >>>, C<< +< >>, +C<< +> >>, C<<< +>> >>>, C<-|>, C<|->. =item Unknown process %x sent message to prime_env_iter: %s @@ -3241,7 +3241,7 @@ At least, Configure doesn't think so. (F) Your machine doesn't support the Berkeley socket mechanism, or at least that's what Configure thought. -=item Unterminated E<lt>E<gt> operator +=item Unterminated <> operator (F) The lexer saw a left angle bracket in a place where it was expecting a term, so it's looking for the corresponding right angle bracket, and not @@ -3279,7 +3279,7 @@ action-at-a-distance effects of C<$*>. (F) You attempted to use a feature of printf that is accessible from only C. This usually means there's a better way to do it in Perl. -=item Use of bare E<lt>E<lt> to mean E<lt>E<lt>"" is deprecated +=item Use of bare << to mean <<"" is deprecated (D deprecated) You are now encouraged to use the explicitly quoted form if you wish to use an empty line as the terminator of the here-document. @@ -3292,10 +3292,10 @@ a split() explicitly to an array (or list). =item Use of inherited AUTOLOAD for non-method %s() is deprecated -(D deprecated) As an (ahem) accidental feature, C<AUTOLOAD> subroutines are looked -up as methods (using the C<@ISA> hierarchy) even when the subroutines to -be autoloaded were called as plain functions (e.g. C<Foo::bar()>), not -as methods (e.g. C<Foo-E<gt>bar()> or C<$obj-E<gt>bar()>). +(D deprecated) As an (ahem) accidental feature, C<AUTOLOAD> subroutines are +looked up as methods (using the C<@ISA> hierarchy) even when the subroutines +to be autoloaded were called as plain functions (e.g. C<Foo::bar()>), +not as methods (e.g. C<< Foo->bar() >> or C<< $obj->bar() >>). This bug will be rectified in Perl 5.005, which will use method lookup only for methods' C<AUTOLOAD>s. However, there is a significant base @@ -3559,13 +3559,13 @@ substitution, but stylistically it's better to use the variable form because other Perl programmers will expect it, and it works better if there are more than 9 backreferences. -=item '|' and 'E<lt>' may not both be specified on command line +=item '|' and '<' may not both be specified on command line (F) An error peculiar to VMS. Perl does its own command line redirection, and found that STDIN was a pipe, and that you also tried to redirect STDIN using -'E<lt>'. Only one STDIN stream to a customer, please. +'<'. Only one STDIN stream to a customer, please. -=item '|' and 'E<gt>' may not both be specified on command line +=item '|' and '>' may not both be specified on command line (F) An error peculiar to VMS. Perl does its own command line redirection, and thinks you tried to redirect stdout both to a file and into a pipe to another diff --git a/pod/perlembed.pod b/pod/perlembed.pod index b46c463f7f..c4df676b19 100644 --- a/pod/perlembed.pod +++ b/pod/perlembed.pod @@ -280,32 +280,32 @@ the first, a C<float> from the second, and a C<char *> from the third. #include <EXTERN.h> #include <perl.h> - + static PerlInterpreter *my_perl; - + main (int argc, char **argv, char **env) { STRLEN n_a; char *embedding[] = { "", "-e", "0" }; - + my_perl = perl_alloc(); perl_construct( my_perl ); - + perl_parse(my_perl, NULL, 3, embedding, NULL); perl_run(my_perl); - + /** Treat $a as an integer **/ eval_pv("$a = 3; $a **= 2", TRUE); printf("a = %d\n", SvIV(get_sv("a", FALSE))); - + /** Treat $a as a float **/ eval_pv("$a = 3.14; $a **= 2", TRUE); printf("a = %f\n", SvNV(get_sv("a", FALSE))); - + /** Treat $a as a string **/ eval_pv("$a = 'rekcaH lreP rehtonA tsuJ'; $a = reverse($a);", TRUE); printf("a = %s\n", SvPV(get_sv("a", FALSE), n_a)); - + perl_destruct(my_perl); perl_free(my_perl); } @@ -364,7 +364,7 @@ been wrapped here): #include <EXTERN.h> #include <perl.h> - + /** my_eval_sv(code, error_check) ** kinda like eval_sv(), ** but we pop the return value off the stack @@ -374,41 +374,41 @@ been wrapped here): dSP; SV* retval; STRLEN n_a; - + PUSHMARK(SP); eval_sv(sv, G_SCALAR); - + SPAGAIN; retval = POPs; PUTBACK; - + if (croak_on_error && SvTRUE(ERRSV)) croak(SvPVx(ERRSV, n_a)); - + return retval; } - + /** match(string, pattern) ** ** Used for matches in a scalar context. ** ** Returns 1 if the match was successful; 0 otherwise. **/ - + I32 match(SV *string, char *pattern) { SV *command = NEWSV(1099, 0), *retval; STRLEN n_a; - + sv_setpvf(command, "my $string = '%s'; $string =~ %s", SvPV(string,n_a), pattern); - + retval = my_eval_sv(command, TRUE); SvREFCNT_dec(command); - + return SvIV(retval); } - + /** substitute(string, pattern) ** ** Used for =~ operations that modify their left-hand side (s/// and tr///) @@ -416,22 +416,22 @@ been wrapped here): ** Returns the number of successful matches, and ** modifies the input string if there were any. **/ - + I32 substitute(SV **string, char *pattern) { SV *command = NEWSV(1099, 0), *retval; STRLEN n_a; - + sv_setpvf(command, "$string = '%s'; ($string =~ %s)", SvPV(*string,n_a), pattern); - + retval = my_eval_sv(command, TRUE); SvREFCNT_dec(command); - + *string = get_sv("string", FALSE); return SvIV(retval); } - + /** matches(string, pattern, matches) ** ** Used for matches in an array context. @@ -439,25 +439,25 @@ been wrapped here): ** Returns the number of matches, ** and fills in **matches with the matching substrings **/ - + I32 matches(SV *string, char *pattern, AV **match_list) { SV *command = NEWSV(1099, 0); I32 num_matches; STRLEN n_a; - + sv_setpvf(command, "my $string = '%s'; @array = ($string =~ %s)", SvPV(string,n_a), pattern); - + my_eval_sv(command, TRUE); SvREFCNT_dec(command); - + *match_list = get_av("array", FALSE); num_matches = av_len(*match_list) + 1; /** assume $[ is 0 **/ - + return num_matches; } - + main (int argc, char **argv, char **env) { PerlInterpreter *my_perl = perl_alloc(); @@ -466,30 +466,30 @@ been wrapped here): I32 num_matches, i; SV *text = NEWSV(1099,0); STRLEN n_a; - + perl_construct(my_perl); perl_parse(my_perl, NULL, 3, embedding, NULL); - + sv_setpv(text, "When he is at a convenience store and the bill comes to some amount like 76 cents, Maynard is aware that there is something he *should* do, something that will enable him to get back a quarter, but he has no idea *what*. He fumbles through his red squeezey changepurse and gives the boy three extra pennies with his dollar, hoping that he might luck into the correct amount. The boy gives him back two of his own pennies and then the big shiny quarter that is his prize. -RICHH"); - + if (match(text, "m/quarter/")) /** Does text contain 'quarter'? **/ printf("match: Text contains the word 'quarter'.\n\n"); else printf("match: Text doesn't contain the word 'quarter'.\n\n"); - + if (match(text, "m/eighth/")) /** Does text contain 'eighth'? **/ printf("match: Text contains the word 'eighth'.\n\n"); else printf("match: Text doesn't contain the word 'eighth'.\n\n"); - + /** Match all occurrences of /wi../ **/ num_matches = matches(text, "m/(wi..)/g", &match_list); printf("matches: m/(wi..)/g found %d matches...\n", num_matches); - + for (i = 0; i < num_matches; i++) printf("match: %s\n", SvPV(*av_fetch(match_list, i, FALSE),n_a)); printf("\n"); - + /** Remove all vowels from text **/ num_matches = substitute(&text, "s/[aeiou]//gi"); if (num_matches) { @@ -497,12 +497,12 @@ been wrapped here): num_matches); printf("Now text is: %s\n\n", SvPV(text,n_a)); } - + /** Attempt a substitution **/ if (!substitute(&text, "s/Perl/C/")) { printf("substitute: s/Perl/C...No substitution made.\n\n"); } - + SvREFCNT_dec(text); PL_perl_destruct_level = 1; perl_destruct(my_perl); diff --git a/pod/perlfaq.pod b/pod/perlfaq.pod index 0d5dae8f5a..fa6943f0db 100644 --- a/pod/perlfaq.pod +++ b/pod/perlfaq.pod @@ -250,7 +250,7 @@ miscellaneous data issues. =item * What's wrong with always quoting "$vars"? -=item * Why don't my E<lt>E<lt>HERE documents work? +=item * Why don't my <<HERE documents work? =item * What is the difference between a list and an array? @@ -361,11 +361,11 @@ I/O and the "f" issues: filehandles, flushing, formats and footers. =item * How come when I open a file read-write it wipes it out? -=item * Why do I sometimes get an "Argument list too long" when I use E<lt>*E<gt>? +=item * Why do I sometimes get an "Argument list too long" when I use <*>? =item * Is there a leak/bug in glob()? -=item * How can I open a file with a leading "E<gt>" or trailing blanks? +=item * How can I open a file with a leading ">" or trailing blanks? =item * How can I reliably rename a file? @@ -508,7 +508,7 @@ other sections. =item * What's the difference between deep and shallow binding? -=item * Why doesn't "my($foo) = E<lt>FILEE<gt>;" work right? +=item * Why doesn't "my($foo) = <FILE>;" work right? =item * How do I redefine a builtin function, operator, or method? diff --git a/pod/perlfaq2.pod b/pod/perlfaq2.pod index 4530f40032..d6870b71dc 100644 --- a/pod/perlfaq2.pod +++ b/pod/perlfaq2.pod @@ -262,7 +262,7 @@ a star may be ordered from O'Reilly. by Ellen Siever, Stephan Spainhour, and Nathan Patwardhan =item Tutorials - + *Learning Perl [2nd edition] by Randal L. Schwartz and Tom Christiansen with foreword by Larry Wall diff --git a/pod/perlfaq4.pod b/pod/perlfaq4.pod index 7a342719f7..ad4824577d 100644 --- a/pod/perlfaq4.pod +++ b/pod/perlfaq4.pod @@ -465,7 +465,7 @@ really does work: # $_ contains the string to parse # BEGIN and END are the opening and closing markers for the # nested text. - + @( = ('(',''); @) = (')',''); ($re=$_)=~s/((BEGIN)|(END)|.)/$)[!$3]\Q$1\E$([!$2]/gs; @@ -821,7 +821,7 @@ Stringification also destroys arrays. print "@lines"; # WRONG - extra blanks print @lines; # right -=head2 Why don't my E<lt>E<lt>HERE documents work? +=head2 Why don't my <<HERE documents work? Check for these three things: @@ -1282,7 +1282,7 @@ Supply a comparison function to sort() (described in L<perlfunc/sort>): @list = sort { $a <=> $b } @list; The default sort function is cmp, string comparison, which would -sort C<(1, 2, 10)> into C<(1, 10, 2)>. C<E<lt>=E<gt>>, used above, is +sort C<(1, 2, 10)> into C<(1, 10, 2)>. C<< <=> >>, used above, is the numerical comparison operator. If you have a complicated function needed to pull out the part you diff --git a/pod/perlfaq5.pod b/pod/perlfaq5.pod index 2209180c22..6ae7755f8b 100644 --- a/pod/perlfaq5.pod +++ b/pod/perlfaq5.pod @@ -347,7 +347,7 @@ Then use any of those as you would a normal filehandle. Anywhere that Perl is expecting a filehandle, an indirect filehandle may be used instead. An indirect filehandle is just a scalar variable that contains a filehandle. Functions like C<print>, C<open>, C<seek>, or -the C<E<lt>FHE<gt>> diamond operator will accept either a read filehandle +the C<< <FH> >> diamond operator will accept either a read filehandle or a scalar variable containing one: ($ifh, $ofh, $efh) = (*STDIN, *STDOUT, *STDERR); @@ -407,7 +407,7 @@ calls doesn't work for the diamond operator. That's because it's a real operator, not just a function with a comma-less argument. Assuming you've been storing typeglobs in your structure as we did above, you can use the built-in function named C<readline> to reads a record just -as C<E<lt>E<gt>> does. Given the initialization shown above for @fd, this +as C<< <> >> does. Given the initialization shown above for @fd, this would work, but only because readline() require a typeglob. It doesn't work with objects or strings, which might be a bug we haven't fixed yet. @@ -463,7 +463,7 @@ whatever: =head2 How can I translate tildes (~) in a filename? -Use the E<lt>E<gt> (glob()) operator, documented in L<perlfunc>. This +Use the <> (glob()) operator, documented in L<perlfunc>. This requires that you have a shell installed that groks tildes, meaning csh or tcsh or (some versions of) ksh, and thus may have portability problems. The Glob::KGlob module (available from CPAN) gives more @@ -495,7 +495,7 @@ doesn't exist. open(FH, "+< /path/name"); # open for update -Using "E<gt>" always clobbers or creates. Using "E<lt>" never does +Using ">" always clobbers or creates. Using "<" never does either. The "+" doesn't change this. Here are examples of many kinds of file opens. Those using sysopen() @@ -556,9 +556,9 @@ isn't so exclusive as you might wish. See also the new L<perlopentut> if you have it (new for 5.6). -=head2 Why do I sometimes get an "Argument list too long" when I use E<lt>*E<gt>? +=head2 Why do I sometimes get an "Argument list too long" when I use <*>? -The C<E<lt>E<gt>> operator performs a globbing operation (see above). +The C<< <> >> operator performs a globbing operation (see above). In Perl versions earlier than v5.6.0, the internal glob() operator forks csh(1) to do the actual glob expansion, but csh can't handle more than 127 items and so gives the error message @@ -576,7 +576,7 @@ use the glob() function or its angle-bracket alias in a scalar context, you may cause a leak and/or unpredictable behavior. It's best therefore to use glob() only in list context. -=head2 How can I open a file with a leading "E<gt>" or trailing blanks? +=head2 How can I open a file with a leading ">" or trailing blanks? Normally perl ignores trailing blanks in filenames, and interprets certain leading characters (or a trailing "|") to mean something @@ -1100,7 +1100,7 @@ Or even with a literal numeric descriptor: $fd = $ENV{MHCONTEXTFD}; open(MHCONTEXT, "<&=$fd"); # like fdopen(3S) -Note that "E<lt>&STDIN" makes a copy, but "E<lt>&=STDIN" make +Note that "<&STDIN" makes a copy, but "<&=STDIN" make an alias. That means if you close an aliased handle, all aliases become inaccessible. This is not true with a copied one. diff --git a/pod/perlfaq6.pod b/pod/perlfaq6.pod index de6093a5ba..bf007ee26b 100644 --- a/pod/perlfaq6.pod +++ b/pod/perlfaq6.pod @@ -533,8 +533,8 @@ pos() point. A failed match resets the position of C<\G> unless the C</c> modifier is in effect. For example, suppose you had a line of text quoted in standard mail -and Usenet notation, (that is, with leading C<E<gt>> characters), and -you want change each leading C<E<gt>> into a corresponding C<:>. You +and Usenet notation, (that is, with leading C<< > >> characters), and +you want change each leading C<< > >> into a corresponding C<:>. You could do so in this way: s/^(>+)/':' x length($1)/gem; diff --git a/pod/perlfaq7.pod b/pod/perlfaq7.pod index 72f4bb74ab..0afbc0dd34 100644 --- a/pod/perlfaq7.pod +++ b/pod/perlfaq7.pod @@ -35,12 +35,12 @@ really type specifiers are: <> are used for inputting a record from a filehandle. \ takes a reference to something. -Note that E<lt>FILEE<gt> is I<neither> the type specifier for files -nor the name of the handle. It is the C<E<lt>E<gt>> operator applied +Note that <FILE> is I<neither> the type specifier for files +nor the name of the handle. It is the C<< <> >> operator applied to the handle FILE. It reads one line (well, record - see L<perlvar/$/>) from the handle FILE in scalar context, or I<all> lines in list context. When performing open, close, or any other operation -besides C<E<lt>E<gt>> on files, or even talking about the handle, do +besides C<< <> >> on files, or even talking about the handle, do I<not> use the brackets. These are correct: C<eof(FH)>, C<seek(FH, 0, 2)> and "copying from STDIN to FILE". @@ -49,7 +49,7 @@ I<not> use the brackets. These are correct: C<eof(FH)>, C<seek(FH, 0, Normally, a bareword doesn't need to be quoted, but in most cases probably should be (and must be under C<use strict>). But a hash key consisting of a simple word (that isn't the name of a defined -subroutine) and the left-hand operand to the C<=E<gt>> operator both +subroutine) and the left-hand operand to the C<< => >> operator both count as though they were quoted: This is like this @@ -307,10 +307,10 @@ you want to pass in a bit of code into a function: my $line; timeout( 30, sub { $line = <STDIN> } ); -If the code to execute had been passed in as a string, C<'$line = -E<lt>STDINE<gt>'>, there would have been no way for the hypothetical -timeout() function to access the lexical variable $line back in its -caller's scope. +If the code to execute had been passed in as a string, +C<< '$line = <STDIN>' >>, there would have been no way for the +hypothetical timeout() function to access the lexical variable +$line back in its caller's scope. =head2 What is variable suicide and how can I prevent it? @@ -581,10 +581,10 @@ However, dynamic variables (aka global, local, or package variables) are effectively shallowly bound. Consider this just one more reason not to use them. See the answer to L<"What's a closure?">. -=head2 Why doesn't "my($foo) = E<lt>FILEE<gt>;" work right? +=head2 Why doesn't "my($foo) = <FILE>;" work right? C<my()> and C<local()> give list context to the right hand side -of C<=>. The E<lt>FHE<gt> read operation, like so many of Perl's +of C<=>. The <FH> read operation, like so many of Perl's functions and operators, can tell which context it was called in and behaves appropriately. In general, the scalar() function can help. This function does nothing to the data itself (contrary to popular myth) @@ -766,7 +766,7 @@ before Perl has seen that such a package exists. It's wisest to make sure your packages are all defined before you start using them, which will be taken care of if you use the C<use> statement instead of C<require>. If not, make sure to use arrow notation (eg, -C<Guru-E<gt>find("Samy")>) instead. Object notation is explained in +C<< Guru->find("Samy") >>) instead. Object notation is explained in L<perlobj>. Make sure to read about creating modules in L<perlmod> and diff --git a/pod/perlfaq8.pod b/pod/perlfaq8.pod index 0d77dc13fc..ed22ba0c59 100644 --- a/pod/perlfaq8.pod +++ b/pod/perlfaq8.pod @@ -410,7 +410,7 @@ For example: } However, because syscalls restart by default, you'll find that if -you're in a "slow" call, such as E<lt>FHE<gt>, read(), connect(), or +you're in a "slow" call, such as <FH>, read(), connect(), or wait(), that the only way to terminate them is by "longjumping" out; that is, by raising an exception. See the time-out handler for a blocking flock() in L<perlipc/"Signals"> or chapter 6 of the Camel. @@ -976,7 +976,7 @@ sysopen(): sysopen(FH, "/tmp/somefile", O_WRONLY|O_NDELAY|O_CREAT, 0644) or die "can't open /tmp/somefile: $!": - + =head2 How do I install a module from CPAN? diff --git a/pod/perlfaq9.pod b/pod/perlfaq9.pod index d2f2034e1b..16a803c997 100644 --- a/pod/perlfaq9.pod +++ b/pod/perlfaq9.pod @@ -82,7 +82,7 @@ way is to use HTML::FormatText which not only removes HTML but also attempts to do a little simple formatting of the resulting plain text. Many folks attempt a simple-minded regular expression approach, like -C<s/E<lt>.*?E<gt>//g>, but that fails in many cases because the tags +C<< s/<.*?>//g >>, but that fails in many cases because the tags may continue over line breaks, they may contain quoted angle-brackets, or HTML comment may be present. Plus folks forget to convert entities, like C<<> for example. @@ -148,7 +148,7 @@ the same as the startform() method. =head2 How do I make a pop-up menu in HTML? -Use the B<E<lt>SELECTE<gt>> and B<E<lt>OPTIONE<gt>> tags. The CGI.pm +Use the B<< <SELECT> >> and B<< <OPTION> >> tags. The CGI.pm module (available from CPAN) supports this widget, as well as many others, including some that it cleverly synthesizes on its own. @@ -396,7 +396,7 @@ format after minor transliterations: =head2 How do I return the user's mail address? -On systems that support getpwuid, the $E<lt> variable and the +On systems that support getpwuid, the $< variable and the Sys::Hostname module (which is part of the standard perl distribution), you can probably try using something like this: diff --git a/pod/perlfilter.pod b/pod/perlfilter.pod index d5fae925b1..bf287c0873 100644 --- a/pod/perlfilter.pod +++ b/pod/perlfilter.pod @@ -1,7 +1,7 @@ =head1 NAME perlfilter - Source Filters - + =head1 DESCRIPTION @@ -198,7 +198,7 @@ going to this trouble is when writing a source scrambler. The C<decrypt> filter (which unscrambles the source before Perl parses it) included with the source filter distribution is an example of a C source filter (see Decryption Filters, below). - + =over 5 diff --git a/pod/perlguts.pod b/pod/perlguts.pod index 58bcea3d1a..6caed3ebf8 100644 --- a/pod/perlguts.pod +++ b/pod/perlguts.pod @@ -385,10 +385,10 @@ Beginning with version 5.004, the following functions are also supported: HE* hv_fetch_ent (HV* tb, SV* key, I32 lval, U32 hash); HE* hv_store_ent (HV* tb, SV* key, SV* val, U32 hash); - + bool hv_exists_ent (HV* tb, SV* key, U32 hash); SV* hv_delete_ent (HV* tb, SV* key, I32 flags, U32 hash); - + SV* hv_iterkeysv (HE* entry); Note that these functions take C<SV*> keys, which simplifies writing diff --git a/pod/perlipc.pod b/pod/perlipc.pod index 3649e4f883..3ddea3e41b 100644 --- a/pod/perlipc.pod +++ b/pod/perlipc.pod @@ -1024,7 +1024,7 @@ something to the server before fetching the server's response. The web server handing the "http" service, which is assumed to be at its standard port, number 80. If your the web server you're trying to connect to is at a different port (like 1080 or 8080), you should specify -as the named-parameter pair, C<PeerPort =E<gt> 8080>. The C<autoflush> +as the named-parameter pair, C<< PeerPort => 8080 >>. The C<autoflush> method is used on the socket because otherwise the system would buffer up the output we sent it. (If you're on a Mac, you'll also need to change every C<"\n"> in your code that sends data over the network to @@ -1142,7 +1142,7 @@ well. As always, setting up a server is little bit more involved than running a client. The model is that the server creates a special kind of socket that does nothing but listen on a particular port for incoming connections. -It does this by calling the C<IO::Socket::INET-E<gt>new()> method with +It does this by calling the C<< IO::Socket::INET->new() >> method with slightly different arguments than the client did. =over diff --git a/pod/perllexwarn.pod b/pod/perllexwarn.pod index d370f04412..af1a910334 100644 --- a/pod/perllexwarn.pod +++ b/pod/perllexwarn.pod @@ -18,10 +18,10 @@ By default, optional warnings are disabled, so any legacy code that doesn't attempt to control the warnings will work unchanged. All warnings are enabled in a block by either of these: - + use warnings ; use warnings 'all' ; - + Similarly all warnings are disabled in a block by either of these: no warnings ; @@ -138,7 +138,7 @@ will enable warnings everywhere. See L<Backward Compatibility> for details of how this flag interacts with lexical warnings. =item B<-W> - + If the B<-W> flag is used on the command line, it will enable all warnings throughout the program regardless of whether warnings were disabled locally using C<no warnings> or C<$^W =0>. This includes all files that get @@ -177,19 +177,19 @@ means that any legacy code that currently relies on manipulating C<$^W> to control warning behavior will still work as is. =item 3. - + Apart from now being a boolean, the C<$^W> variable operates in exactly the same horrible uncontrolled global way, except that it cannot disable/enable default warnings. =item 4. - + If a piece of code is under the control of the C<warnings> pragma, both the C<$^W> variable and the B<-w> flag will be ignored for the scope of the lexical warning. =item 5. - + The only way to override a lexical warnings setting is with the B<-W> or B<-X> command line flags. @@ -200,7 +200,7 @@ the C<warnings> pragma to control the warning behavior of $^W-type code (using a C<local $^W=0>) if it really wants to, but not vice-versa. =head2 Category Hierarchy - + A hierarchy of "categories" have been defined to allow groups of warnings to be enabled/disabled in isolation. @@ -318,7 +318,7 @@ To determine which category a specific warning has been assigned to see L<perldiag>. =head2 Fatal Warnings - + The presence of the word "FATAL" in the category list will escalate any warnings detected from the categories specified in the lexical scope into fatal errors. In the code below, there are 3 places where a @@ -327,14 +327,14 @@ fatal error. use warnings ; - + $a = 1 if $a EQ $b ; - + { use warnings FATAL => qw(deprecated) ; $a = 1 if $a EQ $b ; } - + $a = 1 if $a EQ $b ; =head2 Reporting Warnings from a Module @@ -383,7 +383,7 @@ then C<warnings::warn> will detect this and die after displaying the warning message. =head1 TODO - + perl5db.pl The debugger saves and restores C<$^W> at runtime. I haven't checked whether the debugger will still work with the lexical warnings @@ -398,7 +398,7 @@ warning message. =head1 SEE ALSO L<warnings>, L<perldiag>. - + =head1 AUTHOR - + Paul Marquess diff --git a/pod/perllocale.pod b/pod/perllocale.pod index 475cc0d1e5..ea56e1e03e 100644 --- a/pod/perllocale.pod +++ b/pod/perllocale.pod @@ -309,7 +309,7 @@ discussed above. We decided to try that instead of the above faulty locale "En_US"--and in Cshish shells (B<csh>, B<tcsh>) setenv LC_ALL en_US.ISO8859-1 - + If you do not know what shell you have, consult your local helpdesk or the equivalent. diff --git a/pod/perlmodinstall.pod b/pod/perlmodinstall.pod index 6a861e4fbd..5f1c62e96d 100644 --- a/pod/perlmodinstall.pod +++ b/pod/perlmodinstall.pod @@ -285,7 +285,7 @@ in the Perl distribution. While still in that directory, type: make install - + You will need the packages mentioned in F<README.dos> in the Perl distribution. =item * diff --git a/pod/perlmodlib.pod b/pod/perlmodlib.pod index f4331c3324..38044c9157 100644 --- a/pod/perlmodlib.pod +++ b/pod/perlmodlib.pod @@ -1150,8 +1150,8 @@ Generally you can delete the C<eq 'FOO'> part with no harm at all. Let the objects look after themselves! Generally, avoid hard-wired class names as far as possible. -Avoid C<$r-E<gt>Class::func()> where using C<@ISA=qw(... Class ...)> and -C<$r-E<gt>func()> would work (see L<perlbot> for more details). +Avoid C<< $r->Class::func() >> where using C<@ISA=qw(... Class ...)> and +C<< $r->func() >> would work (see L<perlbot> for more details). Use autosplit so little used or newly added functions won't be a burden to programs that don't use them. Add test functions to @@ -1208,7 +1208,7 @@ or nature of a variable. For example: $no_caps_here function scope my() or local() variables Function and method names seem to work best as all lowercase. -e.g., C<$obj-E<gt>as_string()>. +e.g., C<< $obj->as_string() >>. You can use a leading underscore to indicate that a variable or function should not be used outside the package that defined it. @@ -1224,7 +1224,7 @@ export try to use @EXPORT_OK in preference to @EXPORT and avoid short or common names to reduce the risk of name clashes. Generally anything not exported is still accessible from outside the -module using the ModuleName::item_name (or C<$blessed_ref-E<gt>method>) +module using the ModuleName::item_name (or C<< $blessed_ref->method >>) syntax. By convention you can use a leading underscore on names to indicate informally that they are 'internal' and not for public use. diff --git a/pod/perlobj.pod b/pod/perlobj.pod index fa826415c8..4e45aff7c6 100644 --- a/pod/perlobj.pod +++ b/pod/perlobj.pod @@ -96,8 +96,8 @@ so that your constructors may be inherited: return $self; } -Or if you expect people to call not just C<CLASS-E<gt>new()> but also -C<$obj-E<gt>new()>, then use something like this. The initialize() +Or if you expect people to call not just C<< CLASS->new() >> but also +C<< $obj->new() >>, then use something like this. The initialize() method used will be of whatever $class we blessed the object into: @@ -239,7 +239,7 @@ indirect object slot: display {find Critter "Fred"} 'Height', 'Weight'; -For C++ fans, there's also a syntax using -E<gt> notation that does exactly +For C++ fans, there's also a syntax using -> notation that does exactly the same thing. The parentheses are required if there are any arguments. $fred = Critter->find("Fred"); @@ -346,7 +346,7 @@ Rather than what you might have expected: $obj->{FIELD}->move(); # You should be so lucky. $ary[$i]->move; # Yeah, sure. -The left side of ``-E<gt>'' is not so limited, because it's an infix operator, +The left side of ``->'' is not so limited, because it's an infix operator, not a postfix operator. As if that weren't bad enough, think about this: Perl must guess I<at @@ -362,7 +362,7 @@ tries to cheat by remembering bareword C<require>s, but the grief if it messes up just isn't worth the years of debugging it would likely take you to track such subtle bugs down. -The infix arrow notation using ``C<-E<gt>>'' doesn't suffer from either +The infix arrow notation using ``C<< -> >>'' doesn't suffer from either of these disturbing ambiguities, so we recommend you use it exclusively. =head2 Default UNIVERSAL methods diff --git a/pod/perlopentut.pod b/pod/perlopentut.pod index d3d9f5ada5..9cb9f6738a 100644 --- a/pod/perlopentut.pod +++ b/pod/perlopentut.pod @@ -175,7 +175,7 @@ L<perlfaq5> for more details. One of the most common uses for C<open> is one you never even notice. When you process the ARGV filehandle using -C<E<lt>ARGVE<gt>>, Perl actually does an implicit open +C<< <ARGV> >>, Perl actually does an implicit open on each file in @ARGV. Thus a program called like this: $ myprogram file1 file2 file3 @@ -189,7 +189,7 @@ using a construct no more complex than: If @ARGV is empty when the loop first begins, Perl pretends you've opened up minus, that is, the standard input. In fact, $ARGV, the currently -open file during C<E<lt>ARGVE<gt>> processing, is even set to "-" +open file during C<< <ARGV> >> processing, is even set to "-" in these circumstances. You are welcome to pre-process your @ARGV before starting the loop to @@ -239,7 +239,7 @@ Here's an example: or die "can't open $pwdinfo: $!"; This sort of thing also comes into play in filter processing. Because -C<E<lt>ARGVE<gt>> processing employs the normal, shell-style Perl C<open>, +C<< <ARGV> >> processing employs the normal, shell-style Perl C<open>, it respects all the special things we've already seen: $ myprogram f1 "cmd1|" - f2 "cmd2|" f3 < tmpfile @@ -264,7 +264,7 @@ you can fetch URLs before processing them: @ARGV = map { m#^\w+://# ? "GET $_ |" : $_ } @ARGV; -It's not for nothing that this is called magic C<E<lt>ARGVE<gt>>. +It's not for nothing that this is called magic C<< <ARGV> >>. Pretty nifty, eh? =head1 Open E<agrave> la C @@ -393,7 +393,7 @@ folders, cookie files, and internal temporary files. Sometimes you already have a filehandle open, and want to make another handle that's a duplicate of the first one. In the shell, we place an ampersand in front of a file descriptor number when doing redirections. -For example, C<2E<gt>&1> makes descriptor 2 (that's STDERR in Perl) +For example, C<< 2>&1 >> makes descriptor 2 (that's STDERR in Perl) be redirected into descriptor 1 (which is usually Perl's STDOUT). The same is essentially true in Perl: a filename that begins with an ampersand is treated instead as a file descriptor if a number, or as a @@ -444,8 +444,8 @@ these days. Here's an example of that: $fd = $ENV{"MHCONTEXTFD"}; open(MHCONTEXT, "<&=$fd") or die "couldn't fdopen $fd: $!"; -If you're using magic C<E<lt>ARGVE<gt>>, you could even pass in as a -command line argument in @ARGV something like C<"E<lt>&=$MHCONTEXTFD">, +If you're using magic C<< <ARGV> >>, you could even pass in as a +command line argument in @ARGV something like C<"<&=$MHCONTEXTFD">, but we've never seen anyone actually do this. =head2 Dispelling the Dweomer @@ -474,7 +474,7 @@ The only vaguely popular system that doesn't work this way is the proprietary Macintosh system, which uses a colon where the rest of us use a slash. Maybe C<sysopen> isn't such a bad idea after all. -If you want to use C<E<lt>ARGVE<gt>> processing in a totally boring +If you want to use C<< <ARGV> >> processing in a totally boring and non-magical way, you could do this first: # "Sam sat on the ground and put his head in his hands. diff --git a/pod/perlpod.pod b/pod/perlpod.pod index 49e0ffc767..f4725ba790 100644 --- a/pod/perlpod.pod +++ b/pod/perlpod.pod @@ -173,7 +173,7 @@ here and in commands: L<text|name/"sec"> L<text|"sec"> L<text|/"sec"> - + F<file> Used for filenames X<index> An index entry Z<> A zero-width character diff --git a/pod/perlport.pod b/pod/perlport.pod index b062b3b106..10723ee3a4 100644 --- a/pod/perlport.pod +++ b/pod/perlport.pod @@ -75,7 +75,7 @@ This information should not be considered complete; it includes possibly transient information about idiosyncrasies of some of the ports, almost all of which are in a state of constant evolution. Thus, this material should be considered a perpetual work in progress -(E<lt>IMG SRC="yellow_sign.gif" ALT="Under Construction"E<gt>). +(<IMG SRC="yellow_sign.gif" ALT="Under Construction">). =head1 ISSUES @@ -303,15 +303,15 @@ first 8 characters. Whitespace in filenames is tolerated on most systems, but not all. Many systems (DOS, VMS) cannot have more than one C<.> in their filenames. -Don't assume C<E<gt>> won't be the first character of a filename. -Always use C<E<lt>> explicitly to open a file for reading, +Don't assume C<< > >> won't be the first character of a filename. +Always use C<< < >> explicitly to open a file for reading, unless you want the user to be able to specify a pipe open. open(FILE, "< $existing_file") or die $!; If filenames might use strange characters, it is safest to open it with C<sysopen> instead of C<open>. C<open> is magic and can -translate characters like C<E<gt>>, C<E<lt>>, and C<|>, which may +translate characters like C<< > >>, C<< < >>, and C<|>, which may be the wrong thing to do. (Sometimes, though, it's the right thing.) =head2 System Interaction @@ -787,7 +787,7 @@ you are so inclined. For example: $ endif Do take care with C<$ ASSIGN/nolog/user SYS$COMMAND: SYS$INPUT> if your -perl-in-DCL script expects to do things like C<$read = E<lt>STDINE<gt>;>. +perl-in-DCL script expects to do things like C<< $read = <STDIN>; >>. Filenames are in the format "name.extension;version". The maximum length for filenames is 39 characters, and the maximum length for @@ -1053,9 +1053,9 @@ C<System$Path> until a name is made that points to an object on disk. Writing to a new file C<System:Modules> would be allowed only if C<System$Path> contains a single item list. The filesystem will also expand system variables in filenames if enclosed in angle brackets, so -C<E<lt>System$DirE<gt>.Modules> would look for the file +C<< <System$Dir>.Modules >> would look for the file S<C<$ENV{'System$Dir'} . 'Modules'>>. The obvious implication of this is -that B<fully qualified filenames can start with C<E<lt>E<gt>>> and should +that B<fully qualified filenames can start with C<< <> >>> and should be protected when C<open> is used for input. Because C<.> was in use as a directory separator and filenames could not @@ -1095,11 +1095,11 @@ library emulates Unix filehandles. Consequently, you can't rely on passing C<STDIN>, C<STDOUT>, or C<STDERR> to your children. The desire of users to express filenames of the form -C<E<lt>Foo$DirE<gt>.Bar> on the command line unquoted causes problems, +C<< <Foo$Dir>.Bar >> on the command line unquoted causes problems, too: C<``> command output capture has to perform a guessing game. It -assumes that a string C<E<lt>[^E<lt>E<gt>]+\$[^E<lt>E<gt>]E<gt>> is a +assumes that a string C<< <[^<>]+\$[^<>]> >> is a reference to an environment variable, whereas anything else involving -C<E<lt>> or C<E<gt>> is redirection, and generally manages to be 99% +C<< < >> or C<< > >> is redirection, and generally manages to be 99% right. Of course, the problem remains that scripts cannot rely on any Unix tools being available, or that any tools found have Unix-like command line arguments. @@ -1500,7 +1500,7 @@ Not implemented. (S<Mac OS>, Win32, VMS, Plan9, S<RISC OS>, VOS) The C<|> variants are supported only if ToolServer is installed. (S<Mac OS>) -open to C<|E<45>> and C<-|> are unsupported. (S<Mac OS>, Win32, S<RISC OS>) +open to C<|-> and C<-|> are unsupported. (S<Mac OS>, Win32, S<RISC OS>) =item pipe READHANDLE,WRITEHANDLE @@ -1605,7 +1605,7 @@ in C<wait> or C<waitpid>. (Win32) There is no shell to process metacharacters, and the native standard is to pass a command line terminated by "\n" "\r" or "\0" to the spawned -program. Redirection such as C<E<gt> foo> is performed (if at all) by +program. Redirection such as C<< > foo >> is performed (if at all) by the run time library of the spawned program. C<system> I<list> will call the Unix emulation library's C<exec> emulation, which attempts to provide emulation of the stdin, stdout, stderr in force in the parent, providing @@ -1616,7 +1616,7 @@ of a child Unix program will exists. Mileage B<will> vary. (S<RISC OS>) Far from being POSIX compliant. Because there may be no underlying /bin/sh tries to work around the problem by forking and execing the first token in its argument string. Handles basic redirection -("E<lt>" or "E<gt>") on its own behalf. (MiNT) +("<" or ">") on its own behalf. (MiNT) =item times @@ -1754,41 +1754,41 @@ First public release with perl5.005. =head1 AUTHORS / CONTRIBUTORS -Abigail E<lt>abigail@fnx.comE<gt>, -Charles Bailey E<lt>bailey@newman.upenn.eduE<gt>, -Graham Barr E<lt>gbarr@pobox.comE<gt>, -Tom Christiansen E<lt>tchrist@perl.comE<gt>, -Nicholas Clark E<lt>Nicholas.Clark@liverpool.ac.ukE<gt>, -Thomas Dorner E<lt>Thomas.Dorner@start.deE<gt>, -Andy Dougherty E<lt>doughera@lafcol.lafayette.eduE<gt>, -Dominic Dunlop E<lt>domo@vo.luE<gt>, -Neale Ferguson E<lt>neale@mailbox.tabnsw.com.auE<gt>, -David J. Fiander E<lt>davidf@mks.comE<gt>, -Paul Green E<lt>Paul_Green@stratus.comE<gt>, -M.J.T. Guy E<lt>mjtg@cus.cam.ac.ukE<gt>, -Jarkko Hietaniemi E<lt>jhi@iki.fi<gt>, -Luther Huffman E<lt>lutherh@stratcom.comE<gt>, -Nick Ing-Simmons E<lt>nick@ni-s.u-net.comE<gt>, -Andreas J. KE<ouml>nig E<lt>koenig@kulturbox.deE<gt>, -Markus Laker E<lt>mlaker@contax.co.ukE<gt>, -Andrew M. Langmead E<lt>aml@world.std.comE<gt>, -Larry Moore E<lt>ljmoore@freespace.netE<gt>, -Paul Moore E<lt>Paul.Moore@uk.origin-it.comE<gt>, -Chris Nandor E<lt>pudge@pobox.comE<gt>, -Matthias Neeracher E<lt>neeri@iis.ee.ethz.chE<gt>, -Gary Ng E<lt>71564.1743@CompuServe.COME<gt>, -Tom Phoenix E<lt>rootbeer@teleport.comE<gt>, -AndrE<eacute> Pirard E<lt>A.Pirard@ulg.ac.beE<gt>, -Peter Prymmer E<lt>pvhp@forte.comE<gt>, -Hugo van der Sanden E<lt>hv@crypt0.demon.co.ukE<gt>, -Gurusamy Sarathy E<lt>gsar@activestate.comE<gt>, -Paul J. Schinder E<lt>schinder@pobox.comE<gt>, -Michael G Schwern E<lt>schwern@pobox.comE<gt>, -Dan Sugalski E<lt>sugalskd@ous.eduE<gt>, -Nathan Torkington E<lt>gnat@frii.comE<gt>. +Abigail <abigail@fnx.com>, +Charles Bailey <bailey@newman.upenn.edu>, +Graham Barr <gbarr@pobox.com>, +Tom Christiansen <tchrist@perl.com>, +Nicholas Clark <Nicholas.Clark@liverpool.ac.uk>, +Thomas Dorner <Thomas.Dorner@start.de>, +Andy Dougherty <doughera@lafcol.lafayette.edu>, +Dominic Dunlop <domo@vo.lu>, +Neale Ferguson <neale@mailbox.tabnsw.com.au>, +David J. Fiander <davidf@mks.com>, +Paul Green <Paul_Green@stratus.com>, +M.J.T. Guy <mjtg@cus.cam.ac.uk>, +Jarkko Hietaniemi <jhi@iki.fi<gt>, +Luther Huffman <lutherh@stratcom.com>, +Nick Ing-Simmons <nick@ni-s.u-net.com>, +Andreas J. KE<ouml>nig <koenig@kulturbox.de>, +Markus Laker <mlaker@contax.co.uk>, +Andrew M. Langmead <aml@world.std.com>, +Larry Moore <ljmoore@freespace.net>, +Paul Moore <Paul.Moore@uk.origin-it.com>, +Chris Nandor <pudge@pobox.com>, +Matthias Neeracher <neeri@iis.ee.ethz.ch>, +Gary Ng <71564.1743@CompuServe.COM>, +Tom Phoenix <rootbeer@teleport.com>, +AndrE<eacute> Pirard <A.Pirard@ulg.ac.be>, +Peter Prymmer <pvhp@forte.com>, +Hugo van der Sanden <hv@crypt0.demon.co.uk>, +Gurusamy Sarathy <gsar@activestate.com>, +Paul J. Schinder <schinder@pobox.com>, +Michael G Schwern <schwern@pobox.com>, +Dan Sugalski <sugalskd@ous.edu>, +Nathan Torkington <gnat@frii.com>. This document is maintained by Chris Nandor -E<lt>pudge@pobox.comE<gt>. +<pudge@pobox.com>. =head1 VERSION diff --git a/pod/perlre.pod b/pod/perlre.pod index 64f7f1cdcb..09bee37161 100644 --- a/pod/perlre.pod +++ b/pod/perlre.pod @@ -312,11 +312,11 @@ several patterns that you want to match against consequent substrings of your string, see the previous reference. The actual location where C<\G> will match can also be influenced by using C<pos()> as an lvalue. See L<perlfunc/pos>. - + The bracketing construct C<( ... )> creates capture buffers. To -refer to the digit'th buffer use \E<lt>digitE<gt> within the +refer to the digit'th buffer use \<digit> within the match. Outside the match use "$" instead of "\". (The -\E<lt>digitE<gt> notation works in certain circumstances outside +\<digit> notation works in certain circumstances outside the match. See the warning below about \1 vs $1 for details.) Referring back to another part of the match is called a I<backreference>. @@ -337,13 +337,13 @@ Examples: if (/(.)\1/) { # find first doubled char print "'$1' is the first doubled character\n"; } - + if (/Time: (..):(..):(..)/) { # parse out values $hours = $1; $minutes = $2; $seconds = $3; } - + Several special variables also refer back to portions of the previous match. C<$+> returns whatever the last bracket match matched. C<$&> returns the entire matched string. (At one point C<$0> did @@ -373,7 +373,7 @@ other two. Backslashed metacharacters in Perl are alphanumeric, such as C<\b>, C<\w>, C<\n>. Unlike some other regular expression languages, there are no backslashed symbols that aren't alphanumeric. So anything -that looks like \\, \(, \), \E<lt>, \E<gt>, \{, or \} is always +that looks like \\, \(, \), \<, \>, \{, or \} is always interpreted as a literal character, not a metacharacter. This was once used in a common idiom to disable or quote the special meanings of regular expression metacharacters in a string that you want to @@ -496,9 +496,9 @@ Sometimes it's still easier just to say: For look-behind see below. -=item C<(?E<lt>=pattern)> +=item C<(?<=pattern)> -A zero-width positive look-behind assertion. For example, C</(?E<lt>=\t)\w+/> +A zero-width positive look-behind assertion. For example, C</(?<=\t)\w+/> matches a word that follows a tab, without including the tab in C<$&>. Works only for fixed-width look-behind. @@ -597,7 +597,7 @@ The following pattern matches a parenthesized group: \) }x; -=item C<(?E<gt>pattern)> +=item C<< (?>pattern) >> B<WARNING>: This extended regular expression feature is considered highly experimental, and may be changed or deleted without notice. @@ -610,7 +610,7 @@ construct is useful for optimizations of what would otherwise be It may also be useful in places where the "grab all you can, and do not give anything back" semantic is desirable. -For example: C<^(?E<gt>a*)ab> will never match, since C<(?E<gt>a*)> +For example: C<< ^(?>a*)ab >> will never match, since C<< (?>a*) >> (anchored at the beginning of string, as above) will match I<all> characters C<a> at the beginning of string, leaving no C<a> for C<ab> to match. In contrast, C<a*ab> will match the same as C<a+b>, @@ -619,10 +619,10 @@ group C<ab> (see L<"Backtracking">). In particular, C<a*> inside C<a*ab> will match fewer characters than a standalone C<a*>, since this makes the tail match. -An effect similar to C<(?E<gt>pattern)> may be achieved by writing +An effect similar to C<< (?>pattern) >> may be achieved by writing C<(?=(pattern))\1>. This matches the same substring as a standalone C<a+>, and the following C<\1> eats the matched string; it therefore -makes a zero-length assertion into an analogue of C<(?E<gt>...)>. +makes a zero-length assertion into an analogue of C<< (?>...) >>. (The difference between these two constructs is that the second one uses a capturing group, thus shifting ordinals of backreferences in the rest of a regular expression.) @@ -658,13 +658,13 @@ hung. However, a tiny change to this pattern \) }x -which uses C<(?E<gt>...)> matches exactly when the one above does (verifying +which uses C<< (?>...) >> matches exactly when the one above does (verifying this yourself would be a productive exercise), but finishes in a fourth the time when used on a similar string with 1000000 C<a>s. Be aware, however, that this pattern currently triggers a warning message under B<-w> saying it C<"matches the null string many times">): -On simple groups, such as the pattern C<(?E<gt> [^()]+ )>, a comparable +On simple groups, such as the pattern C<< (?> [^()]+ ) >>, a comparable effect may be achieved by negative look-ahead, as in C<[^()]+ (?! [^()] )>. This was only 4 times slower on a string with 1000000 C<a>s. @@ -907,12 +907,12 @@ then it would take forever--or until you ran out of stack space. A powerful tool for optimizing such beasts is what is known as an "independent group", -which does not backtrack (see L<C<(?E<gt>pattern)>>). Note also that +which does not backtrack (see L<C<< (?>pattern) >>>). Note also that zero-length look-ahead/look-behind assertions will not backtrack to make the tail match, since they are in "logical" context: only whether they match is considered relevant. For an example where side-effects of look-ahead I<might> have influenced the -following match, see L<C<(?E<gt>pattern)>>. +following match, see L<C<< (?>pattern) >>>. =head2 Version 8 Regular Expressions @@ -1160,7 +1160,7 @@ Same as C<S{0,1}>, C<S{0,BIG_NUMBER}>, C<S{1,BIG_NUMBER}> respectively. Same as C<S{0,1}?>, C<S{0,BIG_NUMBER}?>, C<S{1,BIG_NUMBER}?> respectively. -=item C<(?E<gt>S)> +=item C<< (?>S) >> Matches the best match for C<S> and only that. diff --git a/pod/perlref.pod b/pod/perlref.pod index 1d47f37606..274f43d029 100644 --- a/pod/perlref.pod +++ b/pod/perlref.pod @@ -84,7 +84,7 @@ brackets: Here we've created a reference to an anonymous array of three elements whose final element is itself a reference to another anonymous array of three elements. (The multidimensional syntax described later can be used to -access this. For example, after the above, C<$arrayref-E<gt>[2][1]> would have +access this. For example, after the above, C<< $arrayref->[2][1] >> would have the value "b".) Taking a reference to an enumerated list is not the same @@ -357,7 +357,7 @@ syntactic sugar, the examples for method 2 may be written: The left side of the arrow can be any expression returning a reference, including a previous dereference. Note that C<$array[$x]> is I<not> the -same thing as C<$array-E<gt>[$x]> here: +same thing as C<< $array->[$x] >> here: $array[$x]->{"foo"}->[0] = "January"; @@ -365,7 +365,7 @@ This is one of the cases we mentioned earlier in which references could spring into existence when in an lvalue context. Before this statement, C<$array[$x]> may have been undefined. If so, it's automatically defined with a hash reference so that we can look up -C<{"foo"}> in it. Likewise C<$array[$x]-E<gt>{"foo"}> will automatically get +C<{"foo"}> in it. Likewise C<< $array[$x]->{"foo"} >> will automatically get defined with an array reference so that we can look up C<[0]> in it. This process is called I<autovivification>. diff --git a/pod/perlreftut.pod b/pod/perlreftut.pod index 09bea594ff..c8593fb1ce 100644 --- a/pod/perlreftut.pod +++ b/pod/perlreftut.pod @@ -184,26 +184,26 @@ Using a hash reference is I<exactly> the same: B<Use Rule 2> -C<${$aref}[3]> is too hard to read, so you can write C<$aref-E<gt>[3]> +C<${$aref}[3]> is too hard to read, so you can write C<< $aref->[3] >> instead. C<${$href}{red}> is too hard to read, so you can write -C<$href-E<gt>{red}> instead. +C<< $href->{red} >> instead. Most often, when you have an array or a hash, you want to get or set a single element from it. C<${$aref}[3]> and C<${$href}{'red'}> have too much punctuation, and Perl lets you abbreviate. -If C<$aref> holds a reference to an array, then C<$aref-E<gt>[3]> is +If C<$aref> holds a reference to an array, then C<< $aref->[3] >> is the fourth element of the array. Don't confuse this with C<$aref[3]>, which is the fourth element of a totally different array, one deceptively named C<@aref>. C<$aref> and C<@aref> are unrelated the same way that C<$item> and C<@item> are. -Similarly, C<$href-E<gt>{'red'}> is part of the hash referred to by +Similarly, C<< $href->{'red'} >> is part of the hash referred to by the scalar variable C<$href>, perhaps even one with no name. C<$href{'red'}> is part of the deceptively named C<%href> hash. It's -easy to forget to leave out the C<-E<gt>>, and if you do, you'll get +easy to forget to leave out the C<< -> >>, and if you do, you'll get bizarre results when your program gets array and hash elements out of totally unexpected hashes and arrays that weren't the ones you wanted to use. @@ -228,10 +228,10 @@ another array. C<$a[1]> is one of these references. It refers to an array, the array containing C<(4, 5, 6)>, and because it is a reference to an array, -B<USE RULE 2> says that we can write C<$a[1]-E<gt>[2]> to get the -third element from that array. C<$a[1]-E<gt>[2]> is the 6. -Similarly, C<$a[0]-E<gt>[1]> is the 2. What we have here is like a -two-dimensional array; you can write C<$a[ROW]-E<gt>[COLUMN]> to get +B<USE RULE 2> says that we can write C<< $a[1]->[2] >> to get the +third element from that array. C<< $a[1]->[2] >> is the 6. +Similarly, C<< $a[0]->[1] >> is the 2. What we have here is like a +two-dimensional array; you can write C<< $a[ROW]->[COLUMN] >> to get or set the element in any row and any column of the array. The notation still looks a little cumbersome, so there's one more @@ -241,8 +241,8 @@ abbreviation: In between two B<subscripts>, the arrow is optional. -Instead of C<$a[1]-E<gt>[2]>, we can write C<$a[1][2]>; it means the -same thing. Instead of C<$a[0]-E<gt>[1]>, we can write C<$a[0][1]>; +Instead of C<< $a[1]->[2] >>, we can write C<$a[1][2]>; it means the +same thing. Instead of C<< $a[0]->[1] >>, we can write C<$a[0][1]>; it means the same thing. Now it really looks like two-dimensional arrays! diff --git a/pod/perlsub.pod b/pod/perlsub.pod index 927e944c93..46d1a2a2b0 100644 --- a/pod/perlsub.pod +++ b/pod/perlsub.pod @@ -179,7 +179,7 @@ when just naming the subroutine, such as when it's used as an argument to defined() or undef(). Nor is it optional when you want to do an indirect subroutine call with a subroutine name or reference using the C<&$subref()> or C<&{$subref}()> constructs, -although the C<$subref-E<gt>()> notation solves that problem. +although the C<< $subref->() >> notation solves that problem. See L<perlref> for more about all that. Subroutines may be called recursively. If a subroutine is called @@ -891,7 +891,7 @@ like a built-in function. If you call it like an old-fashioned subroutine, then it behaves like an old-fashioned subroutine. It naturally falls out from this rule that prototypes have no influence on subroutine references like C<\&foo> or on indirect subroutine -calls like C<&{$subref}> or C<$subref-E<gt>()>. +calls like C<&{$subref}> or C<< $subref->() >>. Method calls are not influenced by prototypes either, because the function to be called is indeterminate at compile time, since diff --git a/pod/perltie.pod b/pod/perltie.pod index 58e9c4375b..92040528e9 100644 --- a/pod/perltie.pod +++ b/pod/perltie.pod @@ -184,7 +184,7 @@ methods: TIEARRAY, FETCH, STORE, FETCHSIZE, STORESIZE and perhaps DESTROY. FETCHSIZE and STORESIZE are used to provide C<$#array> and equivalent C<scalar(@array)> access. - + The methods POP, PUSH, SHIFT, UNSHIFT, SPLICE, DELETE, and EXISTS are required if the perl operator with the corresponding (but lowercase) name is to operate on the tied array. The B<Tie::Array> class can be used as a diff --git a/pod/perltodo.pod b/pod/perltodo.pod index a6ca1f10ef..f22d4737f8 100644 --- a/pod/perltodo.pod +++ b/pod/perltodo.pod @@ -165,7 +165,7 @@ I think we can accomodate that by extending bless() to stash extra information for objects so we track their lifetime accurately for those that want their DESTROY() to be predictable (this will be a speed hit, naturally, and will therefore be optional, naturally. :) - + [N.B. Don't even ask me about this now! When I have the time to write a cogent summary, I'll post it.] @@ -321,14 +321,14 @@ We need something in the vicinity of: No documentation for perl function `random stuff' found The following entry in perlfunc.pod matches /random/a: =item rand EXPR - + =item rand - + Returns a random fractional number greater than or equal to C<0> and less than the value of EXPR. (EXPR should be positive.) If EXPR is omitted, the value C<1> is used. Automatically calls C<srand()> unless C<srand()> has already been called. See also C<srand()>. - + (Note: If your rand function consistently returns numbers that are too large or too small, then your version of Perl was probably compiled with the wrong number of RANDBITS.) diff --git a/pod/perltoot.pod b/pod/perltoot.pod index 3062f5924d..31a7c76353 100644 --- a/pod/perltoot.pod +++ b/pod/perltoot.pod @@ -111,8 +111,8 @@ by up-casing the hash keys: PEERS => [ "Norbert", "Rhys", "Phineas"], }; -And so you could get at C<$rec-E<gt>{NAME}> to find "Jason", or -C<@{ $rec-E<gt>{PEERS} }> to get at "Norbert", "Rhys", and "Phineas". +And so you could get at C<< $rec->{NAME} >> to find "Jason", or +C<< @{ $rec->{PEERS} } >> to get at "Norbert", "Rhys", and "Phineas". (Have you ever noticed how many 23-year-old programmers seem to be named "Jason" these days? :-) @@ -542,7 +542,7 @@ and DESTROY methods as follows: } What happens if a derived class (which we'll call Employee) inherits -methods from this Person base class? Then C<Employee-E<gt>debug()>, when called +methods from this Person base class? Then C<< Employee->debug() >>, when called as a class method, manipulates $Person::Debugging not $Employee::Debugging. =head2 Class Destructors @@ -816,7 +816,7 @@ What do we mean by the Person::new() function -- isn't that actually a method? Well, in principle, yes. A method is just a function that expects as its first argument a class name (package) or object (blessed reference). Person::new() is the function that both the -C<Person-E<gt>new()> method and the C<Employee-E<gt>new()> method end +C<< Person->new() >> method and the C<< Employee->new() >> method end up calling. Understand that while a method call looks a lot like a function call, they aren't really quite the same, and if you treat them as the same, you'll very soon be left with nothing but broken programs. diff --git a/pod/perltootc.pod b/pod/perltootc.pod index 85ae6fba03..64f8233fdb 100644 --- a/pod/perltootc.pod +++ b/pod/perltootc.pod @@ -653,8 +653,8 @@ settings can then be used in constructors for initialization of a particular object. The class's eponymous hash can also be used to implement I<translucent attributes>. A translucent attribute is one that has a class-wide default. Each object can set its own value for the -attribute, in which case C<$object-E<gt>attribute()> returns that value. -But if no value has been set, then C<$object-E<gt>attribute()> returns +attribute, in which case C<< $object->attribute() >> returns that value. +But if no value has been set, then C<< $object->attribute() >> returns the class-wide default. We'll apply something of a copy-on-write approach to these translucent @@ -1294,8 +1294,8 @@ or the AutoLoader, because they alter the lexical scope in which the module's methods wind up getting compiled. The usual mealy-mouthed package-mungeing doubtless applies to setting -up names of object attributes. For example, C<$self-E<gt>{ObData1}> -should probably be C<$self-E<gt>{ __PACKAGE__ . "_ObData1" }>, but that +up names of object attributes. For example, C<< $self->{ObData1} >> +should probably be C<< $self->{ __PACKAGE__ . "_ObData1" } >>, but that would just confuse the examples. =head1 SEE ALSO diff --git a/pod/perltrap.pod b/pod/perltrap.pod index f278fa0929..e528254e0e 100644 --- a/pod/perltrap.pod +++ b/pod/perltrap.pod @@ -69,7 +69,7 @@ executed.) See L<perlvar>. =item * -$E<lt>I<digit>E<gt> does not refer to fields--it refers to substrings matched +$<I<digit>> does not refer to fields--it refers to substrings matched by the last match pattern. =item * @@ -103,7 +103,7 @@ basically incompatible with C.) The concatenation operator is ".", not the null string. (Using the null string would render C</pat/ /pat/> unparsable, because the third slash would be interpreted as a division operator--the tokenizer is in fact -slightly context sensitive for operators like "/", "?", and "E<gt>". +slightly context sensitive for operators like "/", "?", and ">". And in fact, "." itself can be the beginning of a number.) =item * @@ -295,7 +295,7 @@ you might expect to do not. =item * -The E<lt>FHE<gt> construct is not the name of the filehandle, it is a readline +The <FH> construct is not the name of the filehandle, it is a readline operation on that handle. The data read is assigned to $_ only if the file read is the sole condition in a while loop: @@ -424,7 +424,7 @@ behave differently in perl4 vs. perl5, because the packages don't exist. $a=1;$b=2;$c=3;$var=4; print "$a::$b::$c "; print "$var::abc::xyz\n"; - + # perl4 prints: 1::2::3 4::abc::xyz # perl5 prints: 3 @@ -1266,7 +1266,7 @@ Since version 5.002, Perl uses sigaction() under SysV. =item * (SysV) -Under SysV OSes, C<seek()> on a file opened to append C<E<gt>E<gt>> now does +Under SysV OSes, C<seek()> on a file opened to append C<<< >> >>> now does the right thing w.r.t. the fopen() manpage. e.g., - When a file is opened for append, it is impossible to overwrite information already in the file. diff --git a/pod/perlvar.pod b/pod/perlvar.pod index 1b394b3fbe..04fb3fec96 100644 --- a/pod/perlvar.pod +++ b/pod/perlvar.pod @@ -99,7 +99,7 @@ The implicit iterator variable in the grep() and map() functions. =item * -The default place to put an input record when a C<E<lt>FHE<gt>> +The default place to put an input record when a C<< <FH> >> operation's result is tested by itself as the sole criterion of a C<while> test. Outside a C<while> test, this will not happen. @@ -111,7 +111,7 @@ test. Outside a C<while> test, this will not happen. =over 8 -=item $E<lt>I<digits>E<gt> +=item $<I<digits>> Contains the subpattern from the corresponding set of capturing parentheses from the last pattern match, not counting patterns @@ -215,7 +215,7 @@ you just read() (or called a C<seek> or C<tell> on). The value may be different from the actual physical line number in the file, depending on what notion of "line" is in effect--see C<$/> on how to change that. An explicit close on a filehandle resets the line -number. Because C<E<lt>E<gt>> never does an explicit close, line +number. Because C<< <> >> never does an explicit close, line numbers increase across ARGV files (but see examples in L<perlfunc/eof>). Consider this variable read-only: setting it does not reposition the seek pointer; you'll have to do that on your own. Localizing C<$.> @@ -421,7 +421,7 @@ I<n>-th subpattern, or undef if the subpattern did not match. Thus after a match against $_, $& coincides with C<substr $_, $-[0], $+[0] - $-[0]>. Similarly, C<$>I<n> coincides with C<substr $_, $-[>I<n>C<], $+[>I<n>C<] - $-[>I<n>C<]> if C<$-[>I<n>C<]> is defined, and $+ coincides with -C<substr $_, $-[$#-], $+[$#-]>. One can use C<$#E<45>> to find the last +C<substr $_, $-[$#-], $+[$#-]>. One can use C<$#-> to find the last matched subgroup in the last successful match. Contrast with C<$#+>, the number of subgroups in the regular expression. Compare with C<@+>. @@ -511,7 +511,7 @@ The status returned by the last pipe close, backtick (C<``>) command, successful call to wait() or waitpid(), or from the system() operator. This is just the 16-bit status word returned by the wait() system call (or else is made up to look like it). Thus, the -exit value of the subprocess is really (C<$? E<gt>E<gt> 8>), and +exit value of the subprocess is really (C<<< $? >> 8 >>>), and C<$? & 127> gives which signal, if any, the process died from, and C<$? & 128> reports whether there was a core dump. (Mnemonic: similar to B<sh> and B<ksh>.) @@ -629,7 +629,7 @@ The effective uid of this process. Example: ($<,$>) = ($>,$<); # swap real and effective uid (Mnemonic: it's the uid you went I<to>, if you're running setuid.) -C<$E<lt>> and C<$E<gt>> can be swapped only on machines +C<< $< >> and C<< $> >> can be swapped only on machines supporting setreuid(). =item $REAL_GROUP_ID @@ -673,7 +673,7 @@ list, say C< $) = "5 5" >. (Mnemonic: parentheses are used to I<group> things. The effective gid is the group that's I<right> for you, if you're running setgid.) -C<$E<lt>>, C<$E<gt>>, C<$(> and C<$)> can be set only on +C<< $< >>, C<< $> >>, C<$(> and C<$)> can be set only on machines that support the corresponding I<set[re][ug]id()> routine. C<$(> and C<$)> can be swapped only on machines supporting setregid(). @@ -964,7 +964,7 @@ This may not be a full pathname, nor even necessarily in your path. =item $ARGV -contains the name of the current file when reading from E<lt>E<gt>. +contains the name of the current file when reading from <>. =item @ARGV @@ -1134,7 +1134,7 @@ the value of $@ is the compile error, or the argument to C<die> (which will interpolate C<$!> and C<$?>!). (See also L<Fatal>, though.) -When the eval() expression above is executed, open(), C<<PIPEE<gt>>, +When the eval() expression above is executed, open(), C<< <PIPE> >>, and C<close> are translated to calls in the C run-time library and thence to the operating system kernel. C<$!> is set to the C library's C<errno> if one of these calls fails. diff --git a/pod/perlxstut.pod b/pod/perlxstut.pod index 35edd05ac0..88c04ad300 100644 --- a/pod/perlxstut.pod +++ b/pod/perlxstut.pod @@ -201,11 +201,11 @@ example only, we'll create our own test script. Create a file called hello that looks like this: #! /opt/perl5/bin/perl - + use ExtUtils::testlib; - + use Mytest; - + Mytest::hello(); Now we make the script executable (C<chmod -x hello>), run the script @@ -504,7 +504,7 @@ Also create a file mylib.c that looks like this: #include <stdlib.h> #include "./mylib.h" - + double foo(int a, long b, const char *c) { |