Class::Mixin provides a way to mix methods from one class into another,
such that the target class can use both its methods as well as those of
the source class.
The primary advantage is that the behavior of a class can be modified
to effectively be another class without changing any of the calling
code -- just requires using the new class that mixes into the original.
diStorm is a binary stream disassembler of x86 instructions. It can operate
in 16, 32, and 64 bit modes, and supports FPU, MMX, SSE, SSE2, SSE3, SSE4,
3DNow! (with extensions), x86-64, VMX, AMD SVM, and AVX instruction sets.
diStorm was written to decode every instruction quickly and accurately, with
robust handling of valid and unused prefixes. The output is a special structure
that can describe any x86 instruction, and later be formatted into text for
display.
This module allows you to read configuration data written in a
human-readable and easily-editable text format and access it as
a perl data structure. It also allows you to write configuration
data from perl back to this format.
The data format allows key/value pairs, comments, escaping of
unprintable or problematic characters, sensible whitespace
handling, support for Unicode data, nested sections, or blocks,
of configuration data.
This is an abstract base class for objects backed by a socket which
provides the basic framework for event-driven asynchronous IO,
designed to be fast. Danga::Socket is both a base class for objects,
and an event loop.
Callers subclass Danga::Socket. Danga::Socket's constructor registers
itself with the Danga::Socket event loop, and invokes callbacks on the
object for readability, writability, errors, and other conditions.
This little package serves to access the symbol table of perl.
Devel::Symdump->rnew(@packages)
returns a symbol table object for all subtrees below @packages.
Nested Modules are analyzed recursively. If no package is given as
argument, it defaults to main. That means to get the whole symbol
table, just do a rnew without arguments.
Devel::Symdump->new(@packages)
does not go into recursion and only analyzes the packages that are
given as arguments.
This module can be used to more easily spot the place where a program or a
module generates errors. Its use is extremely simple, reduced to just'use'ing
it.
This is achieved by modifying the functions warn() and die() in order to
replace the standard messages by complete stack traces that precisely indicates
how and where the error or warning occurred. Other than this, their use should
stay unchanged, even when using die() inside eval().
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() as of Perl 5.6.0 though this module still works
with 5.00503.
This module allows you to declare hierarchies of exception classes for
use in your code. It also provides a simple exception class that it
uses as the default base class for all other exceptions.
You may choose to use another base class for your exceptions.
Regardless, the ability to declare all your exceptions at compile time
is a fairly useful trick and helps push people towards more structured
use of exceptions.
IPC::Shareable allows you to tie a variable to shared memory making it
easy to share the contents of that variable with other Perl processes.
Currently either scalars or hashes can be tied; tying of arrays remains
a work in progress. However, the variable being tied may contain
arbitrarily complex data structures - including references to arrays,
hashes of hashes, etc. See the "REFERENCES" entry in this man page below
for more information.
List::SomeUtils provides some trivial but commonly needed functionality on lists
which is not going to go into List::Util.
All of the below functions are implementable in only a couple of lines of Perl
code. Using the functions from this module however should give slightly better
performance as everything is implemented in C. The pure-Perl implementation of
these functions only serves as a fallback in case the C portions of this module
couldn't be compiled on this machine.