Changes for version 5.20.0
- If you are upgrading from an earlier release such as 5.16.0, first read L<perl5180delta>, which describes differences between 5.16.0 and 5.18.0.
- =head1 Core Enhancements
- =head2 Experimental Subroutine signatures
- Declarative syntax to unwrap argument list into lexical variables. C<sub foo ($a,$b) {...}> checks the number of arguments and puts the arguments into lexical variables. Signatures are not equivalent to the existing idiom of C<sub foo { my($a,$b) = @_; ... }>. Signatures are only available by enabling a non-default feature, and generate warnings about being experimental. The syntactic clash with prototypes is managed by disabling the short prototype syntax when signatures are enabled.
- See L<perlsub/Signatures> for details.
- =head2 C<sub>s now take a C<prototype> attribute
- When declaring or defining a C<sub>, the prototype can now be specified inside of a C<prototype> attribute instead of in parens following the name.
- For example, C<sub foo($$){}> could be rewritten as C<sub foo : prototype($$){}>.
- =head2 More consistent prototype parsing
- Multiple semicolons in subroutine prototypes have long been tolerated and treated as a single semicolon. There was one case where this did not happen. A subroutine whose prototype begins with "*" or ";*" can affect whether a bareword is considered a method name or sub call. This now applies also to ";;;*".
- Whitespace has long been allowed inside subroutine prototypes, so C<sub( $ $ )> is equivalent to C<sub($$)>, but until now it was stripped when the subroutine was parsed. Hence, whitespace was I<not> allowed in prototypes set by C<Scalar::Util::set_prototype>. Now it is permitted, and the parser no longer strips whitespace. This means C<prototype &mysub> returns the original prototype, whitespace and all.
- =head2 C<rand> now uses a consistent random number generator
- Previously perl would use a platform specific random number generator, varying between the libc rand(), random() or drand48().
- This meant that the quality of perl's random numbers would vary from platform to platform, from the 15 bits of rand() on Windows to 48-bits on POSIX platforms such as Linux with drand48().
- Perl now uses its own internal drand48() implementation on all platforms. This does not make perl's C<rand> cryptographically secure. [perl #115928]
- =head2 New slice syntax
- The new C<%hash{...}> and C<%array[...]> syntax returns a list of key/value (or index/value) pairs. See L<perldata/"Key/Value Hash Slices">.
- =head2 Experimental Postfix Dereferencing
- When the C<postderef> feature is in effect, the following syntactical equivalencies are set up:
- $sref->$*; # same as ${ $sref } # interpolates $aref->@*; # same as @{ $aref } # interpolates $href->%*; # same as %{ $href } $cref->&*; # same as &{ $cref } $gref->**; # same as *{ $gref }
- $aref->$#*; # same as $#{ $aref }
- $gref->*{ $slot }; # same as *{ $gref }{ $slot }
- $aref->@[ ... ]; # same as @$aref[ ... ] # interpolates $href->@{ ... }; # same as @$href{ ... } # interpolates $aref->%[ ... ]; # same as %$aref[ ... ] $href->%{ ... }; # same as %$href{ ... }
- Those marked as interpolating only interpolate if the associated C<postderef_qq> feature is also enabled. This feature is B<experimental> and will trigger C<experimental::postderef>-category warnings when used, unless they are suppressed.
- For more information, consult L<the Postfix Dereference Syntax section of perlref|perlref/Postfix Dereference Syntax>.
- =head2 Unicode 6.3 now supported
- Perl now supports and is shipped with Unicode 6.3 (though Perl may be recompiled with any previous Unicode release as well). A detailed list of Unicode 6.3 changes is at L<http://www.unicode.org/versions/Unicode6.3.0/>.
- =head2 New C<\p{Unicode}> regular expression pattern property
- This is a synonym for C<\p{Any}> and matches the set of Unicode-defined code points 0 - 0x10FFFF.
- =head2 Better 64-bit support
- On 64-bit platforms, the internal array functions now use 64-bit offsets, allowing Perl arrays to hold more than 2**31 elements, if you have the memory available.
- The regular expression engine now supports strings longer than 2**31 characters. [perl #112790, #116907]
- The functions PerlIO_get_bufsiz, PerlIO_get_cnt, PerlIO_set_cnt and PerlIO_set_ptrcnt now have SSize_t, rather than int, return values and parameters.
- =head2 C<S<use locale>> now works on UTF-8 locales
- Until this release, only single-byte locales, such as the ISO 8859 series were supported. Now, the increasingly common multi-byte UTF-8 locales are also supported. A UTF-8 locale is one in which the character set is Unicode and the encoding is UTF-8. The POSIX C<LC_CTYPE> category operations (case changing (like C<lc()>, C<"\U">), and character classification (C<\w>, C<\D>, C<qr/[[:punct:]]/>)) under such a locale work just as if not under locale, but instead as if under C<S<use feature 'unicode_strings'>>, except taint rules are followed. Sorting remains by code point order in this release. [perl #56820].
- =head2 C<S<use locale>> now compiles on systems without locale ability
- Previously doing this caused the program to not compile. Within its scope the program behaves as if in the "C" locale. Thus programs written for platforms that support locales can run on locale-less platforms without change. Attempts to change the locale away from the "C" locale will, of course, fail.
- =head2 More locale initialization fallback options
- If there was an error with locales during Perl start-up, it immediately gave up and tried to use the C<"C"> locale. Now it first tries using other locales given by the environment variables, as detailed in L<perllocale/ENVIRONMENT>. For example, if C<LC_ALL> and C<LANG> are both set, and using the C<LC_ALL> locale fails, Perl will now try the C<LANG> locale, and only if that fails, will it fall back to C<"C">. On Windows machines, Perl will try, ahead of using C<"C">, the system default locale if all the locales given by environment variables fail.
- =head2 C<-DL> runtime option now added for tracing locale setting
- This is designed for Perl core developers to aid in field debugging bugs regarding locales.
- =head2 B<-F> now implies B<-a> and B<-a> implies B<-n>
- Previously B<-F> without B<-a> was a no-op, and B<-a> without B<-n> or B<-p> was a no-op, with this change, if you supply B<-F> then both B<-a> and B<-n> are implied and if you supply B<-a> then B<-n> is implied.
- You can still use B<-p> for its extra behaviour. [perl #116190]
- =head2 $a and $b warnings exemption
- The special variables $a and $b, used in C<sort>, are now exempt from "used once" warnings, even where C<sort> is not used. This makes it easier for CPAN modules to provide functions using $a and $b for similar purposes.
- perl #120462
- =head1 Security
- =head2 Avoid possible read of free()d memory during parsing
- It was possible that free()d memory could be read during parsing in the unusual circumstance of the Perl program ending with a heredoc and the last line of the file on disk having no terminating newline character. This has now been fixed.
- =head1 Incompatible Changes
- =head2 C<do> can no longer be used to call subroutines
- The C<do SUBROUTINE(LIST)> form has resulted in a deprecation warning since Perl v5.0.0, and is now a syntax error.
- =head2 Quote-like escape changes
- The character after C<\c> in a double-quoted string ("..." or qq(...)) or regular expression must now be a printable character and may not be C<{>.
- A literal C<{> after C<\B> or C<\b> is now fatal.
- These were deprecated in perl v5.14.0.
- =head2 Tainting happens under more circumstances; now conforms to documentation
- This affects regular expression matching and changing the case of a string (C<lc>, C<"\U">, I<etc>.) within the scope of C<use locale>. The result is now tainted based on the operation, no matter what the contents of the string were, as the documentation (L<perlsec>, L<perllocale/SECURITY>) indicates it should. Previously, for the case change operation, if the string contained no characters whose case change could be affected by the locale, the result would not be tainted. For example, the result of C<uc()> on an empty string or one containing only above-Latin1 code points is now tainted, and wasn't before. This leads to more consistent tainting results. Regular expression patterns taint their non-binary results (like C<$&>, C<$2>) if and only if the pattern contains elements whose matching depends on the current (potentially tainted) locale. Like the case changing functions, the actual contents of the string being matched now do not matter, whereas formerly it did. For example, if the pattern contains a C<\w>, the results will be tainted even if the match did not have to use that portion of the pattern to succeed or fail, because what a C<\w> matches depends on locale. However, for example, a C<.> in a pattern will not enable tainting, because the dot matches any single character, and what the current locale is doesn't change in any way what matches and what doesn't.
- =head2 C<\p{}>, C<\P{}> matching has changed for non-Unicode code points.
- C<\p{}> and C<\P{}> are defined by Unicode only on Unicode-defined code points (C<U+0000> through C<U+10FFFF>). Their behavior on matching these legal Unicode code points is unchanged, but there are changes for code points C<0x110000> and above. Previously, Perl treated the result of matching C<\p{}> and C<\P{}> against these as C<undef>, which translates into "false". For C<\P{}>, this was then complemented into "true". A warning was supposed to be raised when this happened. However, various optimizations could prevent the warning, and the results were often counter-intuitive, with both a match and its seeming complement being false. Now all non-Unicode code points are treated as typical unassigned Unicode code points. This generally is more Do-What-I-Mean. A warning is raised only if the results are arguably different from a strict Unicode approach, and from what Perl used to do. Code that needs to be strictly Unicode compliant can make this warning fatal, and then Perl always raises the warning.
- Details are in L<perlunicode/Beyond Unicode code points>.
- =head2 C<\p{All}> has been expanded to match all possible code points
- The Perl-defined regular expression pattern element C<\p{All}>, unused on CPAN, used to match just the Unicode code points; now it matches all possible code points; that is, it is equivalent to C<qr/./s>. Thus C<\p{All}> is no longer synonymous with C<\p{Any}>, which continues to match just the Unicode code points, as Unicode says it should.
- =head2 Data::Dumper's output may change
- Depending on the data structures dumped and the settings set for Data::Dumper, the dumped output may have changed from previous versions.
- If you have tests that depend on the exact output of Data::Dumper, they may fail.
- To avoid this problem in your code, test against the data structure from evaluating the dumped structure, instead of the dump itself.
- =head2 Locale decimal point character no longer leaks outside of S<C<use locale>> scope
- This is actually a bug fix, but some code has come to rely on the bug being present, so this change is listed here. The current locale that the program is running under is not supposed to be visible to Perl code except within the scope of a S<C<use locale>>. However, until now under certain circumstances, the character used for a decimal point (often a comma) leaked outside the scope. If your code is affected by this change, simply add a S<C<use locale>>.
- =head2 Assignments of Windows sockets error codes to $! now prefer F<errno.h> values over WSAGetLastError() values
- In previous versions of Perl, Windows sockets error codes as returned by WSAGetLastError() were assigned to $!, and some constants such as ECONNABORTED, not in F<errno.h> in VC++ (or the various Windows ports of gcc) were defined to corresponding WSAE* values to allow $! to be tested against the E* constants exported by L<Errno> and L<POSIX>.
- This worked well until VC++ 2010 and later, which introduced new E* constants with values E<gt> 100 into F<errno.h>, including some being (re)defined by perl to WSAE* values. That caused problems when linking XS code against other libraries which used the original definitions of F<errno.h> constants.
- To avoid this incompatibility, perl now maps WSAE* error codes to E* values where possible, and assigns those values to $!. The E* constants exported by L<Errno> and L<POSIX> are updated to match so that testing $! against them, wherever previously possible, will continue to work as expected, and all E* constants found in F<errno.h> are now exported from those modules with their original F<errno.h> values.
- In order to avoid breakage in existing Perl code which assigns WSAE* values to $!, perl now intercepts the assignment and performs the same mapping to E* values as it uses internally when assigning to $! itself.
- However, one backwards-incompatibility remains: existing Perl code which compares $! against the numeric values of the WSAE* error codes that were previously assigned to $! will now be broken in those cases where a corresponding E* value has been assigned instead. This is only an issue for those E* values E<lt> 100, which were always exported from L<Errno> and L<POSIX> with their original F<errno.h> values, and therefore could not be used for WSAE* error code tests (e.g. WSAEINVAL is 10022, but the corresponding EINVAL is 22). (E* values E<gt> 100, if present, were redefined to WSAE* values anyway, so compatibility can be achieved by using the E* constants, which will work both before and after this change, albeit using different numeric values under the hood.)
- =head2 Functions C<PerlIO_vsprintf> and C<PerlIO_sprintf> have been removed
- These two functions, undocumented, unused in CPAN, and problematic, have been removed.
- =head1 Deprecations
- =head2 The C</\C/> character class
- The C</\C/> regular expression character class is deprecated. From perl
Documentation
README for the Porting/ directory in the Perl 5 core distribution.
use git bisect to pinpoint changes
Check that all the URLs in the Perl source are valid
Check source code for ANSI-C violations
list of Perl release epigraphs
expand C macros using the C preprocessor
Annotate commits for perldelta
How to write a perldelta
Notes on handling the Perl Patch Pumpkin And Porting Perl
Releasing a new version of perl 5.x
Perl 5 release schedule
Sort warning and error messages in perldiag.pod
Perl TO-DO list
A post processor for make test.valgrind
autogenerated documentation for the perl public API
access Perl configuration information
manipulate @INC at compile time
Dynamically load C libraries into Perl code
System errno constants
Group Perl's functions a la perlfunc.pod
Test Pod::Functions
convert .pod files to .html files
Test Pod::Html::anchorify()
Test HTML cross reference links
Test --htmldir feature
Test --htmldir feature
Test --htmldir feature
Test --htmldir feature
Test --htmldir feature
Test HTML links
Plain Old Documentation: format specification and notes
Perl predefined variables
converts a collection of POD pages to HTML format.
Namespace for Perl's core routines
The tests for Pod::InputObjects
Tests for Pod::Select.
Tests for Pod::Usage
the perl debugger
make patchnum
distribute ppport.h among extensions
The Perl 5 language interpreter
what's new for perl5.004
what's new for perl5.005
what is new for perl 5.10.0
what is new for perl v5.10.1
what is new for perl v5.12.0
what is new for perl v5.12.1
what is new for perl v5.12.2
what is new for perl v5.12.3
what is new for perl v5.12.4
what is new for perl v5.12.5
what is new for perl v5.14.0
what is new for perl v5.14.1
what is new for perl v5.14.2
what is new for perl v5.14.3
what is new for perl v5.14.4
what is new for perl v5.16.0
what is new for perl v5.16.1
what is new for perl v5.16.2
what is new for perl v5.16.3
what is new for perl v5.18.0
what is new for perl v5.18.1
what is new for perl v5.18.2
what's new for perl v5.6.1
what's new for perl v5.6.0
what is new for perl v5.8.1
what is new for perl v5.8.2
what is new for perl v5.8.3
what is new for perl v5.8.4
what is new for perl v5.8.5
what is new for perl v5.8.6
what is new for perl v5.8.7
what is new for perl v5.8.8
what is new for perl v5.8.9
what is new for perl v5.8.0
perl's IO abstraction interface.
the Perl Artistic License
Books about and related to Perl
Links to information on object-oriented programming in Perl
Links to information on object-oriented programming in Perl
Perl calling conventions from C
Perl 5 Cheat Sheet
Internal replacements for standard C library functions
a brief overview of the Perl community
Perl data types
Perl DBM Filters
Guts of Perl debugging
Perl debugging tutorial
Perl debugging
what is new for perl v5.20.0
various Perl diagnostics
Perl Data Structures Cookbook
Perl's support for DTrace
Considerations for running Perl on EBCDIC platforms
how to embed perl in your C program
A listing of experimental features in Perl
Source Filters
Perl's fork() emulation
Perl formats
Perl builtin functions
Detailed information about git and the Perl repository
the GNU General Public License, version 1
Introduction to the Perl API
How to hack on Perl
Tips for Perl core C code hacking
Walk through the creation of a simple C code patch
the Perl history records
An overview of the Perl interpreter
a brief introduction and overview of Perl
C API for Perl's implementation of IO in Layers.
Perl interprocess communication (signals, fifos, pipes, safe subprocesses, sockets, and semaphores)
Perl Lexical Warnings
Perl locale handling (internationalization and localization)
Manipulating Arrays of Arrays in Perl
Perl modules (packages and symbol tables)
Installing CPAN Modules
constructing new Perl modules and finding existing ones
Perl module style guide
Perl method resolution plugin interface
preparing a new module for distribution
semantics of numbers and numeric operations in Perl
Perl object reference
Object-Oriented Programming in Perl Tutorial
Perl operators and precedence
simple recipes for opening files and pipes in Perl
tutorial on pack and unpack
Perl Performance and Optimization Techniques
the Plain Old Documentation format
Plain Old Documentation: format specification and notes
Perl POD style guide
Various and sundry policies and commitments related to the Perl core
Writing portable Perl
how to write a user pragma
Perl regular expressions
Perl regular expression plugin interface
Perl Regular Expression Backslash Sequences and Escapes
Perl Regular Expression Character Classes
Perl references and nested data structures
Mark's very short tutorial about references
Description of the Perl regular expression engine.
Links to current information on the Perl source repository
Perl regular expressions quick start
Perl Regular Expressions Reference
Perl regular expressions tutorial
how to execute the Perl interpreter
Perl security
A guide to the Perl source tree
Perl style guide
Perl subroutines
Perl syntax
Tutorial on threads in Perl
how to hide an object class in a simple variable
Link to the Perl to-do list
Links to information on object-oriented programming in Perl
Links to information on object-oriented programming in Perl
Perl traps for the unwary
Unicode support in Perl
Perl Unicode FAQ
Perl Unicode introduction
Perl Unicode Tutorial
utilities packaged with the Perl distribution
Perl predefined variables
VMS-specific documentation for Perl
Perl pragma to enable new features
Generate C macros that match character classes efficiently
Perl pragma to control optional warnings
a C++ base class encapsulating a Perl interpreter in Symbian
a C++ utility class for Perl/Symbian
convert .h C header files to .ph Perl header files
convert .h C header files to Perl extensions
configure libnet
how to submit bug reports on Perl
Perl Installation Verification Procedure
Rough tool to translate Perl4 .pl files to Perl5 .pm modules.
Awk to Perl translator
translate find command lines to Perl code
a stream editor
Modules
functions for dealing with RFC3066-style language tags
detect the user's language preferences
tags and names for human languages
load various IO modules
supply object methods for directory handles
supply object methods for filehandles
supply object methods for I/O handles
supply object methods for pipes
Object interface to system poll call
supply seek based methods for I/O objects
OO interface to the select system call
Object interface to socket communications
Object interface for AF_INET domain sockets
Object interface for AF_UNIX domain sockets
The Perl Compiler Backend
Walk Perl syntax tree, printing concise info about ops
Show lexical variables used in functions or files
Walk Perl syntax tree, printing terse info about ops
Generates cross reference reports for Perl programs
Generic interface to Perl Compiler backends
check optrees as rendered by B::Concise
A data debugging tool for the XS programmer
write the C code for perlmain.c
load the C Fcntl.h defines
DOS like globbing and then some
Traverse a directory tree.
Perl extension for BSD glob routine
keep more files open than the system permits
Perl5 access to the gdbm library.
Support for Inside-Out Classes
A selection of general-utility hash subroutines
query locale information
open a process for both reading and writing using open2()
open a process for reading, writing, and error handling using open3()
Tied access to ndbm files
Tied access to odbm files
Disable named opcodes when compiling perl code
Perl pragma to restrict unsafe operations when compiling
Perl interface to IEEE Std 1003.1
encoding layer
Memory mapped IO
in-memory IO, scalar IO
Helper class for PerlIO layers implemented in perl
module to convert pod files to HTML
Tied access to sdbm files
Try every conceivable way to get hostname
Named regexp capture buffers
add data to hash when needed
Perl extension to manipulate DCL symbols
convert between VMS and Unix file specification syntax
standard I/O functions via VMS extensions
Win32 CORE function stubs
Test the perl C API
module to test the XS typemaps distributed with perl
Set indexing base via $[
get/set subroutine or variable attributes
Method Resolution Order
Perl pragma to alter regular expression behaviour
Interfaces to some Haiku API Functions
provide framework for multiple DBMs
Perl compiler backend to produce perl code
benchmark running times of Perl code
declare struct-like datatypes as Perl classes
hash lookup of which core extensions were built.
programmatic interface to the Perl debugging API
Filter DBM keys/values
filter for DBM_Filter
filter for DBM_Filter
filter for DBM_Filter
filter for DBM_Filter
filter for DBM_Filter
supply object methods for directory handles
use nice English (or awk) names for ugly punctuation variables
Utilities for embedding Perl in C/C++ applications
keep sets of symbol names palatable to the VMS linker
Parse file paths into directory, filename and suffix.
Compare files or filehandles
Copy files or filehandles
by-name interface to Perl's built-in stat() functions
supply object methods for filehandles
Locate directory of original perl script
by-name interface to Perl's built-in gethost*() functions
by-name interface to Perl's built-in getnet*() functions
by-name interface to Perl's built-in getproto*() functions
by-name interface to Perl's built-in getserv*() functions
On demand loader for PerlIO layers and root of PerlIO::* name space
save and restore selected file handle
manipulate Perl symbols and their names
Manipulate threads in Perl (for old code only)
base class for tied arrays
base class definitions for tied handles
base class definitions for tied handles
Fixed-table-size, fixed-key-length hashing
by-name interface to Perl's built-in gmtime() function
by-name interface to Perl's built-in localtime() function
internal object used by Time::gmtime and Time::localtime
base class for ALL classes (blessed references)
Unicode character database
by-name interface to Perl's built-in getgr*() functions
by-name interface to Perl's built-in getpw*() functions
Use MakeMaker's uninstalled version of a package
Perl pragma to force byte semantics rather than character semantics
access to Unicode character names and named character sequences; also define character names
Perl pragma for deprecating the core version of a module
Perl pragma to enable new features
Perl pragma to control the filetest permission operators
Perl pragma to use integer arithmetic instead of floating point
perl pragma to request less of something
Perl pragma to use or avoid POSIX locales for built-in operations
perl pragma to set default PerlIO layers for input and output
Package for overloading Perl operations
perl pragma to lexically control overloading
Perl pragma to enable simple signal handling
perl pragma to control sort() behaviour
Perl pragma to restrict unsafe constructs
Perl pragma to predeclare sub names
Perl pragma to enable/disable UTF-8 (or UTF-EBCDIC) in source code
Perl pragma to predeclare global variable names
Perl pragma to control VMS-specific language features
Perl pragma to control optional warnings
warnings import function
Perl access to extended attributes.
Perl extension for access to OS/2 setting database.
exports constants for system() call, and process control on OS2.
access to DLLs with REXX calling convention.
access to DLLs with REXX calling convention and REXX runtime.
Provides
in ext/B/B.pm
in ext/B/B.pm
in lib/Class/Struct.pm
in lib/perl5db/t/EnableModule.pm
in lib/Getopt/Std.pm
in symbian/ext/Moped/Msg/Msg.pm
in lib/perl5db/t/MyModule.pm
in os2/OS2/OS2-REXX/DLL/DLL.pm
in os2/OS2/OS2-PrfDB/PrfDB.pm
in os2/OS2/OS2-PrfDB/PrfDB.pm
in os2/OS2/OS2-REXX/REXX.pm
in os2/OS2/OS2-REXX/REXX.pm
in os2/OS2/OS2-REXX/REXX.pm
in os2/OS2/OS2-Process/Process.pm
in ext/POSIX/lib/POSIX.pm
in ext/POSIX/lib/POSIX.pm
in ext/POSIX/lib/POSIX.pm
in ext/Pod-Html/lib/Pod/Html.pm
in ext/File-Find/t/lib/Testing.pm
in lib/Tie/Hash.pm
in lib/DBM_Filter.pm
in lib/Tie/Hash.pm
in lib/Tie/Scalar.pm
in lib/Tie/Array.pm
in lib/Tie/Hash.pm
in lib/Tie/Scalar.pm
in ext/VMS-Stdio/Stdio.pm
in lib/diagnostics.pm
in lib/overload/numbers.pm
in ext/XS-APItest/t/BHK.pm
in ext/XS-APItest/t/Markers.pm
Other files
- AUTHORS
- MANIFEST
- META.json
- META.yml
- Porting/acknowledgements.pl
- Porting/bisect.pl
- Porting/corelist-perldelta.pl
- Porting/newtests-perldelta.pl
- Porting/pod_lib.pl
- Porting/sync-with-cpan
- README
- dist/Attribute-Handlers/demo/demo.pl
- dist/Attribute-Handlers/demo/demo2.pl
- dist/Attribute-Handlers/demo/demo3.pl
- dist/Attribute-Handlers/demo/demo4.pl
- dist/Attribute-Handlers/demo/demo_call.pl
- dist/Attribute-Handlers/demo/demo_chain.pl
- dist/Attribute-Handlers/demo/demo_cycle.pl
- dist/Attribute-Handlers/demo/demo_hashdir.pl
- dist/Attribute-Handlers/demo/demo_phases.pl
- dist/Attribute-Handlers/demo/demo_range.pl
- dist/Attribute-Handlers/demo/demo_rawdata.pl
- ext/B/t/concise-xs.t
- ext/B/t/f_map.t
- ext/B/t/f_sort.t
- ext/B/t/optree_check.t
- ext/B/t/optree_constants.t
- symbian/TODO
- symbian/demo_pl
- utils/c2ph.PL