diff options
Diffstat (limited to 'Master/tlpkg/tlperl/lib/pods/perl595delta.pod')
| -rwxr-xr-x | Master/tlpkg/tlperl/lib/pods/perl595delta.pod | 587 |
1 files changed, 587 insertions, 0 deletions
diff --git a/Master/tlpkg/tlperl/lib/pods/perl595delta.pod b/Master/tlpkg/tlperl/lib/pods/perl595delta.pod new file mode 100755 index 00000000000..246b2cc7478 --- /dev/null +++ b/Master/tlpkg/tlperl/lib/pods/perl595delta.pod @@ -0,0 +1,587 @@ +=head1 NAME + +perl595delta - what is new for perl v5.9.5 + +=head1 DESCRIPTION + +This document describes differences between the 5.9.4 and the 5.9.5 +development releases. See L<perl590delta>, L<perl591delta>, +L<perl592delta>, L<perl593delta> and L<perl594delta> for the differences +between 5.8.0 and 5.9.4. + +=head1 Incompatible Changes + +=head2 Tainting and printf + +When perl is run under taint mode, C<printf()> and C<sprintf()> will now +reject any tainted format argument. (Rafael Garcia-Suarez) + +=head2 undef and signal handlers + +Undefining or deleting a signal handler via C<undef $SIG{FOO}> is now +equivalent to setting it to C<'DEFAULT'>. (Rafael) + +=head2 strictures and array/hash dereferencing in defined() + +C<defined @$foo> and C<defined %$bar> are now subject to C<strict 'refs'> +(that is, C<$foo> and C<$bar> shall be proper references there.) +(Nicholas Clark) + +(However, C<defined(@foo)> and C<defined(%bar)> are discouraged constructs +anyway.) + +=head2 C<(?p{})> has been removed + +The regular expression construct C<(?p{})>, which was deprecated in perl +5.8, has been removed. Use C<(??{})> instead. (Rafael) + +=head2 Pseudo-hashes have been removed + +Support for pseudo-hashes has been removed from Perl 5.9. (The C<fields> +pragma remains here, but uses an alternate implementation.) + +=head2 Removal of the bytecode compiler and of perlcc + +C<perlcc>, the byteloader and the supporting modules (B::C, B::CC, +B::Bytecode, etc.) are no longer distributed with the perl sources. Those +experimental tools have never worked reliably, and, due to the lack of +volunteers to keep them in line with the perl interpreter developments, it +was decided to remove them instead of shipping a broken version of those. +The last version of those modules can be found with perl 5.9.4. + +However the B compiler framework stays supported in the perl core, as with +the more useful modules it has permitted (among others, B::Deparse and +B::Concise). + +=head2 Removal of the JPL + +The JPL (Java-Perl Linguo) has been removed from the perl sources tarball. + +=head2 Recursive inheritance detected earlier + +Perl will now immediately throw an exception if you modify any package's +C<@ISA> in such a way that it would cause recursive inheritance. + +Previously, the exception would not occur until Perl attempted to make +use of the recursive inheritance while resolving a method or doing a +C<$foo-E<gt>isa($bar)> lookup. + +=head1 Core Enhancements + +=head2 Regular expressions + +=over 4 + +=item Recursive Patterns + +It is now possible to write recursive patterns without using the C<(??{})> +construct. This new way is more efficient, and in many cases easier to +read. + +Each capturing parenthesis can now be treated as an independent pattern +that can be entered by using the C<(?PARNO)> syntax (C<PARNO> standing for +"parenthesis number"). For example, the following pattern will match +nested balanced angle brackets: + + / + ^ # start of line + ( # start capture buffer 1 + < # match an opening angle bracket + (?: # match one of: + (?> # don't backtrack over the inside of this group + [^<>]+ # one or more non angle brackets + ) # end non backtracking group + | # ... or ... + (?1) # recurse to bracket 1 and try it again + )* # 0 or more times. + > # match a closing angle bracket + ) # end capture buffer one + $ # end of line + /x + +Note, users experienced with PCRE will find that the Perl implementation +of this feature differs from the PCRE one in that it is possible to +backtrack into a recursed pattern, whereas in PCRE the recursion is +atomic or "possessive" in nature. (Yves Orton) + +=item Named Capture Buffers + +It is now possible to name capturing parenthesis in a pattern and refer to +the captured contents by name. The naming syntax is C<< (?<NAME>....) >>. +It's possible to backreference to a named buffer with the C<< \k<NAME> >> +syntax. In code, the new magical hashes C<%+> and C<%-> can be used to +access the contents of the capture buffers. + +Thus, to replace all doubled chars, one could write + + s/(?<letter>.)\k<letter>/$+{letter}/g + +Only buffers with defined contents will be "visible" in the C<%+> hash, so +it's possible to do something like + + foreach my $name (keys %+) { + print "content of buffer '$name' is $+{$name}\n"; + } + +The C<%-> hash is a bit more complete, since it will contain array refs +holding values from all capture buffers similarly named, if there should +be many of them. + +C<%+> and C<%-> are implemented as tied hashes through the new module +C<Tie::Hash::NamedCapture>. + +Users exposed to the .NET regex engine will find that the perl +implementation differs in that the numerical ordering of the buffers +is sequential, and not "unnamed first, then named". Thus in the pattern + + /(A)(?<B>B)(C)(?<D>D)/ + +$1 will be 'A', $2 will be 'B', $3 will be 'C' and $4 will be 'D' and not +$1 is 'A', $2 is 'C' and $3 is 'B' and $4 is 'D' that a .NET programmer +would expect. This is considered a feature. :-) (Yves Orton) + +=item Possessive Quantifiers + +Perl now supports the "possessive quantifier" syntax of the "atomic match" +pattern. Basically a possessive quantifier matches as much as it can and never +gives any back. Thus it can be used to control backtracking. The syntax is +similar to non-greedy matching, except instead of using a '?' as the modifier +the '+' is used. Thus C<?+>, C<*+>, C<++>, C<{min,max}+> are now legal +quantifiers. (Yves Orton) + +=item Backtracking control verbs + +The regex engine now supports a number of special-purpose backtrack +control verbs: (*THEN), (*PRUNE), (*MARK), (*SKIP), (*COMMIT), (*FAIL) +and (*ACCEPT). See L<perlre> for their descriptions. (Yves Orton) + +=item Relative backreferences + +A new syntax C<\g{N}> or C<\gN> where "N" is a decimal integer allows a +safer form of back-reference notation as well as allowing relative +backreferences. This should make it easier to generate and embed patterns +that contain backreferences. See L<perlre/"Capture buffers">. (Yves Orton) + +=item C<\K> escape + +The functionality of Jeff Pinyan's module Regexp::Keep has been added to +the core. You can now use in regular expressions the special escape C<\K> +as a way to do something like floating length positive lookbehind. It is +also useful in substitutions like: + + s/(foo)bar/$1/g + +that can now be converted to + + s/foo\Kbar//g + +which is much more efficient. (Yves Orton) + +=item Vertical and horizontal whitespace, and linebreak + +Regular expressions now recognize the C<\v> and C<\h> escapes, that match +vertical and horizontal whitespace, respectively. C<\V> and C<\H> +logically match their complements. + +C<\R> matches a generic linebreak, that is, vertical whitespace, plus +the multi-character sequence C<"\x0D\x0A">. + +=back + +=head2 The C<_> prototype + +A new prototype character has been added. C<_> is equivalent to C<$> (it +denotes a scalar), but defaults to C<$_> if the corresponding argument +isn't supplied. Due to the optional nature of the argument, you can only +use it at the end of a prototype, or before a semicolon. + +This has a small incompatible consequence: the prototype() function has +been adjusted to return C<_> for some built-ins in appropriate cases (for +example, C<prototype('CORE::rmdir')>). (Rafael) + +=head2 UNITCHECK blocks + +C<UNITCHECK>, a new special code block has been introduced, in addition to +C<BEGIN>, C<CHECK>, C<INIT> and C<END>. + +C<CHECK> and C<INIT> blocks, while useful for some specialized purposes, +are always executed at the transition between the compilation and the +execution of the main program, and thus are useless whenever code is +loaded at runtime. On the other hand, C<UNITCHECK> blocks are executed +just after the unit which defined them has been compiled. See L<perlmod> +for more information. (Alex Gough) + +=head2 readpipe() is now overridable + +The built-in function readpipe() is now overridable. Overriding it permits +also to override its operator counterpart, C<qx//> (a.k.a. C<``>). +Moreover, it now defaults to C<$_> if no argument is provided. (Rafael) + +=head2 default argument for readline() + +readline() now defaults to C<*ARGV> if no argument is provided. (Rafael) + +=head2 UCD 5.0.0 + +The copy of the Unicode Character Database included in Perl 5.9 has +been updated to version 5.0.0. + +=head2 Smart match + +The smart match operator (C<~~>) is now available by default (you don't +need to enable it with C<use feature> any longer). (Michael G Schwern) + +=head2 Implicit loading of C<feature> + +The C<feature> pragma is now implicitly loaded when you require a minimal +perl version (with the C<use VERSION> construct) greater than, or equal +to, 5.9.5. + +=head1 Modules and Pragmas + +=head2 New Pragma, C<mro> + +A new pragma, C<mro> (for Method Resolution Order) has been added. It +permits to switch, on a per-class basis, the algorithm that perl uses to +find inherited methods in case of a multiple inheritance hierarchy. The +default MRO hasn't changed (DFS, for Depth First Search). Another MRO is +available: the C3 algorithm. See L<mro> for more information. +(Brandon Black) + +Note that, due to changes in the implementation of class hierarchy search, +code that used to undef the C<*ISA> glob will most probably break. Anyway, +undef'ing C<*ISA> had the side-effect of removing the magic on the @ISA +array and should not have been done in the first place. + +=head2 bignum, bigint, bigrat + +The three numeric pragmas C<bignum>, C<bigint> and C<bigrat> are now +lexically scoped. (Tels) + +=head2 Math::BigInt/Math::BigFloat + +Many bugs have been fixed; noteworthy are comparisons with NaN, which +no longer warn about undef values. + +The following things are new: + +=over 4 + +=item config() + +The config() method now also supports the calling-style +C<< config('lib') >> in addition to C<< config()->{'lib'} >>. + +=item import() + +Upon import, using C<< lib => 'Foo' >> now warns if the low-level library +cannot be found. To suppress the warning, you can use C<< try => 'Foo' >> +instead. To convert the warning into a die, use C<< only => 'Foo' >> +instead. + +=item roundmode common + +A rounding mode of C<common> is now supported. + +=back + +Also, support for the following methods has been added: + +=over 4 + +=item bpi(), bcos(), bsin(), batan(), batan2() + +=item bmuladd() + +=item bexp(), bnok() + +=item from_hex(), from_oct(), and from_bin() + +=item as_oct() + +=back + +In addition, the default math-backend (Calc (Perl) and FastCalc (XS)) now +support storing numbers in parts with 9 digits instead of 7 on Perls with +either 64bit integer or long double support. This means math operations +scale better and are thus faster for really big numbers. + +=head2 New Core Modules + +=over 4 + +=item * + +C<Locale::Maketext::Simple>, needed by CPANPLUS, is a simple wrapper around +C<Locale::Maketext::Lexicon>. Note that C<Locale::Maketext::Lexicon> isn't +included in the perl core; the behaviour of C<Locale::Maketext::Simple> +gracefully degrades when the later isn't present. + +=item * + +C<Params::Check> implements a generic input parsing/checking mechanism. It +is used by CPANPLUS. + +=item * + +C<Term::UI> simplifies the task to ask questions at a terminal prompt. + +=item * + +C<Object::Accessor> provides an interface to create per-object accessors. + +=item * + +C<Module::Pluggable> is a simple framework to create modules that accept +pluggable sub-modules. + +=item * + +C<Module::Load::Conditional> provides simple ways to query and possibly +load installed modules. + +=item * + +C<Time::Piece> provides an object oriented interface to time functions, +overriding the built-ins localtime() and gmtime(). + +=item * + +C<IPC::Cmd> helps to find and run external commands, possibly +interactively. + +=item * + +C<File::Fetch> provide a simple generic file fetching mechanism. + +=item * + +C<Log::Message> and C<Log::Message::Simple> are used by the log facility +of C<CPANPLUS>. + +=item * + +C<Archive::Extract> is a generic archive extraction mechanism +for F<.tar> (plain, gziped or bzipped) or F<.zip> files. + +=item * + +C<CPANPLUS> provides an API and a command-line tool to access the CPAN +mirrors. + +=back + +=head2 Module changes + +=over 4 + +=item C<assertions> + +The C<assertions> pragma, its submodules C<assertions::activate> and +C<assertions::compat> and the B<-A> command-line switch have been removed. +The interface was not judged mature enough for inclusion in a stable +release. + +=item C<base> + +The C<base> pragma now warns if a class tries to inherit from itself. +(Curtis "Ovid" Poe) + +=item C<strict> and C<warnings> + +C<strict> and C<warnings> will now complain loudly if they are loaded via +incorrect casing (as in C<use Strict;>). (Johan Vromans) + +=item C<warnings> + +The C<warnings> pragma doesn't load C<Carp> anymore. That means that code +that used C<Carp> routines without having loaded it at compile time might +need to be adjusted; typically, the following (faulty) code won't work +anymore, and will require parentheses to be added after the function name: + + use warnings; + require Carp; + Carp::confess "argh"; + +=item C<less> + +C<less> now does something useful (or at least it tries to). In fact, it +has been turned into a lexical pragma. So, in your modules, you can now +test whether your users have requested to use less CPU, or less memory, +less magic, or maybe even less fat. See L<less> for more. (Joshua ben +Jore) + +=item C<Attribute::Handlers> + +C<Attribute::Handlers> can now report the caller's file and line number. +(David Feldman) + +=item C<B::Lint> + +C<B::Lint> is now based on C<Module::Pluggable>, and so can be extended +with plugins. (Joshua ben Jore) + +=item C<B> + +It's now possible to access the lexical pragma hints (C<%^H>) by using the +method B::COP::hints_hash(). It returns a C<B::RHE> object, which in turn +can be used to get a hash reference via the method B::RHE::HASH(). (Joshua +ben Jore) + +=for p5p XXX document this in B.pm too + +=item C<Thread> + +As the old 5005thread threading model has been removed, in favor of the +ithreads scheme, the C<Thread> module is now a compatibility wrapper, to +be used in old code only. It has been removed from the default list of +dynamic extensions. + +=back + +=head1 Utility Changes + +=head2 C<cpanp> + +C<cpanp>, the CPANPLUS shell, has been added. (C<cpanp-run-perl>, an +helper for CPANPLUS operation, has been added too, but isn't intended for +direct use). + +=head2 C<cpan2dist> + +C<cpan2dist> is a new utility, that comes with CPANPLUS. It's a tool to +create distributions (or packages) from CPAN modules. + +=head2 C<pod2html> + +The output of C<pod2html> has been enhanced to be more customizable via +CSS. Some formatting problems were also corrected. (Jari Aalto) + +=head1 Documentation + +=head2 New manpage, perlunifaq + +A new manual page, L<perlunifaq> (the Perl Unicode FAQ), has been added +(Juerd Waalboer). + +=head1 Installation and Configuration Improvements + +=head2 C++ compatibility + +Efforts have been made to make perl and the core XS modules compilable +with various C++ compilers (although the situation is not perfect with +some of the compilers on some of the platforms tested.) + +=head2 Visual C++ + +Perl now can be compiled with Microsoft Visual C++ 2005. + +=head2 Static build on Win32 + +It's now possible to build a C<perl-static.exe> that doesn't depend +on C<perl59.dll> on Win32. See the Win32 makefiles for details. +(Vadim Konovalov) + +=head2 win32 builds + +All win32 builds (MS-Win, WinCE) have been merged and cleaned up. + +=head2 C<d_pseudofork> and C<d_printf_format_null> + +A new configuration variable, available as C<$Config{d_pseudofork}> in +the L<Config> module, has been added, to distinguish real fork() support +from fake pseudofork used on Windows platforms. + +A new configuration variable, C<d_printf_format_null>, has been added, +to see if printf-like formats are allowed to be NULL. + +=head2 Help + +C<Configure -h> has been extended with the most used option. + +Much less 'Whoa there' messages. + +=head2 64bit systems + +Better detection of 64bit(only) systems, and setting all the (library) +paths accordingly. + +=head2 Ports + +Perl has been reported to work on MidnightBSD. + +Support for Cray XT4 Catamount/Qk has been added. + +Vendor patches have been merged for RedHat and GenToo. + +=head1 Selected Bug Fixes + +PerlIO::scalar will now prevent writing to read-only scalars. Moreover, +seek() is now supported with PerlIO::scalar-based filehandles, the +underlying string being zero-filled as needed. (Rafael, Jarkko Hietaniemi) + +study() never worked for UTF-8 strings, but could lead to false results. +It's now a no-op on UTF-8 data. (Yves Orton) + +The signals SIGILL, SIGBUS and SIGSEGV are now always delivered in an +"unsafe" manner (contrary to other signals, that are deferred until the +perl interpreter reaches a reasonably stable state; see +L<perlipc/"Deferred Signals (Safe Signals)">). (Rafael) + +When a module or a file is loaded through an @INC-hook, and when this hook +has set a filename entry in %INC, __FILE__ is now set for this module +accordingly to the contents of that %INC entry. (Rafael) + +The C<-w> and C<-t> switches can now be used together without messing +up what categories of warnings are activated or not. (Rafael) + +Duping a filehandle which has the C<:utf8> PerlIO layer set will now +properly carry that layer on the duped filehandle. (Rafael) + +Localizing an hash element whose key was given as a variable didn't work +correctly if the variable was changed while the local() was in effect (as +in C<local $h{$x}; ++$x>). (Bo Lindbergh) + +=head1 New or Changed Diagnostics + +=head2 Deprecations + +Two deprecation warnings have been added: (Rafael) + + Opening dirhandle %s also as a file + Opening filehandle %s also as a directory + +=head1 Changed Internals + +The anonymous hash and array constructors now take 1 op in the optree +instead of 3, now that pp_anonhash and pp_anonlist return a reference to +an hash/array when the op is flagged with OPf_SPECIAL (Nicholas Clark). + +=for p5p XXX have we some docs on how to create regexp engine plugins, since that's now possible ? (perlreguts) + +=for p5p XXX new BIND SV type, #29544, #29642 + +=head1 Reporting Bugs + +If you find what you think is a bug, you might check the articles +recently posted to the comp.lang.perl.misc newsgroup and the perl +bug database at http://rt.perl.org/rt3/ . There may also be +information at http://www.perl.org/ , the Perl Home Page. + +If you believe you have an unreported bug, please run the B<perlbug> +program included with your release. Be sure to trim your bug down +to a tiny but sufficient test case. Your bug report, along with the +output of C<perl -V>, will be sent off to perlbug@perl.org to be +analysed by the Perl porting team. + +=head1 SEE ALSO + +The F<Changes> file for exhaustive details on what changed. + +The F<INSTALL> file for how to build Perl. + +The F<README> file for general stuff. + +The F<Artistic> and F<Copying> files for copyright information. + +=cut |