The Devel::StackTrace module contains two classes, Devel::StackTrace and
Devel::StackTraceFrame. The goal of this object is to encapsulate the
information that can found through using the caller() function, as well
as providing a simple interface to this data.

The Devel::StackTrace object contains a set of Devel::StackTraceFrame
objects, one for each level of the stack. The frames contain all the
data available from "caller()".

This code was created to support my Exception::Class::Base class (part
of Exception::Class) but may be useful in other contexts.

Authors: Dave Rolsky,

Devel::Symdump is a Perl module that provides a convenient way to
inspect Perl's symbol table and the class hierarchy within a running
program.

HMAC is used for message integrity checks between two parties that
share a secret key. HMAC works in combination with another Digest
algorithm, usually MD5 or SHA-1. The HMAC mechanism is described in RFC
2104.

Perl interface to the RSA Data Security Inc. MD4 Message-Digest
Algorithm.

The Digest::SHA1 module allows the use of the NIST SHA-1 message digest
algorithm from within Perl programs. The algorithm takes a message of
arbitrary length as input and produces a 160-bit fingerprint or message
digest of the input as output.

One shortcoming of the CPAN clients that currently exist is that they have no way of specifying conflicting downstream dependencies of modules. This module attempts to work around this issue by allowing you to specify conflicting versions of modules separately, and deal with them after the module is done installing.

For instance, say you have a module 'Foo', and some other module 'Bar' uses 'Foo'. If 'Foo' were to change its API in a non-backwards-compatible way, this would cause 'Bar' to break until it is updated to use the new API. 'Foo' can't just depend on the fixed version of 'Bar', because this will cause a circular dependency (because 'Bar' is already depending on 'Foo'), and this doesn't express intent properly anyway - 'Foo' doesn't use 'Bar' at all. The ideal solution would be for there to be a way to specify conflicting versions of modules in a way that would let CPAN clients update conflicting modules automatically after an existing module is upgraded, but until that happens, this module will allow users to do this manually.

This Perl module is an Encode::Encoding subclass that uses
Encode::Detect::Detector to determine the charset of the input data and then
decodes it using the encoder of the detected charset.

It is similar to Encode::Guess, but does not require the configuration of a set
of expected encodings. Like Encode::Guess, it only supports decoding--it cannot
encode.

Authors:
--------
John Gardiner Myers

Perl 5.7.3 and later ships with an adequate set of Chinese encodings,
including the most used CP950, CP936 (also known as GBK), Big5,
Big5-HKSCS, EUC-CN, HZ, and ISO-IR-165.

However, the numbers of Chinese encodings are staggering, and a
complete coverage will easily increase the size of perl distribution by
several megabytes; hence, this CPAN module tries to provide the rest of
them.

NOTE: Automatically created during Factory devel project migration by admin.

In many applications it's wise to let Perl use Unicode for the strings it
processes. Most of the interfaces Perl has to the outside world is still
byte based. Programs therefore needs to decode byte strings that enter the
program from the outside and encode them again on the way out.

The POSIX locale system is used to specify both the language conventions
requested by the user and the preferred character set to consume and
output. The 'Encode::Locale' module looks up the charset and encoding
(called a CODESET in the locale jargon) and arrange for the the Encode
manpage module to know this encoding under the name "locale". It means
bytes obtained from the environment can be converted to Unicode strings by
calling 'Encode::encode(locale => $bytes)' and converted back again with
'Encode::decode(locale => $string)'.

Where file systems interfaces pass file names in and out of the program we
also need care. The trend is for operating systems to use a fixed file
encoding that don't actually depend on the locale; and this module
determines the most appropriate encoding for file names. The the Encode
manpage module will know this encoding under the name "locale_fs". For
traditional Unix systems this will be an alias to the same encoding as
"locale".

For programs running in a terminal window (called a "Console" on some
systems) the "locale" encoding is usually a good choice for what to expect
as input and output. Some systems allows us to query the encoding set for
the terminal and 'Encode::Locale' will do that if available and make these
encodings known under the 'Encode' aliases "console_in" and "console_out".
For systems where we can't determine the terminal encoding these will be
aliased as the same encoding as "locale". The advice is to use "console_in"
for input known to come from the terminal and "console_out" for output
known to go from the terminal.

This package two interfaces. Firstly Error provides a procedural
interface to exception handling. Secondly Error is a base class for
errors/exceptions that can either be thrown (for subsequent catch) or
simply be recorded.

Exception::Class allows you to declare exception hierarchies in your modules in
a "Java-esque" manner.

It features a simple interface allowing programmers to 'declare' exception
classes at compile time. It also has a base exception class,
Exception::Class::Base, that can be easily extended.

It is designed to make structured exception handling simpler and better by
encouraging people to use hierarchies of exceptions in their applications,
as opposed to a single catch-all exception class.

This module does not implement any try/catch syntax. Please see the
"OTHER EXCEPTION MODULES (try/catch syntax)" section for more information on
how to get this syntax.

You will also want to look at the documentation for Exception::Class::Base,
which is the default base class for all exception objects created
by this module.

Author: Dave Rolsky

This module tries to make it easy to build Perl extensions that use
functions and typemaps provided by other perl extensions. This means
that a perl extension is treated like a shared library that provides
also a C and an XS interface besides the perl one. This works as long
as the base extension is loaded with the RTLD_GLOBAL flag (usually done
with a sub dl_load_flags {0x01} in the main .pm file) if you need to
use functions defined in the module.

Module::Build is the official heir apparent to MakeMaker and we encourage people to work on M::B rather than spending time adding features to MakeMaker.

This is here just to fulfil a dependency in Jifty.

This module is a simplistic Perl interface to the pkg-config
command-line utility, for use in the Makefile.PLs used to build Perl
modules which wrap the libraries about which pkg-config knows.

Perl extension for recursively copying files and directories.

File::Find::Rule is a friendlier interface to File::Find. It allows you to build rules which specify the desired files and directories.

This module exports a single function called parse_dir(), which can be used
to parse directory listings.

This module provides subs that allow you to read or write entire files with one
simple call. They are designed to be simple to use, have flexible ways to pass
in or get the file contents and to be very efficient. There is also a sub to
read in all the files in a directory other than . and ..

These slurp/spew subs work for files, pipes and sockets,
and stdio, pseudo-files, and DATA.

Author: Uri Guttman,

This module wraps the File::Slurp manpage and adds character encoding
support through the *'encoding'* parameter. It exports the same functions
which take all the same parameters as File::Slurp. Please see the the
File::Slurp manpage documentation for basic usage; only the differences are
described from here on out.