Ports Search

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.