Free convert 1.1 software for linux

Mail::Addressbook::Convert is a Perl module that can convert to and from many e-mail addressbooks.

SYNOPSIS

These modules allow to to convert between the following e-mail addressbook formats
From To csv csv ( Note: MS Outlook. Outlook Express and many other mailers will export and import into this format) tsv tsv (tab-separated ascii, Outlook and OE also do these) pine pine ccMail Eudora Eudora Pegasus Pegasus Juno Lidf Ldif (Netscape 4 exports in this format ) Mailrc Spry

This distribution will convert email addressbooks between many common formats. Some examples are Pine, Eudora, Pegasus, csv.

The documentation here is general. For details on conversion, each module has pod documentation specific to its conversion

As an example

To use to convert between Pine and Eudora as an example, you would do the following

use Mail::Addressbook::Convert::Pine;

use Mail::Addressbook::Convert::Eudora;

my $Pine = new Mail::Addressbook::Convert::Pine();

my $Eudora = new Mail::Addressbook::Convert::Eudora();

my $PineInFile ="pineSample.txt"; # name of the file containing the Pine data

my $raIntermediate = $Pine->scan($PineInFile);

my $raEudora = $Eudora->output($raIntermediate); # reference to an array containing a Eudora addressbook

All modules follow this template except Pegasus. Pegasus stores its address books in multiple files. See the documentation in Pegasus.pm

Convert::BER is a Perl module for ASN.1 Basic Encoding Rules.

SYNOPSIS

use Convert::BER;

$ber = new Convert::BER;

$ber->encode(
INTEGER => 1,
SEQUENCE => [
BOOLEAN => 0,
STRING => "Hello",
],
REAL => 3.7,
);

$ber->decode(
INTEGER => $i,
SEQUENCE => [
BOOLEAN => $b,
STRING => $s,
],
REAL => $r,
);

Convert::BER provides an OO interface to encoding and decoding data using the ASN.1 Basic Encoding Rules (BER), a platform independent way of encoding structured binary data together with the structure.

Convert::BinHex can extract data from Macintosh BinHex files.

ALPHA WARNING: this code is currently in its Alpha release. Things may change drastically until the interface is hammered out: if you have suggestions or objections, please speak up now!

SYNOPSIS

Simple functions:

use Convert::BinHex qw(binhex_crc macbinary_crc);

# Compute HQX7-style CRC for data, pumping in old CRC if desired:
$crc = binhex_crc($data, $crc);

# Compute the MacBinary-II-style CRC for the data:
$crc = macbinary_crc($data, $crc);

Hex to bin, low-level interface. Conversion is actually done via an object ("Convert::BinHex::Hex2Bin") which keeps internal conversion state:
# Create and use a "translator" object:
my $H2B = Convert::BinHex->hex2bin; # get a converter object
while (< STDIN >) {
print $STDOUT $H2B->next($_); # convert some more input
}
print $STDOUT $H2B->done; # no more input: finish up

Hex to bin, OO interface. The following operations must be done in the order shown!
# Read data in piecemeal:
$HQX = Convert::BinHex->open(FH=>*STDIN) || die "open: $!";
$HQX->read_header; # read header info
@data = $HQX->read_data; # read in all the data
@rsrc = $HQX->read_resource; # read in all the resource

Bin to hex, low-level interface. Conversion is actually done via an object ("Convert::BinHex::Bin2Hex") which keeps internal conversion state:
# Create and use a "translator" object:
my $B2H = Convert::BinHex->bin2hex; # get a converter object
while (< STDIN >) {
print $STDOUT $B2H->next($_); # convert some more input
}
print $STDOUT $B2H->done; # no more input: finish up

Bin to hex, file interface. Yes, you can convert to BinHex as well as from it!
# Create new, empty object:
my $HQX = Convert::BinHex->new;

# Set header attributes:
$HQX->filename("logo.gif");
$HQX->type("GIFA");
$HQX->creator("CNVS");

# Give it the data and resource forks (either can be absent):
$HQX->data(Path => "/path/to/data"); # here, data is on disk
$HQX->resource(Data => $resourcefork); # here, resource is in core

# Output as a BinHex stream, complete with leading comment:
$HQX->encode(*STDOUT);

PLANNED!!!! Bin to hex, "CAP" interface. Thanks to Ken Lunde for suggesting this.
# Create new, empty object from CAP tree:
my $HQX = Convert::BinHex->from_cap("/path/to/root/file");
$HQX->encode(*STDOUT);

BinHex is a format used by Macintosh for transporting Mac files safely through electronic mail, as short-lined, 7-bit, semi-compressed data streams. Ths module provides a means of converting those data streams back into into binary data.

Convert::UUlib is a Perl interface to the uulib library (a.k.a. uudeview/uuenview).

SYNOPSIS

use Convert::UUlib :all;

# read all the files named on the commandline and decode them
# into the CURRENT directory. See below for a longer example.
LoadFile $_ for @ARGV;
for (my $i = 0; my $uu = GetFileListItem $i; $i++) {
if ($uu->state & FILE_OK) {
$uu->decode;
print $uu->filename, "n";
}
}

Read the file doc/library.pdf from the distribution for in-depth information about the C-library used in this interface, and the rest of this document and especially the non-trivial decoder program at the end.

Time::Convert is a Perl interface to converting unix seconds to years, days, hours and minutes.

SYNOPSIS

use Time::Convert;
my $convert = new Time::Convert;

EXAMPLE

use Time::Convert;
my $convert = new Time::Convert;
$REPLY = $convert->ConvertSecs(time);
print($REPLY);

Convert::Recode is a Perl module to make mapping functions between character sets.

SYNOPSIS

use Convert::Recode qw(ebcdic_to_ascii);

while () {
print ebcdic_to_ascii($_);
}

The Convert::Recode module can provide mapping functions between character sets on demand. It depends on GNU recode to provide the raw mapping data, i.e. GNU recode must be installed first. The name of the mapping function is constructed by taking the names of the two charsets and joining them with the string "_to_". For example, if you want to convert between the "mac" and the "latin1" charsets, just import the mac_to_latin1() function.

If you prefix the function name with "strict_", any characters that cannot be mapped are removed during transformation. For instance, the strict_mac_to_latin1() function converts a string to latin1 and removes all mac characters that do not have a corresponding latin1 character.

Running the command recode -l should give you the list of available character sets.

Convert::Scalar is a Perl module that can convert between different representations of perl scalars.

SYNOPSIS

use Convert::Scalar;

This module exports various internal perl methods that change the internal representation or state of a perl scalar. All of these work in-place, that is, they modify their scalar argument. No functions are exported by default.

The following export tags exist:

:utf8 all functions with utf8 in their name
:taint all functions with taint in their name
:refcnt all functions with refcnt in their name
:ok all *ok-functions.
utf8 scalar[, mode]

Returns true when the given scalar is marked as utf8, false otherwise. If the optional mode argument is given, also forces the interpretation of the string to utf8 (mode true) or plain bytes (mode false). The actual (byte-) content is not changed. The return value always reflects the state before any modification is done.

This function is useful when you "import" utf8-data into perl, or when some external function (e.g. storing/retrieving from a database) removes the utf8-flag.

utf8_on scalar

Similar to utf8 scalar, 1, but additionally returns the scalar (the argument is still modified in-place).

utf8_off scalar

Similar to utf8 scalar, 0, but additionally returns the scalar (the argument is still modified in-place).

utf8_valid scalar [Perl 5.7]

Returns true if the bytes inside the scalar form a valid utf8 string, false otherwise (the check is independent of the actual encoding perl thinks the string is in).

utf8_upgrade scalar

Convert the string content of the scalar in-place to its UTF8-encoded form (and also returns it).

utf8_downgrade scalar[, fail_ok=0]

Attempt to convert the string content of the scalar from UTF8-encoded to ISO-8859-1. This may not be possible if the string contains characters that cannot be represented in a single byte; if this is the case, it leaves the scalar unchanged and either returns false or, if fail_ok is not true (the default), croaks.

utf8_encode scalar

Convert the string value of the scalar to UTF8-encoded, but then turn off the SvUTF8 flag so that it looks like bytes to perl again. (Might be removed in future versions).

utf8_length scalar

Returns the number of characters in the string, counting wide UTF8 characters as a single character, independent of wether the scalar is marked as containing bytes or mulitbyte characters.

unmagic scalar, type

Remove the specified magic from the scalar (DANGEROUS!).

weaken scalar

Weaken a reference. (See also WeakRef).

taint scalar

Taint the scalar.

tainted scalar

returns true when the scalar is tainted, false otherwise.

untaint scalar

Remove the tainted flag from the specified scalar.

grow scalar, newlen

Sets the memory area used for the scalar to the given length, if the current length is less than the new value. This does not affect the contents of the scalar, but is only useful to "pre-allocate" memory space if you know the scalar will grow. The return value is the modified scalar (the scalar is modified in-place).

refcnt scalar[, newrefcnt]

Returns the current reference count of the given scalar and optionally sets it to the given reference count.

refcnt_inc scalar

Increments the reference count of the given scalar inplace.

refcnt_dec scalar

Decrements the reference count of the given scalar inplace. Use weaken instead if you understand what this function is fore. Better yet: dont use this module in this case.

refcnt_rv scalar[, newrefcnt]

Works like refcnt, but dereferences the given reference first. This is useful to find the reference count of arrays or hashes, which cnanot be passed directly. Remember that taking a reference of some object increases its reference count, so the reference count used by the *_rv-functions tend to be one higher.

refcnt_inc_rv scalar

Works like refcnt_inc, but dereferences the given reference first.

refcnt_dec_rv scalar

Works like refcnt_dec, but dereferences the given reference first.

ok scalar

uok scalar

rok scalar

pok scalar

nok scalar

niok scalar

Calls SvOK, SvUOK, SvROK, SvPOK, SvNOK or SvNIOK on the given scalar, respectively.

Convert::CharMap is a Perl module that can conversion between Unicode Character Maps.

SYNOPSIS

use Convert::CharMap;
my $map = Convert::CharMap->load(CharMapML => test.xml);
$map->save(UCM => test.ucm);

This module transforms between unicode character map formats, using an in-memory representation of CharMapML as the intermediate format.

Currently is supports the CharMapML, YAML and UCM (write-only) backends; ENC, Iconv and other maps are also planned.