Free encoding binary software for linux

Search::Binary is a Perl module for generic binary search.

SYNOPSIS

use Seach::Binary;
$pos = binary_search($min, $max, $val, $read, $handle, [$size]);

binary_search implements a generic binary search algorithm returning the position of the first record whose index value is greater than or equal to $val. The search routine does not define any of the terms position, record or index value, but leaves their interpretation and implementation to the user supplied function &$read(). The only restriction is that positions must be integer scalars.

During the search the read function will be called with three arguments: the input parameters $handle and $val, and a position. If the position is not undef, the read function should read the first whole record starting at or after the position; otherwise, the read function should read the record immediately following the last record it read. The search algorithm will guarantee that the first call to the read function will not be with a position of undef. The read function needs to return a two element array consisting of the result of comparing $val with the index value of the read record and the position of the read record. The comparison value must be positive if $val is strictly greater than the index value of the read record, 0 if equal, and negative if strictly less. Furthermore, the returned position value must be greater than or equal to the position the read function was called with.

The input parameters $min and $max are positions and represents the extent of the search. Only records which begin at positions within this range (inclusive) will be searched. Moreover, $min must be the starting position of a record. If present $size is a difference between positions and determines when the algorithms switches to a sequential search. $val is an index value. The value of $handle is of no consequence to the binary search algorithm; it is merely passed as a convenience to the read function.

Encode is a Perl module created to deal with character encodings.

SYNOPSIS

use Encode;

Table of Contents

Encode consists of a collection of modules whose details are too big to fit in one document. This POD itself explains the top-level APIs and general topics at a glance. For other topics and more details, see the PODs below:

Name Description
--------------------------------------------------------
Encode::Alias Alias definitions to encodings
Encode::Encoding Encode Implementation Base Class
Encode::Supported List of Supported Encodings
Encode::CN Simplified Chinese Encodings
Encode::JP Japanese Encodings
Encode::KR Korean Encodings
Encode::TW Traditional Chinese Encodings
--------------------------------------------------------

The Encode module provides the interfaces between Perls strings and the rest of the system. Perl strings are sequences of characters.

The repertoire of characters that Perl can represent is at least that defined by the Unicode Consortium. On most platforms the ordinal values of the characters (as returned by ord(ch)) is the "Unicode codepoint" for the character (the exceptions are those platforms where the legacy encoding is some variant of EBCDIC rather than a super-set of ASCII - see perlebcdic).

Traditionally, computer data has been moved around in 8-bit chunks often called "bytes". These chunks are also known as "octets" in networking standards. Perl is widely used to manipulate data of many types - not only strings of characters representing human or computer languages but also "binary" data being the machines representation of numbers, pixels in an image - or just about anything.

When Perl is processing "binary data", the programmer wants Perl to process "sequences of bytes". This is not a problem for Perl - as a byte has 256 possible values, it easily fits in Perls much larger "logical character".

Scriptol to binary Compiler is a C++ native compiler.

Installation:

It is better to install Scriptol at root of a disk, for example:
c:scriptolc

Once the archive is extracted into the scriptolc directory, you have just to change to this directory to run the compiler.

To use the compiler at command line from any directory, you have to put the compiler into the path variable.

The setup script installs required file into sub-directories, or into the directory given as argument. Before to use the compiler, you have to read the licence, in the doc
directory: licence.html.

Usage:

Just type:
./solc mysource

Type "solc" only to list the options.

If your program is a multi-file project, the source given as parameter must be the main source file, the compiler will know dependencies from "include" statements and will build what is needed.

Exemples:

Type from the main scriptol directory:
./solc -bre demosfibo

Configuring:

By editing the solc.ini file, you may change the second pass compiler (you may have to rebuild the libsol library for this compiler), change the options of the compiler or add header files to include.

To add header files, just add "header=someheader.hpp" lines into the config file.

A xxx.cfg file may be written for each project main source beeing xxx, and if present, it overloads the solc.ini file.

Encode::MIME::Header is a Perl module that contains MIME B and Q header encoding.

SYNOPSIS

use Encode qw/encode decode/;
$utf8 = decode(MIME-Header, $header);
$header = encode(MIME-Header, $utf8);

ABSTRACT

This module implements RFC 2047 Mime Header Encoding. There are 3 variant encoding names; MIME-Header, MIME-B and MIME-Q. The difference is described below

decode() encode()
----------------------------------------------
MIME-Header Both B and Q =?UTF-8?B?....?=
MIME-B B only; Q croaks =?UTF-8?B?....?=
MIME-Q Q only; B croaks =?UTF-8?Q?....?=

When you decode(=?encoding?X?ENCODED WORD?=), ENCODED WORD is extracted and decoded for X encoding (B for Base64, Q for Quoted-Printable). Then the decoded chunk is fed to decode(encoding). So long as encoding is supported by Encode, any source encoding is fine.

When you encode, it just encodes UTF-8 string with X encoding then quoted with =?UTF-8?X?....?= . The parts that RFC 2047 forbids to encode are left as is and long lines are folded within 76 bytes per line.

Encode::HanExtra Perl module contains extra sets of Chinese encodings.



SYNOPSIS

use Encode;

# Traditional Chinese
$euc_tw = encode("euc-tw", $utf8); # loads Encode::HanExtra implicitly
$utf8 = decode("euc-tw", $euc_tw); # ditto

# Simplified Chinese
$gb18030 = encode("gb18030", $utf8); # loads Encode::HanExtra implicitly
$utf8 = decode("gb18030", $gb18030); # ditto

Perl 5.7.3 and later ships with an adequate set of Chinese encodings, including the commonly used CP950, CP936 (also known as GBK), Big5 (alias for Big5-Eten), Big5-HKSCS, EUC-CN, HZ, and ISO-IR-165.

However, the numbers of Chinese encodings are staggering, and a complete coverage will easily increase the size of perl distribution by several megabytes; hence, this CPAN module tries to provide the rest of them.

If you are using perl 5.8 or later, Encode::CN and Encode::TW will automatically load the extra encodings for you, so theres no need to explicitly write use Encode::HanExtra if you are using one of them already.

ENCODINGS

This version includes the following encoding tables:

Canonical Alias Description
-----------------------------------------------------------------------------
big5-1984 /b(tca-)?big5-?(19)?84$/i TCAs original Big5-1984
big5ext /b(cmex-)?big5-?e(xt)?$/i CMEXs Big5e Extension
big5plus /b(cmex-)?big5-?p(lus)?$/i CMEXs Big5+ Extension
/b(cmex-)?big5+$/i
cccii /b(ccag-)?cccii$/i Chinese Character Code for
Information Interchange
cns11643-1 /bCNS[-_ ]?11643[-_]1$/i Taiwans CNS map, plane 1
cns11643-2 /bCNS[-_ ]?11643[-_]2$/i Taiwans CNS map, plane 2
cns11643-3 /bCNS[-_ ]?11643[-_]3$/i Taiwans CNS map, plane 3
cns11643-4 /bCNS[-_ ]?11643[-_]4$/i Taiwans CNS map, plane 4
cns11643-5 /bCNS[-_ ]?11643[-_]5$/i Taiwans CNS map, plane 5
cns11643-6 /bCNS[-_ ]?11643[-_]6$/i Taiwans CNS map, plane 6
cns11643-7 /bCNS[-_ ]?11643[-_]7$/i Taiwans CNS map, plane 7
cns11643-f /bCNS[-_ ]?11643[-_]f$/i Taiwans CNS map, plane F
euc-tw /beuc.*tw$/i EUC (Extended Unix Character)
/btw.*euc$/i
gb18030 /bGB[-_ ]?18030$/i GBK with Traditional Characters
unisys /bunisys$/i Unisys Traditional Chinese
unisys-sosi1 Unisys SOSI1 transport encoding
unisys-sosi2 Unisys SOSI2 transport encoding

Detailed descriptions are as follows:

BIG5-1984

This is the original Big5 encoding made by TCA Taiwan.

BIG5PLUS

This encoding, while not heavily used, is an attempt to bring all Taiwans conflicting internal-use encodings together, and fit it as an extension to the widely-deployed Big5 range, by CMEX Taiwan.

BIG5EXT

The CMEXs second (and less ambitious) try at unifying the most commonly used characters not covered by Big5, while not polluting out of the 94x94 arragement like BIG5PLUS did.

CCCII

The earliest (and most sophisticated) Traditional Chinese encoding, with a three-byte raw character map, made in 1980 by the Chinese Character Analysis Group (CCAG), used mostly in library systems.

EUC-TW

The EUC transport version of CNS11643 (planes 1-7), the comprehensive character set used by the Taiwan government.

CNS11643-*

The raw character map extracted from the Unihan database, including the plane F which wasnt included in EUC-TW.

GB18030

An extension to GBK, this encoding lists most Han characters (both simplified and traditional), as well as some other encodings used by other peoples in China.

UNISYS

Unisys Systems internal Chinese mapping.

TXTCOD is an encoding module using the SAC system.

SYNOPSIS

use TXTCOD;

TXTCOD::codage($source,
$destination,
< $file.cod >,
< $algorithm.alc >,
< $param >);

$param = TXTCOD::decodage($source,
$destination,
$file.cod,
< $algorithm.alc >);
$file.cod = TXTCOD::createcod;

TXTCOD 4.7 encodes files with the SAC system, 2.4 version..

The SAC system consists in several algorithms : a default algorithm who can be remplaced by user-written algorithms. Every algorithm uses a .cod file generated by the module and who contains a list of random numbers used by the module in order to ensure a maximal protection.

B>

This version of the SAC system can encode any type of file (binary files, text) and recognizes automatically their type.

In the first part you will see the modules how-to and in the second part how to program an algorithm.

FIRST PART : TXTCOD Module

These functions will be accessible after you have typed B>
1) Encoding

You call the encoding function by typing :

TXTCOD::codage($source,
$destination,
< $file.cod >,
< $algorithm.alc >,
< $param >);
This function doesnt return any value.

$source is the file you want to encode.
$destination is the file where TXTCOD will send the result of the encoding.

These two parameters are B>.

$file.cod is the .cod file who is indispensable for the encoding and the decoding. If you dont specify this parameter, will search a "[year].cod" file, for example "2003.cod". A .cod file MUST be changed every year at least in order to assure an optimal protection.

$algorithm.alc is the used algorithm. If you dont put anything, TXTCOD will use the default algorithm.

$param is an user-defined parameter who wont be crypted.
2) Decoding

You call the decoding function by typing :

$param = TXTCOD::decodage($source,
$destination,
$file.cod,
);

$source in the file you want to decode.
$destination is the result of the decoding
$file.cod et $algorithm.alc -> see the encoding function description.

The returned value is the parameter you optionnally defined while the encoding and which isnt crypted.

3) .cod files creation

To create a .cod file type :

$file.cod = TXTCOD::createcod;
The returned value is the files name ("[year].cod")

Bundle::Encode is a Perl bundle to install Encode modules and dependencies.

SYNOPSIS

perl -MCPAN -e install Bundle::Encode

CONTENTS

Text::Iconv
Module::Build
Module::Build::Compat
Test::Simple
Test::More
Unicode::Japanese
CGI
ExtUtils::CBuilder
XML::Parser::Expat
IO::File
MIME::Base64
Getopt::Std
Getopt::Long
Unicode::Normalize
Font::TTF
Compress::Zlib
Spiffy
Cwd
File::Find
File::Path
FindBin
Config
Test::Builder
Test::Base
HTML::Entities::Pictogram
XSLoader
IDNA::Punycode
Net::IDN::Nameprep
Unicode::Normalize
Unicode::String
Scalar::Util
Encoding::BER
encoding::split
encoding::warnings
HTML::Encoding
Term::Encoding
XML::Encoding
Template::Provider::Encoding
Catalyst::Plugin::Unicode::Encoding
Email::MIME::Encodings
Convert::Charmap
Encode
Encode::IBM
Encode::compat
Encode::InCharset
Encode::JIS2K
Encode::ZapCP1252
Encode::Unicode::Japanese
Encode::HEBCI
Encode::Detect
Encode::HanConvert
Encode::Registry
Encode::TECkit
Encode::UTR22
Encode::DoubleEncodedUTF8
Encode::First
Encode::JavaScript::UCS
Encode::JP::Mobile
Encode::Punycode
Encode::BOCU1
Encode::BOCU1::XS
Encode::EUCJPMS
Encode::CNMap
Encode::Unicode::UTF7
Encode::IMAPUTF7
Encode::Mapper