Free convert varchar software for linux

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.

Convert::RACE is a conversion between Unicode and RACE.

SYNOPSIS

use Convert::RACE;

$domain = to_race($utf16str);
$utf16str = from_race($domain);

This module provides functions to convert between RACE (Row-based ASCII-Compatible Encoding) and Unicode Encodings.

RACE converts strings with internationalized characters into strings of US-ASCII that are acceptable as host name parts in current DNS host naming usage.

Convert::Binary::C is a Binary Data Conversion using C Types.

SYNOPSIS

Simple
use Convert::Binary::C;

#---------------------------------------------
# Create a new object and parse embedded code
#---------------------------------------------
my $c = Convert::Binary::C->new->parse( DEC, day => 24 };

my $packed = $c->pack( Date, $date );
Advanced
use Convert::Binary::C;
use Data::Dumper;

#---------------------
# Create a new object
#---------------------
my $c = new Convert::Binary::C ByteOrder => BigEndian;

#---------------------------------------------------
# Add include paths and global preprocessor defines
#---------------------------------------------------
$c->Include( /usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include,
/usr/include )
->Define( qw( __USE_POSIX __USE_ISOC99=1 ) );

#----------------------------------
# Parse the time.h header file
#----------------------------------
$c->parse_file( time.h );

#---------------------------------------
# See which files the object depends on
#---------------------------------------
print Dumper( [$c->dependencies] );

#-----------------------------------------------------------
# See if struct timespec is defined and dump its definition
#-----------------------------------------------------------
if( $c->def( struct timespec ) ) {
print Dumper( $c->struct( timespec ) );
}

#-------------------------------
# Create some binary dummy data
#-------------------------------
my $data = "binaryteststring";

#--------------------------------------------------------
# Unpack $data according to struct timespec definition
#--------------------------------------------------------
if( length($data) >= $c->sizeof( timespec ) ) {
my $perl = $c->unpack( timespec, $data );
print Dumper( $perl );
}

#--------------------------------------------------------
# See which member lies at offset 5 of struct timespec
#--------------------------------------------------------
my $member = $c->member( timespec, 5 );
print "member( timespec, 5 ) = $membern";

Convert::Binary::C is a preprocessor and parser for C type definitions. It is highly configurable and should support arbitrarily complex data structures. Its object-oriented interface has pack and unpack methods that act as replacements for Perls pack and unpack and allow to use the C types instead of a string representation of the data structure for conversion of binary data from and to Perls complex data structures.

Actually, what Convert::Binary::C does is not very different from what a C compiler does, just that it doesnt compile the source code into an object file or executable, but only parses the code and allows Perl to use the enumerations, structs, unions and typedefs that have been defined within your C source for binary data conversion, similar to Perls pack and unpack.

Beyond that, the module offers a lot of convenience methods to retrieve information about the C types that have been parsed.

GD::Convert is a Perl module with additional output formats for GD.

SYNOPSIS

use GD;
use GD::Convert qw(gif=gif_netpbm newFromGif=newFromGif_imagemagick wbmp);
# or:
require GD::Convert;
import GD::Convert;
...
$gd->ppm;
$gd->xpm;
$gd->gif;
$gd->wbmp;
...
$gd = GD::Image->newFromPpmData(...);
$gd = GD::Image->newFromGif(...);

This module provides additional output methods for the GD module: ppm, xpm, wbmp, gif_netpbm and gif_imagemagick, and also additional constructors: newFromPpm, newFromPpmData, newFromGif_netpbm, newFromGifData_netpbm, newFromGif_imagemagick, newFromGifData_imagemagick.

The new methods go into the GD namespace.

For convenience, it is possible to set shorter names for the gif, newFromGif and newFromGifData methods by providing one of the following strings in the import list:

gif=gif_netpbm
newFromGif=newFromGif_netpbm
newFromGifData=newFromGifData_netpbm

Use external commands from netpbm to load and create GIF images.

gif=gif_imagemagick
newFromGif=newFromGif_imagemagick
newFromGifData=newFromGifData_imagemagick

Use external commands from imagemagick to load and create GIF images.

gif=any
newFromGif=any
newFromGifData=any

Use any of the above methods to load and create GIF images.

wbmp

Create wbmp images. Only necessary for GD before version 1.26, but it does not hurt if it is included with newer GD versions.

The new methods and constructors:

$ppmdata = $image->ppm

Take a GD image and return a string with a PPM file as its content.

$xpmdata = $image->xpm

Take a GD image and return a string with a XPM file as its content.

$gifdata = $image->gif_netpbm([...])

Take a GD image and return a string with a GIF file as its content. The conversion will use the ppmtogif binary from netpbm. Make sure that ppmtogif is actually in your PATH. If you specify gif=gif_netpbm in the use line, then you can use the method name gif instead.

The gif_netpbm handles the optional parameter -transparencyhack. If set to a true value, a transparent GIF file will be produced. Note that this will not work if the transparent color occurs also as a normal color.

$gifdata = $image->gif_imagemagick

This is the same as gif_netpbm, instead it is using the convert program of ImageMagick.

$image = GD::Image->newFromPpm($file, [$truecolor])

Create a GD image from the named ppm file or filehandle reference. Only raw ppm files (signature P6) are supported.

$image = GD::Image->newFromPpmData($data, [$truecolor])

Create a GD image from the data string containing ppm data. Only raw ppm files are supported.

$image = GD::Image->newFromGif_netpbm($file, [$truecolor]);

Create a GD image from the named file or filehandle reference using external netpbm programs.

$image = GD::Image->newFromGifData_netpbm($file, [$truecolor]);

Create a GD image from the data string using external netpbm programs.

$image = GD::Image->newFromGif_imagemagick($file, [$truecolor]);

Create a GD image from the named file or filehandle reference using external ImageMagick programs.

$image = GD::Image->newFromGifData_imagemagick($file, [$truecolor]);

Create a GD image from the data string using external ImageMagick programs.

You can set the variable $GD::Convert::DEBUG to a true value to get some information about external commands used while converting.

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::Braille is a Perl module that can convert Between Braille Encodings.

SYNOPSIS

use Convert::Braille;

print brailleAsciiToUnicode ( "HELLO" ), "n";
print brailleDotsToAscii ( "12515123123135" ), "n";

EXPORTS
brailleDotsToUnicode
brailleUnicodeToDots
brailleUnicodeToAscii
brailleAsciiToUnicode
brailleAsciiToDots
brailleDotsToAscii