Involved Projects and Packages
ExtUtils::ParseXS will compile XS code into C code by embedding the constructs
necessary to let C functions manipulate Perl values and creates the glue
necessary to let Perl access those functions. The compiler uses typemaps to
determine how to map C function parameters and variables to Perl values.
Th compiler will search for typemap files called typemap. It will use the
following search path to find default typemaps, with the rightmost typemap
The intent of File::ShareDir is to provide a companion to Class::Inspector and File::HomeDir, modules that take a process that is well-known by advanced Perl developers but gets a little tricky, and make it more available to the larger Perl community.
Quite often you want or need your Perl module (CPAN or otherwise) to have access to a large amount of read-only data that is stored on the file-system at run-time.
On a linux-like system, this would be in a place such as /usr/share, however Perl runs on a wide variety of different systems, and so the use of any one location is unreliable.
Perl provides a little-known method for doing this, but almost nobody is aware that it exists. As a result, module authors often go through some very strange ways to make the data available to their code.
The most common of these is to dump the data out to an enormous Perl data structure and save it into the module itself. The result are enormous multi-megabyte .pm files that chew up a lot of memory needlessly.
$bool = is_FH($fh);
$bool = is_FH(\*FH);
This is just a (more intuitively named) alias for is_arg_ok().
Returns 1 if its argument is an open filehandle.
Returns 0 if its argument is something other than an open filehandle.
GD::Barcode is a subclass of GD and allows you to create barcode image with GD.
This module based on "Generate Barcode Ver 1.02 By Shisei Hanai 97/08/22".
From 1.14, you can use this module even if no GD (except plot method).
Kawai Takanori GCD00051@nifty.ne.jp
Barcode::Code128 generates bar codes using the CODE 128 symbology. It can generate images in PNG or GIF format using the GD package, or it can generate a text string representing the barcode that you can render using some other technology if desired.
GnuPG::Interface and its associated modules are designed to provide an object-oriented method for interacting with GnuPG, being able to perform functions such as but not limited to encrypting, signing, decryption, verification, and key-listing parsing.
Under older perls this module provides a drop in compatible api to
Hash::Util::FieldHash using perltie. When Hash::Util::FieldHash is available it
will use that instead.
This way code requiring field hashes can benefit from fast, robust field hashes
on Perl 5.10 and newer, but still run on older perls that don't ship with that
See Hash::Util::FieldHash for all the details of the API.
HTML::RewriteAttributes is designed for simple yet powerful HTML attribute
You simply specify a callback to run for each attribute and we do the rest for
This module is designed to be subclassable to make handling special cases
eaiser. See the source for methods you can override.
Shawn M Moore,
Original HTML::Template is written by Sam Tregar, with contributions of many
people mentioned there. Their efforts caused HTML::Template to be mature html
tempate engine which separate perl code and html design. Yet powerful,
HTML::Template is slow, especially if mod_perl isn't available or in case of
disk usage and memory limitations.
HTML::Template::Pro is a fast lightweight C/Perl+XS reimplementation of
HTML::Template (as of 2.8) and HTML::Template::Expr (as of 0.0.5). It is not
intended to be a complete replacement, but to be a fast implementation of
HTML::Template if you don't need quering, the extended facility of
HTML::Template. Designed for heavy upload, resource limitations, abcence of
HTML::Template::Pro has complete support of filters and HTML::Template::Expr's
tag EXPR="expression", including user-defined functions.
HTML::Template work cycle uses 2 steps. First, it loads and parse template.
Then it accepts param() calls until you call output(). output() is its second
phase where it produces a page from the parsed tree of template, obtained in
the 1st step.
HTML::Template::Pro loads, parse and outputs template on fly, when you call
$tmpl->output(), in one pass. The corresponding code is written in C and glued
to Perl using Perl+XS. As a result, comparing to HTML::Template in ordinary
calls, it runs 10-25 times faster. Comparing to HTML::Template with all caching
enabled under mod_perl, it still 1-3 times faster. At that HTML::Template
caching requires considerable amount of memory (per process, shareable, or on
disk) to be permanently filled with parsed trees, whereas HTML::Template::Pro
don't consumes memory for caches and use mmap() for reading templates on disk.
Introduction to HTML::Template and syntax of template files is described in
HTML::Template::SYNTAX. Perl interface of HTML::Template and
HTML::Template::Pro is described in HTML::Template::PerlInterface.
This is a simple standalone HTTP server. By default, it doesn't thread or fork.
It does, however, act as a simple frontend which can be used to build a
standalone web-based application or turn a CGI into one.
It is possible to use Net::Server classes to create forking, pre-forking, and
other types of more complicated servers; see "net_server".
See HTTP::Server::Simple package and the documentation in the perldoc manual.
Finding the home country of a client using only the IP address can be
difficult. Looking up the domain name associated with that address can provide
some help, but many IP address are not reverse mapped to any useful domain, and
the most common domain (.com) offers no help when looking for country.
This module comes bundled with a database of countries where various IP
addresses have been assigned. Although the country of assignment will probably
be the country associated with a large ISP rather than the client herself, this
is probably good enough for most log analysis applications, and under test has
proved to be as accurate as reverse-DNS and WHOIS lookup.
Nigel Wetters Gourlay
Jcode is a Japanese Charset Handler. It supports both object and traditional approach.
JSON-RPC is a stateless and light-weight remote procedure call (RPC)
protocol for inter-networking applications over HTTP. It uses JSON
as the data format for of all facets of a remote procedure call,
including all application data carried in parameters.
The old modules - JSONRPC::Transport::HTTP and Apache::JSONRPC are deprecated. Please try to use JSON::RPC::Server and JSON::RPC::Client which support both JSON-RPC protocol version 1.1 and 1.0.
This module implements a Portuguese stemming algorithm proposed in the paper A
Stemming Algorithm for the Portuguese Language by Moreira, V. and Huyck, C.
The eight steps of stemming algorithm are listed as follows:
* Plural Reduction
* Feminine Reduction
* Adverb Reduction
* Augmentative/Diminutive Reduction
* Noun Suffix Reduction
* Verb Suffix Reduction
* Vowel Reduction
* Accents Removal
This routine applies stemming algorithms to its parameters, returning the
stemmed words as appropriate to the selected locale.
You can import some or all of the class methods.
Stemming reduces related words to a common root form. For instance, "horse",
"horses", and "horsing" all become "hors". Most commonly, stemming is deployed
as part of a search application, allowing searches for a given term to match
documents which contain other forms of that term.
This module is very similar to Lingua::Stem -- however, Lingua::Stem is pure
Perl, while Lingua::Stem::Snowball is an XS module which provides a Perl
interface to the C version of the Snowball stemmers.
This module is a subclass of Locale::Maketext, with additional support for localizing messages that already contains interpolated variables.
This is most useful when the messages are returned by external sources -- for example, to match dir: command not found against [_1]: command not found.
This module allows you to map from US two-letter codes to statees and vice
T. M. Brannon,
This simple locking scheme is not based on any file locking system calls such
as flock() or lockf() but rather relies on basic file system primitives and
properties, such as the atomicity of the write() system call. It is not meant
to be exempt from all race conditions, especially over NFS. The algorithm used
is described below in the ALGORITHM section.
It is possible to customize the locking operations to attempt locking once
every 5 seconds for 30 times, or delete stale locks (files that are deemed too
ancient) before attempting the locking.
The Logfile extension will help you to generate various reports from different
server logfiles. In general there is no restriction as to what information you
extract from the logfiles.
MARC.pm is a Perl 5 module for reading in, manipulating, and outputting bibliographic records in the USMARC format. You will need to have Perl 5.004 or greater for MARC.pm to work properly. Since it is a Perl module you use MARC.pm from one of your own Perl scripts. To see what sorts of conversions are possible you can try out a web interface to MARC.pm which will allow you to upload MARC files and retrieve the results (for details see the section below entitled "Web Interface").
However, to get the full functionality you will probably want to install MARC.pm on your server or PC. MARC.pm can handle both single and batches of MARC records. The limit on the number of records in a batch is determined by the memory capacity of the machine you are running. If memory is an issue for you MARC.pm will allow you to read in records from a batch gradually. MARC.pm also includes a variety of tools for searching, removing, and even creating records from scratch.
MARC::Charset is a package to assist you in converting data encoded using MARC-8 character sets to Unicode (UTF-8).
MARC/Perl is a Perl 5 library for reading, manipulating, outputting and converting bibliographic records in the MARC format. The MAchine Readable Cataloging format was designed by the Library of Congress in the late 1960s in order to allow libraries to convert their card catalogs into a digital format.
This module provides an implentation of the LOC's spec on how to convert
metadata between MARC and Dublin Core format. The spec for converting MARC to
Dublin Core is available at: http://www.loc.gov/marc/marc2dc.html, and from DC
to MARC: http://www.loc.gov/marc/dccross.html.
NB: The conversion cannot be done in a round-trip manner. i.e. Doing a
conversion from MARC to DC, then trying to go back to MARC will not yield the