Free code128 2.01 software for linux

Barcode::Code128 is a Perl module that can generate CODE 128 bar codes.

SYNOPSIS

use Barcode::Code128;

$code = new Barcode::Code128;

EXPORTS

By default, nothing. However there are a number of constants that represent special characters used in the CODE 128 symbology that you may wish to include. For example if you are using the EAN-128 or UCC-128 code, the string to encode begins with the FNC1 character. To encode the EAN-128 string "00 0 0012345 555555555 8", you would do the following:

use Barcode::Code128 FNC1;
$code = new Barcode::Code128;
$code->text(FNC1.00000123455555555558);

To have this module export one or more of these characters, specify them on the use statement or use the special token :all instead to include all of them. Examples:

use Barcode::Code128 qw(FNC1 FNC2 FNC3 FNC4 Shift);
use Barcode::Code128 qw(:all);

Here is the complete list of the exportable characters. They are assigned to high-order ASCII characters purely arbitrarily for the purposes of this module; the values used do not reflect any part of the CODE 128 standard. Warning: Using the CodeA, CodeB, CodeC, StartA, StartB, StartC, and Stop codes may cause your barcodes to be invalid, and be rejected by scanners. They are inserted automatically as needed by this module.

CodeA 0xf4 CodeB 0xf5 CodeC 0xf6
FNC1 0xf7 FNC2 0xf8 FNC3 0xf9
FNC4 0xfa Shift 0xfb StartA 0xfc
StartB 0xfd StartC 0xfe Stop 0xff

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.

The intended use of this module is to create a web page with a bar code on it, which can then be printed out and faxed or mailed to someone who will scan the bar code. The application which spurred its creation was an expense report tool, where the employee submitting the report would print out the web page and staple the receipts to it, and the Accounts Payable clerk would scan the bar code to indicate that the receipts were received.

The default settings for this module produce a large image that can safely be FAXed several times and still scanned easily. If this requirement is not important you can generate smaller image using optional parameters, described below.

If you wish to generate images with this module you must also have the GD.pm module (written by Lincoln Stein, and available from CPAN) installed. Version 1.20 or higher of GD generates a PNG file, due to issues with the GIF patent. If you want to create a GIF, you must use version 1.19 or earlier of GD. However, most browsers have no trouble with PNG files.

If the GD module is not present, you can still use the module, but you will not be able to use its functions for generating images. You can use the barcode() method to get a string of "#" and " " (hash and space) characters, and use your own image-generating routine with that as input.

To use the the GD module, you will need to install it along with this module. You can obtain it from the CPAN (Comprehensive Perl Archive Network) repository of your choice under the directory authors/id/LDS. Visit http://www.cpan.org/ for more information about CPAN. The GD home page is: http://stein.cshl.org/WWW/software/GD/GD.html

LZO is a data compression library which is suitable for data de-/compression in real-time. This means it favours speed over compression ratio.
LZO is written in ANSI C. Both the source code and the compressed data format are designed to be portable across platforms.
Main features:
- Decompression is simple and *very* fast.
- Requires no memory for decompression.
- Compression is pretty fast.
- Requires 64 kB of memory for compression.
- Allows you to dial up extra compression at a speed cost in the compressor. The speed of the decompressor is not reduced.
- Includes compression levels for generating pre-compressed data which achieve a quite competitive compression ratio.
- There is also a compression level which needs only 8 kB for compression.
- Algorithm is thread safe.
- Algorithm is lossless.
Enhancements:
- Changed the configure system to install the LZO library under the name "liblzo2" so that parallel installation with LZO v1 is possible.
- Improved auto-configuration in miniLZO for some embedded targets like Blackfin and H8/300 processors.

dbdeploy is a Database Change Management tool. The project helps developers and DBAs change their database in a simple, controlled, flexible and frequent manner.

The recurring problem with database development is that at some point you’ll need to upgrade an existing database and preserve its content. In development environments it’s often possible (even desirable) to blow away the database and rebuild from scratch as often as the code is rebuilt but this approach cannot be taken forward into more controlled environments such as QA, UAT and Production.

Drawing from our experiences, we’ve found that one of the easiest ways to allow people to change the database is by using version-controlled SQL delta scripts. We’ve also found it beneficial to ensure that the scripts used to build development environments are the exact same used in QA, UAT and production. Maintaining and making use of these deltas can quickly become a significant overhead - dbdeploy aims to address this.

How It Works

By comparing the SQL delta scripts on your filesystem against a patch table in the target database, it generates SQL scripts – it doesn’t directly apply them.

Invocation methods

dbdeploy can be called from within an ant build file.

DBMS support

dbdeploy supports the following DBMS:

Oracle
MS SQL Server
Sybase
Hypersonic SQL

AtExit is a Perl module that can perform exit processing for a program or object.

SYNOPSIS

use AtExit;

sub cleanup {
my @args = @_;
print "cleanup() executing: args = @argsn";
}

## Register subroutines to be called when this program exits

$_ = atexit(&cleanup, "This call was registered first");
print "first call to atexit() returned $_n";

$_ = atexit("cleanup", "This call was registered second");
print "second call to atexit() returned $_n";

$_ = atexit("cleanup", "This call shouldve been unregistered by rmexit");
rmexit($_) or warn "couldnt unregister exit-sub $_!";

if (@ARGV == 0) {
## Register subroutines to be called when this lexical scope is exited
my $scope1 = AtExit->new( &cleanup, "Scope 1, Callback 1" );
{
## Do the same for this nested scope
my $scope2 = AtExit->new;
$_ = $scope2->atexit( &cleanup, "Scope 2, Callback 1" );
$scope1->atexit( &cleanup, "Scope 1, Callback 2");
$scope2->atexit( &cleanup, "Scope 2, Callback 2" );
$scope2->rmexit($_) or warn "couldnt unregister exit-sub $_!";

print "*** Leaving Scope 2 ***n";
}
print "*** Finished Scope 2 ***n";
print "*** Leaving Scope 1 ***n";
}
print "*** Finished Scope 1 ***n" if (@ARGV == 0);

END {
print "*** Now performing program-exit processing ***n";
}

The AtExit module provides ANSI-C style exit processing modeled after the atexit function in the standard C library (see atexit(3C)). Various exit processing routines may be registered by calling atexit and passing it the desired subroutine along with any desired arguments. Then, at program-exit time, the subroutines registered with atexit are invoked with their given arguments in the reverse order of registration (last one registered is invoked first). Registering the same subroutine more than once will cause that subroutine to be invoked once for each registration.

An AtExit object can be created in any scope. When invoked as a function, atexit registers callbacks to be executed at program-exit time. But when invoked as an object-method (using the $object->method_name syntax), callbacks registered with an AtExit object are executed at object-destruction time! The rules for order of execution of the registered subroutines are the same for objects during object-destruction, as for the program during program-termination.

The atexit function/method should be passed a subroutine name or reference, optionally followed by the list of arguments with which to invoke it at program/object exit time. Anonymous subroutine references passed to atexit act as "closures" (which are described in perlref). If a subroutine name is specified (as opposed to a subroutine reference) then, unless the subroutine name has an explicit package prefix, it is assumed to be the name of a subroutine in the callers current package. A reference to the specified subroutine is obtained, and, if invocation arguments were specified, it is "wrapped up" in a closure which invokes the subroutine with the specified arguments. The resulting subroutine reference is added to the front of the list of exit-handling subroutines for the program (atexit) or the AtExit object ($exitObject->atexit) and the reference is then returned to the caller (just in case you might want to unregister it later using rmexit. If the given subroutine could not be registered, then the value zero is returned.

The rmexit function/method should be passed one or more subroutine references, each of which was returned by a previous call to atexit. For each argument given, rmexit will look in the list of exit-handling subroutines for the program (rmexit) or the AtExit object ($exitObject->rmexit) and remove the first matching entry from the list. If no arguments are given, then all program or object exit-handlers are unregistered! The value returned will be the number of subroutines that were successfully unregistered.

At object destruction time, the DESTROY{} subroutine in the AtExit module iterates over the subroutine references in the AtExit object and invokes each one in turn (each subroutine is removed from the front of the queue immediately before it is invoked). At program-exit time, the END{} block in the AtExit module iterates over the subroutines in the array returned by the exit_subs method and invokes each one in turn (each subroutine is removed from the front of the queue immediately before it is invoked). Note that in both cases (program-exit, and object-destruction) the subroutines in this queue are invoked in first-to-last order (the reverse order in which they were registered with atexit).

etherdump project is a very small and efficient ethernet sniffer.
EtherDump is a fork by Peter Willis of ipdump2-pre1 (by Christophe Devine) with a few small improvements and feature add-ons with the end result being able to stream raw frames over a network and eventually convert them into pcap format and import into a pcap-reading prog of your choice (I personally love Ethereal).
Pretty simple use; just run the prog with no arguments and you will get the usage instructions. Log a session to a file using ASCII hex dump and when you are done run `text2pcap hex_dump pcap_file and read `pcap_file with Ethereal or another libpcap-aware program.
Since version 2.01 EtherDump supports some minimal packet filtering rules. Some of the rules you can use are "proto" or "protocol", "sport" or "sourceport", "dport" or "destinationport", "src" or "source", and "dst" or "destination". You can also give "!" or "not" to negate a particular rule.
If you execute EtherDump from a symlink named "tcpdump", the default print out method is tcpdump-like.
On uClibc the compiled size is ~8kB so this is very well suited for embedded systems where you want to debug a network interface but dont have room for a whole libpcap+application_layer program. Instead just combine netcat or a CGI script + httpd with EtherDump and read the traffic (converted to pcap) on another machine on the network.
Enhancements:
- Changes by Peter Willis since 2.0:
- Changed configuration option to reflect new name is "etherdump", not "packetdump". -p is now -e.
- Added basic [ipv4] filtering rules.
- Improved tcpdump output.
- If etherdump was run as a program named tcpdump, defaults to tcpdump-like output.
- Added -i to specify interface.
- If EtherDump is executed as "tcpdump", tcpdump-like output is the default output type.

Archiveopteryx is an Internet mail server, optimized to support heavy usage and long-term archiving.
The project stores mail in a PostgreSQL database, and provides access to it through IMAP, POP, and more.
Enhancements:
- A very serious SMTP submit bug was fixed.
- A new feature to copy outgoing mail to the sender was added.
- Support for SMTP+TLS on port 465 was added for Outlook.
- HTTP archive display improvements were made.
- A few minor bugs were fixed.

JoeDog::Config provides a perl extension for parsing data/configuration file.

It reads columns, key-value pairs, and INI style config files into arrays, hashes and hashes of hashes. It can take characters or regexes for separators.

ABSTRACT:
This is a autoloadable module which allows the programmer
to read data from an configuration file into various perl
data types, arrays, multi-dimentional arrays and hashes.

INSTALLATION
JoeDog::Config.pm was built using perl Make::Maker utility
If you are familiar with that utility you should have no
problem with this installation as it will be familiar:

$ perl Makefile.PL
$ make
$ make test
$ su
$ make install

USAGE
use JoeDog::Config;
my $cnf = new JoeDog::Config(filename);
my @array = $cnf->get_column();
my @arrays = $cnf->get_columns(sep);
my @aoa = $cnf->get_table(sep,num);
my @aoa = $cnf->get_table(sep,[num1, num2, etc...]);
my %hash = $cnf->get_hash(sep);
my %hashes = $cnf->get_hashes(sep);

Homemade Dictionary is a customizable and easy to use dictionary, with features including background music support.
Homemade Dictionary has a built in "Test Your Word Power Game", a medical dictionary, and a nice GUI.
The dictionary has an initial database of of around 5600 words, including slang. You can add your personal words on the fly. It is very small in size (only 637 KB).
Enhancements:
- Wordlist has been updated