Suomi-Malaga is a description of Finnish morphology written in Malaga.

Mftrace is a small Python program that lets you trace a TeX bitmap font
into a PFA or PFB font (A PostScript Type1 Scalable Font) or TTF
(TrueType) font.

nspluginwrapper is an Open Source compatibility plugin for Netscape 4
(NPAPI) plugins. It enables you to use plugins on platforms they were
not built for. For example, you can use the plugins compiled for i386
in Mozilla on Linux/x86_64 or other architectures. This package
consists of:

* npviewer: the plug-in viewer

* npwrapper.so: the browser-side plug-in

* nspluginwrapper: a tool to manage plug-ins installation and update

Core package of Network UPS Tools.

Network UPS Tools is a collection of programs which provide a common
interface for monitoring and administering UPS hardware.

Detailed information about supported hardware can be found in
/usr/share/doc/packages/nut.

OpenCT is a set of library and tools to talk to smart card readers.
OpenCT is used by the OpenSC Smart Card library.

For a list of supported readers, please read documentation in
/usr/share/doc/packages/openct/wiki/index.html - some readers may be
supported only with particular firmware or particular connection type.

There are other packages that may support your reader in a different
way. Name of all these packages starts with "pcsc-".

OpenSC provides a set of utilities to access smart cards. It mainly
focuses on cards that support cryptographic operations. It facilitates
their use in security applications such as mail encryption,
authentication, and digital signature. OpenSC implements the PKCS#11
API. Applications supporting this API, such as Mozilla Firefox and
Thunderbird, can use it. OpenSC implements the PKCS#15 standard and aims
to be compatible with every software that does so, too.

Before purchasing any cards, please read carefully documentation on the
web pageonly some cards are supported. Not only card type matters, but
also card version, card OS version and preloaded applet. Only subset of
possible operations may be supported for your card. Card initialization
may require third party proprietary software.

Orc is a library and set of tools for compiling and executing very simple
programs that operate on arrays of data. The “language” is a generic
assembly language that represents many of the features available in SIMD
architectures, including saturated addition and subtraction, and many
arithmetic operations.

Pam_p11 is a pluggable authentication module (pam) package for using
cryptographic tokens, such as smart cards and usb crypto tokens, for
authentication.

Pam_p11 uses libp11 to access any PKCS#11 module. It should be
compatible with any implementation, but it is primarily developed using
OpenSC.

Pam_p11 implements two authentication modules:

* pam_p11_openssh authenticates the user using openssh
~/.ssh/authorized_keys file.

* pam_p11_opensc authenticates the user using certificates found in
~/.eid/authorized_certificates. It is compatible with the older
opensc "pam_opensc" authentication module (eid mode).

Pam_p11 is very simple. It has no configuration file, no other options
than the PKCS#11 module file, and does not know about certificate
chains, certificate authorities, revocation lists, or OCSP. It is
perfect for the small installation with no frills.

This Linux PAM module allows X.509 a certificate-based user
authentication. The certificate and its dedicated private key are
thereby accessed by means of an appropriate PKCS #11 module. For the
verification of the users' certificates, locally stored CA certificates
as well as online or locally accessible CRLs are used.

Additionally, the package includes pam_pkcs11-related tools: *
pkcs11_eventmgr: Generates actions on card insert, removal, or
time-out events

* pklogin_finder: Gets the login name that maps to a certificate

* pkcs11_inspect: Inspects the contents of a certificate

* make_hash_links: Creates hash link directories for storing CAs and
CRLs

This package contains a driver for the ACR 38 smart card reader
produced by ACS.

This driver is meant to be used with the PCSC-Lite daemon from the
pcsc-lite package.

This package contains a driver for the ASEDrive IIIe Serial smart card
reader.

This driver is meant to be used with the PCSC-Lite daemon from the
pcsc-lite package.

This package contains a driver for the ASEDrive IIIe USB smart card
reader.

This driver is meant to be used with the PCSC-Lite daemon from the
pcsc-lite package.

This package contains a driver for the ASEKey USB Token.

This driver is meant to be used with the PCSC-Lite daemon from the
pcsc-lite package.

This package contains a generic USB CCID (Chip/Smart Card Interface
Devices) driver.

This driver is meant to be used with the PCSC-Lite daemon from the
pcsc-lite package.

Driver for the ECO 5000 Serial Smart Card Reader.

This driver is meant to be used with the PCSC-Lite daemon from the
pcsc-lite package.

This interface allows access to the terminal using the Card Terminal
Basic Command Set (CT-BCS). This driver also includes the support for
memory cards, exposed as Interindustry Command Set for Synchronous
Cards.

The CT-API driver supports the IFD Handler interface from PC/SC.

Please take a look in the included README document for further
information.

This driver only works with the serial interface version of the ECO
5000. ORGA also sells a USB version, that is incompatible with the
serial version. This driver will not work with the USB version!

This package contains a driver for the GemPC 410 and GemPC 430 smart
card readers produced by Gemplus.

This driver is meant to be used with the PCSC-Lite daemon from the
pcsc-lite package.

The purpose of PCSC Lite is to provide a Windows(R) SCard interface in
a very small form factor for communication with smart cards and
readers. PCSC Lite can be compiled directly for a desired reader driver
or can be used to dynamically allocate/deallocate reader drivers at
runtime (the default behavior).

PCSC Lite uses the same winscard API as used in Windows(R).

Security aware people should read the SECURITY file for possible
vulnerabilities of pcsclite and how to fix them. For information on how
to install drivers please read the DRIVERS file.

Memory cards will be supported through the MCT specification, which is
an APDU like manner sent normally through the SCardTransmit() function.
This functionality is exercised in the driver.

This package contains a driver for the Reflex 62 and Reflex 64 smart
card readers produced by Schlumberger.

This driver is meant to be used with the PCSC-Lite daemon from the
pcsc-lite package.

This package contains a driver for Towitoko Chipdrive Micro, Extern,
Extern II, Intern, and Twin and Kartenzwerg smart card readers.

This driver is meant to be used with the PCSC-Lite daemon from the
pcsc-lite package.

Please note, that many modern Towitoko readers are supported by the
openct package.

Finance::Quote provides access to time-delayed stockquotes from a
number of sources. After you've installed the pacakage, try 'perldoc
Finance::Quote' for full information. Alternatively, you can 'perldoc
lib/Finance/Quote.pm' before the install.

HTML::TableExtract is a subclass of HTML::Parser that serves to extract the
information from tables of interest contained within an HTML document. The
information from each extracted table is stored in table objects. Tables
can be extracted as text, HTML, or HTML::ElementTable structures (for
in-place editing or manipulation).

There are currently four constraints available to specify which tables you
would like to extract from a document: _Headers_, _Depth_, _Count_, and
_Attributes_.

_Headers_, the most flexible and adaptive of the techniques, involves
specifying text in an array that you expect to appear above the data in the
tables of interest. Once all headers have been located in a row of that
table, all further cells beneath the columns that matched your headers are
extracted. All other columns are ignored: think of it as vertical slices
through a table. In addition, TableExtract automatically rearranges each
row in the same order as the headers you provided. If you would like to
disable this, set _automap_ to 0 during object creation, and instead rely
on the column_map() method to find out the order in which the headers were
found. Furthermore, TableExtract will automatically compensate for cell
span issues so that columns are really the same columns as you would
visually see in a browser. This behavior can be disabled by setting the
_gridmap_ parameter to 0. HTML is stripped from the entire textual content
of a cell before header matches are attempted -- unless the _keep_html_
parameter was enabled.

_Depth_ and _Count_ are more specific ways to specify tables in relation to
one another. _Depth_ represents how deeply a table resides in other tables.
The depth of a top-level table in the document is 0. A table within a
top-level table has a depth of 1, and so on. Each depth can be thought of
as a layer; tables sharing the same depth are on the same layer. Within
each of these layers, _Count_ represents the order in which a table was
seen at that depth, starting with 0. Providing both a _depth_ and a _count_
will uniquely specify a table within a document.

_Attributes_ match based on the attributes of the html tag, for
example, boder widths or background color.

Each of the _Headers_, _Depth_, _Count_, and _Attributes_ specifications
are cumulative in their effect on the overall extraction. For instance, if
you specify only a _Depth_, then you get all tables at that depth (note
that these could very well reside in separate higher- level tables
throughout the document since depth extends across tables). If you specify
only a _Count_, then the tables at that _Count_ from all depths are
returned (i.e., the _n_th occurrence of a table at each depth). If you only
specify _Headers_, then you get all tables in the document containing those
column headers. If you have specified multiple constraints of _Headers_,
_Depth_, _Count_, and _Attributes_, then each constraint has veto power
over whether a particular table is extracted.

If no _Headers_, _Depth_, _Count_, or _Attributes_ are specified, then all
tables match.

When extracting only text from tables, the text is decoded with
HTML::Entities by default; this can be disabled by setting the _decode_
parameter to 0.

Extraction Modes
The default mode of extraction for HTML::TableExtract is raw text or
HTML. In this mode, embedded tables are completely decoupled from one
another. In this case, HTML::TableExtract is a subclass of
HTML::Parser:

use HTML::TableExtract;

Alternativevly, tables can be extracted as HTML::ElementTable
structures, which are in turn embedded in an HTML::Element tree
representing the entire HTML document. Embedded tables are not
decoupled from one another since this tree structure must be
manitained. In this case, HTML::TableExtract is a subclass of
HTML::TreeBuilder (itself a subclass of HTML:::Parser):

use HTML::TableExtract qw(tree);

In either case, the basic interface for HTML::TableExtract and the
resulting table objects remains the same -- all that changes is what
you can do with the resulting data.

HTML::TableExtract is a subclass of HTML::Parser, and as such inherits
all of its basic methods such as 'parse()' and 'parse_file()'. During
scans, 'start()', 'end()', and 'text()' are utilized. Feel free to
override them, but if you do not eventually invoke them in the SUPER
class with some content, results are not guaranteed.

Advice
The main point of this module was to provide a flexible method of
extracting tabular information from HTML documents without relying to
heavily on the document layout. For that reason, I suggest using
_Headers_ whenever possible -- that way, you are anchoring your
extraction on what the document is trying to communicate rather than
some feature of the HTML comprising the document (other than the fact
that the data is contained in a table).

pkcs11-helper allows using multiple PKCS#11 providers at the same
time and selecting keys by id, label or certificate subject.
Besides it covers the following topics: * Handling card removal
and card insert events

* Handling card re-insert to a different slot

* Supporting session expiration serialization

* and much more All this is possible using a simple API.

Potrace is a utility for tracing a bitmap, which means, transforming a
bitmap into a smooth, scalable image. The input is a bitmap (PBM, PGM,
PPM, or BMP), and the default output is one of several vector file
formats. A typical use is to create EPS files from scanned data, such
as company or university logos, handwritten notes, etc. The resulting
image is not "jaggy" like a bitmap, but smooth. It can then be rendered
at any resolution.

PowerMan is a tool for manipulating remote power control (RPC) devices from a
central location. Several RPC varieties are supported natively by PowerMan and
Expect-like configurability simplifies the addition of new devices.

pstoedit converts PostScript and PDF files to other vector graphic
formats so that they can be edited graphically.

pstoedit supports:

* Tgif .obj format (for tgif version >= 3)

* .fig format for xfig

* pdf - Adobe's Portable Document Format

* gnuplot format

* Flattened PostScript (with or without Bezier curves)

* DXF - CAD exchange format

* LWO - LightWave 3D

* RIB - RenderMan

* RPL - Real3D

* Java 1 or Java 2 applet

* Idraw format (in fact a special form of EPS that idraw can read)

* Tcl/Tk

* HPGL

* AI (Adobe Illustrator) (based on ps2ai.ps - not a real pstoedit driver - see notes below and manual)

* Windows Meta Files (WMF) (Windows only)

* Enhanced Windows Meta Files (EMF) (Windows, but also Linux/Unix if libemf is available)

* OS/2 meta files (OS/2 only)

* PIC format for troff/groff

* MetaPost format for usage with TeX/LaTeX

* LaTeX2e picture

* Kontour

* GNU Metafile (plotutils / libplot)

* Skencil ( http://www.skencil.org )

* Mathematica

* via ImageMagick to any format supported by ImageMagick

* SWF

* CNC G code

* VTK files for ParaView and similar visualization tools