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>
--------------
____________________________________________________________________________
+[ 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
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
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
(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
(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
=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
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
=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
=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
}
}
-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;
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
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
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!
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.
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:
$$self;
}
}
-
+
Now we call for the name:
print $talking->name, " says ", $talking->sound, "\n";
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:
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
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
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:
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.
=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
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
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
=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
=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)>.
=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).
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 *
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
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
=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
=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
=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
=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
=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
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
=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
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
=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
(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
=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
=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
(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>.
=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
=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
(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)
=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.
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.
=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.
(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
=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,
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"
=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.
=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.
=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
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.
(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>.
=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
(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
(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.
=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
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
#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);
}
#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
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///)
** 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.
** 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();
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) {
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);
=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?
=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?
=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?
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
# $_ 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;
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:
@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
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);
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.
=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
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()
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
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
$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.
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;
<> 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".
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
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?
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)
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
}
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.
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?
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.
=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.
=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:
=head1 NAME
perlfilter - Source Filters
-
+
=head1 DESCRIPTION
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
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
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
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
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 ;
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
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.
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.
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
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
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
=head1 SEE ALSO
L<warnings>, L<perldiag>.
-
+
=head1 AUTHOR
-
+
Paul Marquess
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.
While still in that directory, type:
make install
-
+
You will need the packages mentioned in F<README.dos> in the Perl distribution.
=item *
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
$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.
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.
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:
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");
$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
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
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
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
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
@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
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
$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
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.
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
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
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
$ 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
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
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.
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
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
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
=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
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>.
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
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
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.
\)
}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.
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>,
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.)
\)
}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.
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
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.
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
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";
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>.
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.
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
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!
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
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
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
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.]
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.)
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? :-)
}
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
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.
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
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
=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 *
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 *
=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:
$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
=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.
=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.
=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
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<$.>
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<@+>.
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>.)
($<,$>) = ($>,$<); # 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
(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().
=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
(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.
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
#include <stdlib.h>
#include "./mylib.h"
-
+
double
foo(int a, long b, const char *c)
{
https://perl5.git.perl.org / perl5.git / commitdiff