sub generate_manifest {
- # Annyoingly unexpand doesn't consider it good form to replace a single
+ # Annoyingly, unexpand doesn't consider it good form to replace a single
# space before a tab with a tab
# Annoyingly (2) it returns read only values.
my @temp = unexpand (map {sprintf "%-32s%s\n", @$_} @_);
B<NOTE:> This is a backwards incompatible no-warning change in behaviour. If you are upgrading
and you process large volumes of text look for POSIX and Perl style character classes and
-change them to the relevent property name (by removing the word 'Posix' from the current name).
+change them to the relevant property name (by removing the word 'Posix' from the current name).
The following table maps the POSIX character class names, the escapes and the old and new
Unicode property mappings:
PERL_TEST_LEGACY_POSIX_CC
-to true your enviornment when testing.
+to true your environment when testing.
=head2 @INC reorganization
=item *
-Explicitely point to $. when it causes an uninitialized warning for ranges in scalar context
+Explicitly point to $. when it causes an uninitialized warning for ranges in scalar context
=item *
=head2 REGEXPs are now first class
-Internally, Perl now treates compiled regular expressions (such as
+Internally, Perl now treats compiled regular expressions (such as
those created with C<qr//>) as first class entities. Perl modules which
serialize, deserialize or otherwise have deep interaction with Perl's
internal data structures need to be updated for this change. Most
core versions of these modules warnings will issue a deprecation warning.
If you ship a packaged version of Perl, either alone or as part of a
-larger system, then you should carefully consider the reprecussions of
+larger system, then you should carefully consider the repercussions of
core module deprecations. You may want to consider shipping your default
build of Perl with packages for some or all deprecated modules which
install into C<vendor> or C<site> perl library directories. This will
Perl's developers have fixed several problems with the recognition of
C<\N{...}> constructs. As part of this, perl will store any scalar
or regex containing C<\N{I<name>}> or C<\N{U+I<wide hex char>}> in its
-definition in UTF-8 format. (This was true previously for all occurences
+definition in UTF-8 format. (This was true previously for all occurrences
of C<\N{I<name>}> that did not use a custom translator, but now it's
always true.)
=item *
-We upgraded L<Safe> to version 2.27 to wrap coderefs retured by C<reval()> and C<rdo()>.
+We upgraded L<Safe> to version 2.27 to wrap coderefs returned by C<reval()> and C<rdo()>.
=back
the speed penalty caused by the introduction of "safe signals" in
5.8.0. Signals should still be dispatched within the same statement as
they were previously - if this is not the case, or it is possible to
-create uninterruptable loops, this is a bug, and reports are encouraged
+create uninterruptible loops, this is a bug, and reports are encouraged
of how to recreate such issues.
=head2 Assignment to C<$0> sets the legacy process name with C<prctl()> on Linux
=head2 C<(?^...)> regex construct added to signify default modifiers
-A caret (also called a "cirumflex accent") C<"^"> immediately following
+A caret (also called a "circumflex accent") C<"^"> immediately following
a C<"(?"> in a regular expression now means that the subexpression is to
not inherit the surrounding modifiers such as C</i>, but to revert to the
Perl defaults. Any modifiers following the caret override the defaults.
(L<CPAN RT #40727|https://rt.cpan.org/Public/Bug/Display.html?id=40727>).
C<< ->maketext >> calls will now backup and restore C<$@> so that error
-messages are not supressed
+messages are not suppressed
(L<CPAN RT #34182|https://rt.cpan.org/Public/Bug/Display.html?id=34182>).
=item *
=item *
C<sort> with a custom sort routine could crash if too many nested
-subroutine calls occurrred from within the sort routine
+subroutine calls occurred from within the sort routine
L<[perl #77930]|http://rt.perl.org/rt3/Public/Bug/Display.html?id=77930>.
This bug was introduced in an earlier 5.13 release, and did not affect
frustrated at the mysterious results (core dumps, most often) it is
for now forbidden (you will get a fatal error even from an attempt).
-=head2 Variable Attributes are not Currently Usable for Tieing
+=head2 Variable Attributes are not Currently Usable for Tying
This limitation will hopefully be fixed in future. (Subroutine
-attributes work fine for t
ieing, see L<Attribute::Handlers>).
+attributes work fine for t
ying, see L<Attribute::Handlers>).
=head2 Building Extensions Can Fail Because Of Largefiles
This variable controls the state of the internal UTF-8 offset caching code.
1 for on (the default), 0 for off, -1 to debug the caching code by checking
-all its results against linear scans, and panicing on any discrepancy.
+all its results against linear scans, and panicking on any discrepancy.
=back
=item *
-Fixed bug RT #37886, symbolic deferencing was allowed in the argument of
+Fixed bug RT #37886, symbolic dereferencing was allowed in the argument of
C<defined> even under the influence of C<use strict 'refs'>.
=item *
=item *
-Fixed bug RT #54828 in F<perlio.c> where calling C<binmode> on Win32 and Cgywin
+Fixed bug RT #54828 in F<perlio.c> where calling C<binmode> on Win32 and Cygwin
may cause a segmentation fault.
=back
The warning is issued when C<%{}> overloading exists on a blessed arrayref,
when C<@{}> overloading exists on a blessed hashref, or when both overloadings
are defined (in which case C<%{}> is used). You can force the interpretation
-of the object by explictly dereferencing it as an array or hash instead of
+of the object by explicitly dereferencing it as an array or hash instead of
passing the object itself to C<keys>, C<values> or C<each>.
=item Ambiguous range in transliteration operator
If you really do mean it, explicitly numify your reference, like so:
C<$array[0+$ref]>. This warning is not given for overloaded objects,
either, because you can overload the numification and stringification
-operators and then you assumably know what you are doing.
+operators and then you presumably know what you are doing.
=item Use of reserved word "%s" is deprecated
$string =~ s/=([0-9A-Fa-f][0-9A-Fa-f])/chr $a2e[hex $1]/ge;
$string =~ s/=[\n\r]+$//;
-=head2 Caesarian ciphers
+=head2 Caesarean ciphers
The practice of shifting an alphabet one or more characters for encipherment
dates back thousands of years and was explicitly detailed by Gaius Julius
popular editors support ctags for several different languages,
including Perl.
-Exuberent ctags supports Perl: http://ctags.sourceforge.net/
+Exuberant ctags supports Perl: http://ctags.sourceforge.net/
You might also try pltags: http://www.mscha.com/pltags.zip
interface changed significantly between versions 1 and 2 so they have
separate Perl modules. It runs under Unix, Win32 and Mac OS X (currently
it requires an X server on Mac OS, but a 'native' port is underway), and
-the widgets look the same on every plaform: i.e., they don't match the
+the widgets look the same on every platform: i.e., they don't match the
native widgets. As with Wx, the Perl bindings follow the C API closely,
and the documentation requires you to read the C documentation to
understand it.
wash_animals( qw( dog cat bird ) );
wash_animals( @animals );
-Array operations, which change the scalars, reaaranges them, or adds
+Array operations, which change the scalars, rearranges them, or adds
or subtracts some scalars, only work on arrays. These can't work on a
list, which is fixed. Array operations include C<shift>, C<unshift>,
C<push>, C<pop>, and C<splice>.
context evaluates its lefthand side, throws away the result, and
evaluates it's righthand side and returns the result. In effect,
that list-lookalike assigns to C<$scalar> it's rightmost value. Many
-people mess this up becuase they choose a list-lookalike whose
+people mess this up because they choose a list-lookalike whose
last element is also the count they expect:
my $scalar = ( 1, 2, 3 ); # $scalar gets 3, accidentally
my $element = $array[ rand @array ];
=head2 How do I permute N elements of a list?
-X<List::Permut
er> X<permute> X<Algorithm::Loops> X<Knuth>
+X<List::Permut
or> X<permute> X<Algorithm::Loops> X<Knuth>
X<The Art of Computer Programming> X<Fischer-Krause>
Use the C<List::Permutor> module on CPAN. If the list is actually an
}
For more details on regular expression efficiency, see I<Mastering
-Regular Expressions> by Jeffrey Freidl. He explains how regular
+Regular Expressions> by Jeffrey Friedl. He explains how regular
expressions engine work and why some patterns are surprisingly
inefficient. Once you understand how perl applies regular expressions,
you can tune them for individual situations.
(contributed by brian d foy)
-The C<LWP> family of modules (available on CPAN as the libwww-perl distibution)
+The C<LWP> family of modules (available on CPAN as the libwww-perl distribution)
can work with FTP just like it can with many other protocols. C<LWP::Simple>
makes it quite easy to fetch a file:
Note that a return value of C<-1> could mean that child processes are
being automatically reaped, as described in L<perlipc>.
-If you use wait in your handler for $SIG{CHLD} it may accidently wait for the
+If you use wait in your handler for $SIG{CHLD} it may accidentally for the
child created by qx() or system(). See L<perlipc> for details.
=item waitpid PID,FLAGS
=item class method
-A L</method> whose L</invocant> is a L</package> name, not an
+A L</method> whose L</invocand> is a L</package> name, not an
L</object> reference. A method associated with the class as a whole.
=item client
indirect-object object" where L</STDOUT> is the recipient of the
L<print|perlfunc/print> action, and C<"$foo"> is the object being
printed. Similarly, when invoking a L</method>, you might place the
-invocant between the method and its arguments:
+invocand between the method and its arguments:
$gollum = new Pathetic::Creature "Smeagol";
give $gollum "Fisssssh!";
form (L<syntax trees|/syntax tree>) within the I<perl> process itself,
which the Perl L</run time> system then interprets.
-=item invocant
+=item invocand
The agent on whose behalf a L</method> is invoked. In a L</class>
-method, the invocant is a package name. In an L</instance> method,
-the invocant is an object reference.
+method, the invocand is a package name. In an L</instance> method,
+the invocand is an object reference.
=item invocation
thing to keep in touch with the most recent changes. If not only to
verify if what you would have posted as a bug report isn't already
solved in the most recent available perl development branch, also
-known as perl-current, bleading edge perl, bleedperl or bleadperl.
+known as perl-current, bleeding edge perl, bleedperl or bleadperl.
Needless to say, the source code in perl-current is usually in a perpetual
state of evolution. You should expect it to be very buggy. Do B<not> use
=item Signals as "faults"
Certain signals like SEGV, ILL, and BUS are generated by virtual memory
-addressing errors and similiar "faults". These are normally fatal: there is
+addressing errors and similar "faults". These are normally fatal: there is
little a Perl-level handler can do with them. So Perl now delivers them
immediately rather than attempting to defer them.
C<CLONE> will be called once as a class method for every package that has it
defined (or inherits it). It will be called in the context of the new thread,
so all modifications are made in the new area. Currently CLONE is called with
-no parameters other than the invocant package name, but code should not assume
+no parameters other than the invocand package name, but code should not assume
that this will remain unchanged, as it is likely that in future extra parameters
will be passed in to give more information about the state of cloning.
needed.
Like C<CLONE>, C<CLONE_SKIP> is currently called with no parameters other
-than the invocant package name, although that may change. Similarly, to
+than the invocand package name, although that may change. Similarly, to
allow for future expansion, the return value should be a single C<0> or
C<1> value.
can contain up to 255 characters, are prohibited from starting
with a C<-> character, and the set of prohibited characters is
reduced to any character matching C<< tr/#%*<>?// >>. There are
-restrictions involving spaces and apostrophies: these characters
+restrictions involving spaces and apostrophes: these characters
must not begin or end a name, nor can they immediately precede or
follow a period. Additionally, a space must not immediately
precede another space or hyphen. Specifically, the following
package main;
- tie my $sv => "CatptureVar";
+ tie my $sv => "CaptureVar";
$sv =~ y/a/b/;
Because C<$sv> is C<undef> when the C<y///> operator is applied to it
In some contexts, a backslash followed by two or even one octal digits may be
interpreted as an octal escape, sometimes with a warning, and because of some
bugs, sometimes with surprising results. Also, if you are creating a regex
-out of smaller snippets concatentated together, and you use fewer than three
+out of smaller snippets concatenated together, and you use fewer than three
digits, the beginning of one snippet may be interpreted as adding digits to the
ending of the snippet before it. See L</Absolute referencing> for more
discussion and examples of the snippet problem.
with C<$1> being the line number for the next line, and C<$3> being
the optional filename (specified with or without quotes). Note that
-no whitespace may preceed the C<< # >>, unlike modern C preprocessors.
+no whitespace may precede the C<< # >>, unlike modern C preprocessors.
There is a fairly obvious gotcha included with the line directive:
Debuggers and profilers will only show the last source line to appear
Annotated POD for L<threads>:
L<http://annocpan.org/?mode=search&field=Module&name=threads>
-Lastest version of L<threads> on CPAN:
+Latest version of L<threads> on CPAN:
L<http://search.cpan.org/search?module=threads>
Annotated POD for L<threads::shared>:
L<http://annocpan.org/?mode=search&field=Module&name=threads%3A%3Ashared>
-Lastest version of L<threads::shared> on CPAN:
+Latest version of L<threads::shared> on CPAN:
L<http://search.cpan.org/search?module=threads%3A%3Ashared>
Perl threads mailing list:
told is something Perl is good at. So it would be nice to know what it is doing
that is taking so much CPU, and where possible address it.
-=head2 enable lexical enabling/disabling of inidvidual warnings
+=head2 enable lexical enabling/disabling of individual warnings
Currently, warnings can only be enabled or disabled by category. There
are times when it would be useful to quash a single warning, not a
Currently C<$foo ~~ $object> will die with the message "Smart matching a
non-overloaded object breaks encapsulation". It would be nice to allow
-to bypass this by using explictly the syntax C<$foo ~~ %$object> or
+to bypass this by using explicitly the syntax C<$foo ~~ %$object> or
C<$foo ~~ @$object>.
=head2 error reporting of [$a ; $b]
The world's languages are written in a number of scripts. This sentence
(unless you're reading it in translation) is written in Latin, while Russian is
-written in Cyrllic, and Greek is written in, well, Greek; Japanese mainly in
+written in Cyrillic, and Greek is written in, well, Greek; Japanese mainly in
Hiragana or Katakana. There are many more.
The Unicode Script property gives what script a given character is in,
such as MMK or MMS may generate a filename in all upper case even on an
ODS-5 volume. If this filename is later retrieved by a Perl script or
module in a case preserving environment, that upper case name may not
-match the mixed-case or lower-case expections of the Perl code. Your
+match the mixed-case or lower-case exceptions of the Perl code. Your
best bet is to follow an all-or-nothing approach to case preservation:
either don't use it at all, or make sure your entire toolchain and
application environment support and use it.
OpenVMS Alpha v7.3-1 and later and all version of OpenVMS I64 support
case sensitivity as a process setting (see C<SET PROCESS
-/CASE_LOOKUP=SENSITIVE>). Perl does not currently suppport case
+/CASE_LOOKUP=SENSITIVE>). Perl does not currently support case
sensitivity on VMS, but it may in the future, so Perl programs should
use the C<< File::Spec->case_tolerant >> method to determine the state, and
not the C<$^O> variable.
improvements in the POSIX exit handling.
In general, with C<PERL_VMS_POSIX_EXIT> enabled, more detailed information
-will be availble in the exit status for DCL scripts or other native VMS tools,
+will be available in the exit status for DCL scripts or other native VMS tools,
and will give the expected information for Posix programs. It has not been
made the default in order to preserve backward compatibility.
projects / platform / upstream / perl.git / commitdiff