recode - phpMan

File: recode.info, Node: Top, Next: Tutorial, Prev: (dir), Up: (dir)

`recode'
********

This recoding library converts files between various coded character
sets and surface encodings. When this cannot be achieved exactly, it
may get rid of the offending characters or fall back on approximations.
The library recognises or produces more than 300 different character
sets and is able to convert files between almost any pair. Most
RFC 1345 character sets, and all `libiconv' character sets, are
supported. The `recode' program is a handy front-end to the library.

The current `recode' release is 3.6.

* Menu:

* Tutorial:: Quick Tutorial
* Introduction:: Terminology and purpose
* Invoking recode:: How to use this program
* Library:: A recoding library
* Universal:: The universal charset
* libiconv:: The `iconv' library
* Tabular:: Tabular sources (RFC 1345)
* ASCII misc:: ASCII and some derivatives
* IBM and MS:: Some IBM or Microsoft charsets
* CDC:: Charsets for CDC machines
* Micros:: Other micro-computer charsets
* Miscellaneous:: Various other charsets
* Surfaces:: All about surfaces
* Internals:: Internal aspects
* Concept Index:: Concept Index
* Option Index:: Option Index
* Library Index:: Library Index
* Charset and Surface Index:: Charset and Surface Index

--- The Detailed Node Listing ---

Terminology and purpose

* Charset overview:: Overview of charsets
* Surface overview:: Overview of surfaces
* Contributing:: Contributions and bug reports

How to use this program

* Synopsis:: Synopsis of `recode' call
* Requests:: The REQUEST parameter
* Listings:: Asking for various lists
* Recoding:: Controlling how files are recoded
* Reversibility:: Reversibility issues
* Sequencing:: Selecting sequencing methods
* Mixed:: Using mixed charset input
* Emacs:: Using `recode' within Emacs
* Debugging:: Debugging considerations

A recoding library

* Outer level:: Outer level functions
* Request level:: Request level functions
* Task level:: Task level functions
* Charset level:: Charset level functions
* Errors:: Handling errors

The universal charset

* UCS-2:: Universal Character Set, 2 bytes
* UCS-4:: Universal Character Set, 4 bytes
* UTF-7:: Universal Transformation Format, 7 bits
* UTF-8:: Universal Transformation Format, 8 bits
* UTF-16:: Universal Transformation Format, 16 bits
* count-characters:: Frequency count of characters
* dump-with-names:: Fully interpreted UCS dump

ASCII and some derivatives

* ASCII:: Usual ASCII
* ISO 8859:: ASCII extended by Latin Alphabets
* ASCII-BS:: ASCII 7-bits, BS to overstrike
* flat:: ASCII without diacritics nor underline

Some IBM or Microsoft charsets

* EBCDIC:: EBCDIC codes
* IBM-PC:: IBM's PC code
* Icon-QNX:: Unisys' Icon code

Charsets for CDC machines

* Display Code:: Control Data's Display Code
* CDC-NOS:: ASCII 6/12 from NOS
* Bang-Bang:: ASCII ``bang bang''

Other micro-computer charsets

* Apple-Mac:: Apple's Macintosh code
* AtariST:: Atari ST code

Various other charsets

* HTML:: World Wide Web representations
* LaTeX:: LaTeX macro calls
* Texinfo:: GNU project documentation files
* Vietnamese:: Vietnamese charsets
* African:: African charsets
* Others:: Cyrillic and other charsets
* Texte:: Easy French conventions
* Mule:: Mule as a multiplexed charset

All about surfaces

* Permutations:: Permuting groups of bytes
* End lines:: Representation for end of lines
* MIME:: MIME contents encodings
* Dump:: Interpreted character dumps
* Test:: Artificial data for testing

Internal aspects

* Main flow:: Overall organisation
* New charsets:: Adding new charsets
* New surfaces:: Adding new surfaces
* Design:: Comments on the library design

File: recode.info, Node: Tutorial, Next: Introduction, Prev: Top, Up: Top

Quick Tutorial
**************

So, really, you just are in a hurry to use `recode', and do not feel
like studying this manual? Even reading this paragraph slows you down?
We might have a problem, as you will have to do some guess work, and
might not become very proficient unless you have a very solid
intuition....

Let me use here, as a quick tutorial, an actual reply of mine to a
`recode' user, who writes:

My situation is this--I occasionally get email with special
characters in it. Sometimes this mail is from a user using IBM
software and sometimes it is a user using Mac software. I myself
am on a SPARC Solaris machine.

Your situation is similar to mine, except that I _often_ receive
email needing recoding, that is, much more than _occasionally_! The
usual recodings I do are Mac to Latin-1, IBM page codes to Latin-1,
Easy-French to Latin-1, remove Quoted-Printable, remove Base64. These
are so frequent that I made myself a few two-keystroke Emacs commands
to filter the Emacs region. This is very convenient for me. I also
resort to many other email conversions, yet more rarely than the
frequent cases above.

It _seems_ like this should be doable using `recode'. However,
when I try something like `grecode mac macfile.txt' I get nothing
out--no error, no output, nothing.

Presuming you are using some recent version of `recode', the command:

recode mac macfile.txt

is a request for recoding `macfile.txt' over itself, overwriting the
original, from Macintosh usual character code and Macintosh end of
lines, to Latin-1 and Unix end of lines. This is overwrite mode. If
you want to use `recode' as a filter, which is probably what you need,
rather do:

recode mac

and give your Macintosh file as standard input, you'll get the Latin-1
file on standard output. The above command is an abbreviation for any
of:

recode mac..
recode mac..l1
recode mac..Latin-1
recode mac/CR..Latin-1/
recode Macintosh..ISO_8859-1
recode Macintosh/CR..ISO_8859-1/

That is, a `CR' surface, encoding newlines with ASCII <CR>, is first
to be removed (this is a default surface for `mac'), then the Macintosh
charset is converted to Latin-1 and no surface is added to the result
(there is no default surface for `l1'). If you want `mac' code
converted, but you know that newlines are already coded the Unix way,
just do:

recode mac/

the slash then overriding the default surface with empty, that is, none.
Here are other easy recipes:

recode pc to filter IBM-PC code and CR-LF (default) to Latin-1
recode pc/ to filter IBM-PC code to Latin-1
recode 850 to filter code page 850 and CR-LF (default) to Latin-1
recode 850/ to filter code page 850 to Latin-1
recode /qp to remove quoted printable

The last one is indeed equivalent to any of:

recode /qp..
recode l1/qp..l1/
recode ISO_8859-1/Quoted-Printable..ISO_8859-1/

Here are some reverse recipes:

recode ..mac to filter Latin-1 to Macintosh code and CR (default)
recode ..mac/ to filter Latin-1 to Macintosh code
recode ..pc to filter Latin-1 to IBM-PC code and CR-LF (default)
recode ..pc/ to filter Latin-1 to IBM-PC code
recode ..850 to filter Latin-1 to code page 850 and CR-LF (default)
recode ..850/ to filter Latin-1 to code page 850
recode ../qp to force quoted printable

In all the above calls, replace `recode' by `recode -f' if you want
to proceed despite recoding errors. If you do not use `-f' and there
is an error, the recoding output will be interrupted after first error
in filter mode, or the file will not be replaced by a recoded copy in
overwrite mode.

You may use `recode -l' to get a list of available charsets and
surfaces, and `recode --help' to get a quick summary of options. The
above output is meant for those having already read this manual, so let
me dare a suggestion: why could not you find a few more minutes in your
schedule to peek further down, right into the following chapters!

File: recode.info, Node: Introduction, Next: Invoking recode, Prev: Tutorial, Up: Top

Terminology and purpose
***********************

A few terms are used over and over in this manual, our wise reader
will learn their meaning right away. Both ISO (International
Organization for Standardisation) and IETF (Internet Engineering Task
Force) have their own terminology, this document does not try to stick
to either one in a strict way, while it does not want to throw more
confusion in the field. On the other hand, it would not be efficient
using paraphrases all the time, so `recode' coins a few short words,
which are explained below.

A "charset", in the context of `recode', is a particular association
between computer codes on one side, and a repertoire of intended
characters on the other side. Codes are usually taken from a set of
consecutive small integers, starting at 0. Some characters have a
graphical appearance (glyph) or displayable effect, others have special
uses like, for example, to control devices or to interact with
neighbouring codes to specify them more precisely. So, a _charset_ is
roughly one of those tables, giving a meaning to each of the codes from
the set of allowable values. MIME also uses the term charset with
approximately the same meaning. It does _not_ exactly corresponds to
what ISO calls a "coded character set", that is, a set of characters
with an encoding for them. An coded character set does not necessarily
use all available code positions, while a MIME charset usually tries to
specify them all. A MIME charset might be the union of a few disjoint
coded character sets.

A "surface" is a term used in `recode' only, and is a short for
surface transformation of a charset stream. This is any kind of
mapping, usually reversible, which associates physical bits in some
medium for a stream of characters taken from one or more charsets
(usually one). A surface is a kind of varnish added over a charset so
it fits in actual bits and bytes. How end of lines are exactly encoded
is not really pertinent to the charset, and so, there is surface for
end of lines. `Base64' is also a surface, as we may encode any charset
in it. Other examples would `DES' enciphering, or `gzip' compression
(even if `recode' does not offer them currently): these are ways to give
a real life to theoretical charsets. The "trivial" surface consists
into putting characters into fixed width little chunks of bits, usually
eight such bits per character. But things are not always that simple.

This `recode' library, and the program by that name, have the purpose
of converting files between various charsets and surfaces. When this
cannot be done in exact ways, as it is often the case, the program may
get rid of the offending characters or fall back on approximations.
This library recognises or produces around 175 such charsets under 500
names, and handle a dozen surfaces. Since it can convert each charset
to almost any other one, many thousands of different conversions are
possible.

The `recode' program and library do not usually know how to split and
sort out textual and non-textual information which may be mixed in a
single input file. For example, there is no surface which currently
addresses the problem of how lines are blocked into physical records,
when the blocking information is added as binary markers or counters
within files. So, `recode' should be given textual streams which are
rather _pure_.

This tool pays special attention to superimposition of diacritics for
some French representations. This orientation is mostly historical, it
does not impair the usefulness, generality or extensibility of the
program. `recode' is both a French and English word. For those who
pay attention to those things, the proper pronunciation is French (that
is, `racud', with `a' like in `above', and `u' like in `cut').

The program `recode' has been written by Franc,ois Pinard. With
time, it got to reuse works from other contributors, and notably, those
of Keld Simonsen and Bruno Haible.

* Menu:

* Charset overview:: Overview of charsets
* Surface overview:: Overview of surfaces
* Contributing:: Contributions and bug reports

File: recode.info, Node: Charset overview, Next: Surface overview, Prev: Introduction, Up: Introduction

Overview of charsets
====================

Recoding is currently possible between many charsets, the bulk of
which is described by RFC 1345 tables or available in the `iconv'
library. *Note Tabular::, and *note libiconv::. The `recode' library
also handles some charsets in some specialised ways. These are:

* 6-bit charsets based on CDC display code: 6/12 code from NOS;
bang-bang code from Universite' de Montre'al;

* 7-bit ASCII: without any diacritics, or else: using backspace for
overstriking; Unisys' Icon convention; TeX/LaTeX coding; easy
French conventions for electronic mail;

* 8-bit extensions to ASCII: ISO Latin-1, Atari ST code, IBM's code
for the PC, Apple's code for the Macintosh;

* 8-bit non-ASCII codes: three flavours of EBCDIC;

* 16-bit or 31-bit universal characters, and their transfer
encodings.

The introduction of RFC 1345 in `recode' has brought with it a few
charsets having the functionality of older ones, but yet being different
in subtle ways. The effects have not been fully investigated yet, so
for now, clashes are avoided, the old and new charsets are kept well
separate.

Conversion is possible between almost any pair of charsets. Here is
a list of the exceptions. One may not recode _from_ the `flat',
`count-characters' or `dump-with-names' charsets, nor _from_ or _to_
the `data', `tree' or `:libiconv:' charsets. Also, if we except the
`data' and `tree' pseudo-charsets, charsets and surfaces live in
disjoint recoding spaces, one cannot really transform a surface into a
charset or vice-versa, as surfaces are only meant to be applied over
charsets, or removed from them.

File: recode.info, Node: Surface overview, Next: Contributing, Prev: Charset overview, Up: Introduction

Overview of surfaces
====================

For various practical considerations, it sometimes happens that the
codes making up a text, written in a particular charset, cannot simply
be put out in a file one after another without creating problems or
breaking other things. Sometimes, 8-bit codes cannot be written on a
7-bit medium, variable length codes need kind of envelopes, newlines
require special treatment, etc. We sometimes have to apply "surfaces"
to a stream of codes, which surfaces are kind of tricks used to fit the
charset into those practical constraints. Moreover, similar surfaces
or tricks may be useful for many unrelated charsets, and many surfaces
can be used at once over a single charset.

So, `recode' has machinery to describe a combination of a charset
with surfaces used over it in a file. We would use the expression "pure
charset" for referring to a charset free of any surface, that is, the
conceptual association between integer codes and character intents.

It is not always clear if some transformation will yield a charset
or a surface, especially for those transformations which are only
meaningful over a single charset. The `recode' library is not overly
picky as identifying surfaces as such: when it is practical to consider
a specialised surface as if it were a charset, this is preferred, and
done.

File: recode.info, Node: Contributing, Prev: Surface overview, Up: Introduction

Contributions and bug reports
=============================

Even being the `recode' author and current maintainer, I am no
specialist in charset standards. I only made `recode' along the years
to solve my own needs, but felt it was applicable for the needs of
others. Some FSF people liked the program structure and suggested to
make it more widely available. I often rely on `recode' users
suggestions to decide what is best to be done next.

Properly protecting `recode' about possible copyright fights is a
pain for me and for contributors, but we cannot avoid addressing the
issue in the long run. Besides, the Free Software Foundation, which
mandates the GNU project, is very sensible to this matter. GNU
standards suggest that we stay cautious before looking at copyrighted
code. The safest and simplest way for me is to gather ideas and
reprogram them anew, even if this might slow me down considerably. For
contributions going beyond a few lines of code here and there, the FSF
definitely requires employer disclaimers and copyright assignments in
writing.

When you contribute something to `recode', _please_ explain what it
is about. Do not take for granted that I know those charsets which are
familiar to you. Once again, I'm no expert, and you have to help me.
Your explanations could well find their way into this documentation,
too. Also, for contributing new charsets or new surfaces, as much as
possible, please provide good, solid, verifiable references for the
tables you used(1).

Many users contributed to `recode' already, I am grateful to them for
their interest and involvement. Some suggestions can be integrated
quickly while some others have to be delayed, I have to draw a line
somewhere when time comes to make a new release, about what would go in
it and what would go in the next.

Please send suggestions, documentation errors and bug reports to
<recode-bugs AT iro.ca> or, if you prefer, directly to
<pinard AT iro.ca>, Franc,ois Pinard. Do not be afraid to
report details, because this program is the mere aggregation of
hundreds of details.

---------- Footnotes ----------

(1) I'm not prone at accepting a charset you just invented, and
which nobody uses yet: convince your friends and community first!

File: recode.info, Node: Invoking recode, Next: Library, Prev: Introduction, Up: Top

How to use this program
***********************

With the synopsis of the `recode' call, we stress the difference
between using this program as a file filter, or recoding many files at
once. The first parameter of any call states the recoding request, and
this deserves a section on its own. Options are then presented, but
somewhat grouped according to the related functionalities they control.

* Menu:

File: recode.info, Node: Synopsis, Next: Requests, Prev: Invoking recode, Up: Invoking recode

Synopsis of `recode' call
=========================

The general format of the program call is one of:

recode [OPTION]... [CHARSET | REQUEST [FILE]... ]

Some calls are used only to obtain lists produced by `recode' itself,
without actually recoding any file. They are recognised through the
usage of listing options, and these options decide what meaning should
be given to an optional CHARSET parameter. *Note Listings::.

In other calls, the first parameter (REQUEST) always explains which
transformations are expected on the files. There are many variations to
the aspect of this parameter. We will discuss more complex situations
later (*note Requests::), but for many simple cases, this parameter
merely looks like this(1):

BEFORE..AFTER

where BEFORE and AFTER each gives the name of a charset. Each FILE
will be read assuming it is coded with charset BEFORE, it will be
recoded over itself so to use the charset AFTER. If there is no FILE
on the `recode' command, the program rather acts as a Unix filter and
transforms standard input onto standard output.

The capability of recoding many files at once is very convenient.
For example, one could easily prepare a distribution from Latin-1 to
MSDOS, this way:

mkdir package
cp -p Makefile *.[ch] package
recode Latin-1..MSDOS package/*
zoo ah package.zoo package/*
rm -rf package

(In this example, the non-mandatory `-p' option to `cp' is for
preserving timestamps, and the `zoo' program is an archiver from Rahul
Dhesi which once was quite popular.)

The filter operation is especially useful when the input files should
not be altered. Let us make an example to illustrate this point.
Suppose that someone has a file named `datum.txt', which is almost a
TeX file, except that diacriticised characters are written using
Latin-1. To complete the recoding of the diacriticised characters
_only_ and produce a file `datum.tex', without destroying the original,
one could do:

cp -p datum.txt datum.tex
recode -d l1..tex datum.tex

However, using `recode' as a filter will achieve the same goal more
neatly:

recode -d l1..tex <datum.txt >datum.tex

This example also shows that `l1' could be used instead of
`Latin-1'; charset names often have such aliases.

---------- Footnotes ----------

(1) In previous versions or `recode', a single colon `:' was used
instead of the two dots `..' for separating charsets, but this was
creating problems because colons are allowed in official charset names.
The old request syntax is still recognised for compatibility purposes,
but is deprecated.

File: recode.info, Node: Requests, Next: Listings, Prev: Synopsis, Up: Invoking recode

The REQUEST parameter
=====================

In the case where the REQUEST is merely written as BEFORE..AFTER,
then BEFORE and AFTER specify the start charset and the goal charset
for the recoding.

For `recode', charset names may contain any character, besides a
comma, a forward slash, or two periods in a row. But in practice,
charset names are currently limited to alphabetic letters (upper or
lower case), digits, hyphens, underlines, periods, colons or round
parentheses.

The complete syntax for a valid REQUEST allows for unusual things,
which might surprise at first. (Do not pay too much attention to these
facilities on first reading.) For example, REQUEST may also contain
intermediate charsets, like in the following example:

BEFORE..INTERIM1..INTERIM2..AFTER

meaning that `recode' should internally produce the INTERIM1 charset
from the start charset, then work out of this INTERIM1 charset to
internally produce INTERIM2, and from there towards the goal charset.
In fact, `recode' internally combines recipes and automatically uses
interim charsets, when there is no direct recipe for transforming
BEFORE into AFTER. But there might be many ways to do it. When many
routes are possible, the above "chaining" syntax may be used to more
precisely force the program towards a particular route, which it might
not have naturally selected otherwise. On the other hand, because
`recode' tries to choose good routes, chaining is only needed to
achieve some rare, unusual effects.

Moreover, many such requests (sub-requests, more precisely) may be
separated with commas (but no spaces at all), indicating a sequence of
recodings, where the output of one has to serve as the input of the
following one. For example, the two following requests are equivalent:

BEFORE..INTERIM1..INTERIM2..AFTER
BEFORE..INTERIM1,INTERIM1..INTERIM2,INTERIM2..AFTER

In this example, the charset input for any recoding sub-request is
identical to the charset output by the preceding sub-request. But it
does not have to be so in the general case. One might wonder what
would be the meaning of declaring the charset input for a recoding
sub-request of being of different nature than the charset output by a
preceding sub-request, when recodings are chained in this way. Such a
strange usage might have a meaning and be useful for the `recode'
expert, but they are quite uncommon in practice.

More useful is the distinction between the concept of charset, and
the concept of surfaces. An encoded charset is represented by:

PURE-CHARSET/SURFACE1/SURFACE2...

using slashes to introduce surfaces, if any. The order of application
of surfaces is usually important, they cannot be freely commuted. In
the given example, SURFACE1 is first applied over the PURE-CHARSET,
then SURFACE2 is applied over the result. Given this request:

BEFORE/SURFACE1/SURFACE2..AFTER/SURFACE3

the `recode' program will understand that the input files should have
SURFACE2 removed first (because it was applied last), then SURFACE1
should be removed. The next step will be to translate the codes from
charset BEFORE to charset AFTER, prior to applying SURFACE3 over the
result.

Some charsets have one or more _implied_ surfaces. In this case, the
implied surfaces are automatically handled merely by naming the charset,
without any explicit surface to qualify it. Let's take an example to
illustrate this feature. The request `pc..l1' will indeed decode MS-DOS
end of lines prior to converting IBM-PC codes to Latin-1, because `pc'
is the name of a charset(1) which has `CR-LF' for its usual surface.
The request `pc/..l1' will _not_ decode end of lines, since the slash
introduces surfaces, and even if the surface list is empty, it
effectively defeats the automatic removal of surfaces for this charset.
So, empty surfaces are useful, indeed!

Both charsets and surfaces may have predefined alternate names, or
aliases. However, and this is rather important to understand, implied
surfaces are attached to individual aliases rather than on genuine
charsets. Consequently, the official charset name and all of its
aliases do not necessarily share the same implied surfaces. The
charset and all its aliases may each have its own different set of
implied surfaces.

Charset names, surface names, or their aliases may always be
abbreviated to any unambiguous prefix. Internally in `recode',
disambiguating tables are kept separate for charset names and surface
names.

While recognising a charset name or a surface name (or aliases
thereof), `recode' ignores all characters besides letters and digits,
so for example, the hyphens and underlines being part of an official
charset name may safely be omitted (no need to un-confuse them!).
There is also no distinction between upper and lower case for charset
or surface names.

One of the BEFORE or AFTER keywords may be omitted. If the double
dot separator is omitted too, then the charset is interpreted as the
BEFORE charset.(2)

When a charset name is omitted or left empty, the value of the
`DEFAULT_CHARSET' variable in the environment is used instead. If this
variable is not defined, the `recode' library uses the current locale's
encoding. On POSIX compliant systems, this depends on the first
non-empty value among the environment variables LC_ALL, LC_CTYPE, LANG,
and can be determined through the command `locale charmap'.

If the charset name is omitted but followed by surfaces, the surfaces
then qualify the usual or default charset. For example, the request
`../x' is sufficient for applying an hexadecimal surface to the input
text(3).

The allowable values for BEFORE or AFTER charsets, and various
surfaces, are described in the remainder of this document.

---------- Footnotes ----------

(1) More precisely, `pc' is an alias for the charset `IBM-PC'.

(2) Both BEFORE and AFTER may be omitted, in which case the double
dot separator is mandatory. This is not very useful, as the recoding
reduces to a mere copy in that case.

(3) MS-DOS is one of those systems for which the default charset has
implied surfaces, `CR-LF' here. Such surfaces are automatically
removed or applied whenever the default charset is read or written,
exactly as it would go for any other charset. In the example above, on
such systems, the hexadecimal surface would then _replace_ the implied
surfaces. For _adding_ an hexadecimal surface without removing any,
one should write the request as `/../x'.

File: recode.info, Node: Listings, Next: Recoding, Prev: Requests, Up: Invoking recode

Asking for various lists
========================

Many options control listing output generated by `recode' itself,
they are not meant to accompany actual file recodings. These options
are:

`--version'
The program merely prints its version numbers on standard output,
and exits without doing anything else.

`--help'
The program merely prints a page of help on standard output, and
exits without doing any recoding.

`-C'
`--copyright'
Given this option, all other parameters and options are ignored.
The program prints briefly the copyright and copying conditions.
See the file `COPYING' in the distribution for full statement of
the Copyright and copying conditions.

`-h[LANGUAGE/][NAME]'
`--header[=[LANGUAGE/][NAME]]'
Instead of recoding files, `recode' writes a LANGUAGE source file
on standard output and exits. This source is meant to be included
in a regular program written in the same programming LANGUAGE: its
purpose is to declare and initialise an array, named NAME, which
represents the requested recoding. The only acceptable values for
LANGUAGE are `c' or `perl', and may may be abbreviated. If
LANGUAGE is not specified, `c' is assumed. If NAME is not
specified, then it defaults to `BEFORE_AFTER'. Strings BEFORE and
AFTER are cleaned before being used according to the syntax of
LANGUAGE.

Even if `recode' tries its best, this option does not always
succeed in producing the requested source table. It will however,
provided the recoding can be internally represented by only one
step after the optimisation phase, and if this merged step conveys
a one-to-one or a one-to-many explicit table. Also, when
attempting to produce sources tables, `recode' relaxes its
checking a tiny bit: it ignores the algorithmic part of some
tabular recodings, it also avoids the processing of implied
surfaces. But this is all fairly technical. Better try and see!

Beware that other options might affect the produced source tables,
these are: `-d', `-g' and, particularly, `-s'.

`-k PAIRS'
`--known=PAIRS'
This particular option is meant to help identifying an unknown
charset, using as hints some already identified characters of the
charset. Some examples will help introducing the idea.

Let's presume here that `recode' is run in an ISO-8859-1 locale,
and that `DEFAULT_CHARSET' is unset in the environment. Suppose
you have guessed that code 130 (decimal) of the unknown charset
represents a lower case `e' with an acute accent. That is to say
that this code should map to code 233 (decimal) in the usual
charset. By executing:

recode -k 130:233

you should obtain a listing similar to:

AtariST atarist
CWI cphu cwi cwi2
IBM437 437 cp437 ibm437
IBM850 850 cp850 ibm850
IBM851 851 cp851 ibm851
IBM852 852 cp852 ibm852
IBM857 857 cp857 ibm857
IBM860 860 cp860 ibm860
IBM861 861 cp861 cpis ibm861
IBM863 863 cp863 ibm863
IBM865 865 cp865 ibm865

You can give more than one clue at once, to restrict the list
further. Suppose you have _also_ guessed that code 211 of the
unknown charset represents an upper case `E' with diaeresis, that
is, code 203 in the usual charset. By requesting:

recode -k 130:233,211:203

you should obtain:

IBM850 850 cp850 ibm850
IBM852 852 cp852 ibm852
IBM857 857 cp857 ibm857

The usual charset may be overridden by specifying one non-option
argument. For example, to request the list of charsets for which
code 130 maps to code 142 for the Macintosh, you may ask:

recode -k 130:142 mac

and get:

which, of course, is identical to the result of the first example,
since the code 142 for the Macintosh is a small `e' with acute.

More formally, option `-k' lists all possible _before_ charsets
for the _after_ charset given as the sole non-option argument to
`recode', but subject to restrictions given in PAIRS. If there is
no non-option argument, the _after_ charset is taken to be the
default charset for this `recode'.

The restrictions are given as a comma separated list of pairs,
each pair consisting of two numbers separated by a colon. The
numbers are taken as decimal when the initial digit is between `1'
and `9'; `0x' starts an hexadecimal number, or else `0' starts an
octal number. The first number is a code in any _before_ charset,
while the second number is a code in the specified _after_ charset.
If the first number would not be transformed into the second
number by recoding from some _before_ charset to the _after_
charset, then this _before_ charset is rejected. A _before_
charset is listed only if it is not rejected by any pair. The
program will only test those _before_ charsets having a tabular
style internal description (*note Tabular::), so should be the
selected _after_ charset.

The produced list is in fact a subset of the list produced by the
option `-l'. As for option `-l', the non-option argument is
interpreted as a charset name, possibly abbreviated to any non
ambiguous prefix.

`-l[FORMAT]'
`--list[=FORMAT]'
This option asks for information about all charsets, or about one
particular charset. No file will be recoded.

If there is no non-option arguments, `recode' ignores the FORMAT
value of the option, it writes a sorted list of charset names on
standard output, one per line. When a charset name have aliases
or synonyms, they follow the true charset name on its line, sorted
from left to right. Each charset or alias is followed by its
implied surfaces, if any. This list is over two hundred lines.
It is best used with `grep -i', as in:

recode -l | grep -i greek

There might be one non-option argument, in which case it is
interpreted as a charset name, possibly abbreviated to any non
ambiguous prefix. This particular usage of the `-l' option is
obeyed _only_ for charsets having a tabular style internal
description (*note Tabular::). Even if most charsets have this
property, some do not, and the option `-l' cannot be used to
detail these particular charsets. For knowing if a particular
charset can be listed this way, you should merely try and see if
this works. The FORMAT value of the option is a keyword from the
following list. Keywords may be abbreviated by dropping suffix
letters, and even reduced to the first letter only:

`decimal'
This format asks for the production on standard output of a
concise tabular display of the charset, in which character
code values are expressed in decimal.

`octal'
This format uses octal instead of decimal in the concise
tabular display of the charset.

`hexadecimal'
This format uses hexadecimal instead of decimal in the
concise tabular display of the charset.

`full'
This format requests an extensive display of the charset on
standard output, using one line per character showing its
decimal, hexadecimal, octal and `UCS-2' code values, and also
a descriptive comment which should be the 10646 name for the
character.

The descriptive comment is given in English and ASCII, yet if
the English description is not available but a French one is,
then the French description is given instead, using Latin-1.
However, if the `LANGUAGE' or `LANG' environment variable
begins with the letters `fr', then listing preference goes to
French when both descriptions are available.

When option `-l' is used together with a CHARSET argument, the
FORMAT defaults to `decimal'.

`-T'
`--find-subsets'
This option is a maintainer tool for evaluating the redundancy of
those charsets, in `recode', which are internally represented by
an `UCS-2' data table. After the listing has been produced, the
program exits without doing any recoding. The output is meant to
be sorted, like this: `recode -T | sort'. The option triggers
`recode' into comparing all pairs of charsets, seeking those which
are subsets of others. The concept and results are better
explained through a few examples. Consider these three sample
lines from `-T' output:

[ 0] IBM891 == IBM903
[ 1] IBM1004 < CP1252
[ 12] INVARIANT < CSA_Z243.4-1985-1

The first line means that `IBM891' and `IBM903' are completely
identical as far as `recode' is concerned, so one is fully
redundant to the other. The second line says that `IBM1004' is
wholly contained within `CP1252', yet there is a single character
which is in `CP1252' without being in `IBM1004'. The third line
says that `INVARIANT' is wholly contained within
`CSA_Z243.4-1985-1', but twelve characters are in
`CSA_Z243.4-1985-1' without being in `INVARIANT'. The whole
output might most probably be reduced and made more significant
through a transitivity study.

File: recode.info, Node: Recoding, Next: Reversibility, Prev: Listings, Up: Invoking recode

Controlling how files are recoded
=================================

The following options have the purpose of giving the user some fine
grain control over the recoding operation themselves.

`-c'
`--colons'
With `Texte' Easy French conventions, use the column `:' instead
of the double-quote `"' for marking diaeresis. *Note Texte::.

`-g'
`--graphics'
This option is only meaningful while getting _out_ of the `IBM-PC'
charset. In this charset, characters 176 to 223 are used for
constructing rulers and boxes, using simple or double horizontal or
vertical lines. This option forces the automatic selection of
ASCII characters for approximating these rulers and boxes, at cost
of making the transformation irreversible. Option `-g' implies
`-f'.

`-t'
`--touch'
The _touch_ option is meaningful only when files are recoded over
themselves. Without it, the time-stamps associated with files are
preserved, to reflect the fact that changing the code of a file
does not really alter its informational contents. When the user
wants the recoded files to be time-stamped at the recoding time,
this option inhibits the automatic protection of the time-stamps.

`-v'
`--verbose'
Before doing any recoding, the program will first print on the
`stderr' stream the list of all intermediate charsets planned for
recoding, starting with the BEFORE charset and ending with the
AFTER charset. It also prints an indication of the recoding
quality, as one of the word `reversible', `one to one', `one to
many', `many to one' or `many to many'.

This information will appear once or twice. It is shown a second
time only when the optimisation and step merging phase succeeds in
replacing many single steps by a new one.

This option also has a second effect. The program will print on
`stderr' one message per recoded FILE, so as to keep the user
informed of the progress of its command.

An easy way to know beforehand the sequence or quality of a
recoding is by using the command such as:

recode -v BEFORE..AFTER < /dev/null

using the fact that, in `recode', an empty input file produces an
empty output file.

`-x CHARSET'
`--ignore=CHARSET'
This option tells the program to ignore any recoding path through
the specified CHARSET, so disabling any single step using this
charset as a start or end point. This may be used when the user
wants to force `recode' into using an alternate recoding path (yet
using chained requests offers a finer control, *note Requests::).

CHARSET may be abbreviated to any unambiguous prefix.

File: recode.info, Node: Reversibility, Next: Sequencing, Prev: Recoding, Up: Invoking recode

Reversibility issues
====================

The following options are somewhat related to reversibility issues:

`-f'
`--force'
With this option, irreversible or otherwise erroneous recodings
are run to completion, and `recode' does not exit with a non-zero
status if it would be only because irreversibility matters. *Note
Reversibility::.

Without this option, `recode' tries to protect you against recoding
a file irreversibly over itself(1). Whenever an irreversible
recoding is met, or any other recoding error, `recode' produces a
warning on standard error. The current input file does not get
replaced by its recoded version, and `recode' then proceeds with
the recoding of the next file.

When the program is merely used as a filter, standard output will
have received a partially recoded copy of standard input, up to
the first error point. After all recodings have been done or
attempted, and if some recoding has been aborted, `recode' exits
with a non-zero status.

In releases of `recode' prior to version 3.5, this option was
always selected, so it was rather meaningless. Nevertheless,
users were invited to start using `-f' right away in scripts
calling `recode' whenever convenient, in preparation for the
current behaviour.

`-q'
`--quiet'
`--silent'
This option has the sole purpose of inhibiting warning messages
about irreversible recodings, and other such diagnostics. It has
no other effect, in particular, it does _not_ prevent recodings to
be aborted or `recode' to return a non-zero exit status when
irreversible recodings are met.

This option is set automatically for the children processes, when
recode splits itself in many collaborating copies. Doing so, the
diagnostic is issued only once by the parent. See option `-p'.

`-s'
`--strict'
By using this option, the user requests that `recode' be very
strict while recoding a file, merely losing in the transformation
any character which is not explicitly mapped from a charset to
another. Such a loss is not reversible and so, will bring
`recode' to fail, unless the option `-f' is also given as a kind
of counter-measure.

Using `-s' without `-f' might render the `recode' program very
susceptible to the slighest file abnormalities. Despite the fact
that it might be irritating to some users, such paranoia is
sometimes wanted and useful.

Even if `recode' tries hard to keep the recodings reversible, you
should not develop an unconditional confidence in its ability to do so.
You _ought_ to keep only reasonable expectations about reverse
recodings. In particular, consider:

* Most transformations are fully reversible for all inputs, but lose
this property whenever `-s' is specified.

* A few transformations are not meant to be reversible, by design.

* Reversibility sometimes depends on actual file contents and cannot
be ascertained beforehand, without reading the file.

* Reversibility is never absolute across successive versions of this
program. Even correcting a small bug in a mapping could induce
slight discrepancies later.

* Reversibility is easily lost by merging. This is best explained
through an example. If you reversibly recode a file from charset
A to charset B, then you reversibly recode the result from charset
B to charset C, you cannot expect to recover the original file by
merely recoding from charset C directly to charset A. You will
instead have to recode from charset C back to charset B, and only
then from charset B to charset A.

* Faulty files create a particular problem. Consider an example,
recoding from `IBM-PC' to `Latin-1'. End of lines are represented
as `\r\n' in `IBM-PC' and as `\n' in `Latin-1'. There is no way
by which a faulty `IBM-PC' file containing a `\n' not preceded by
`\r' be translated into a `Latin-1' file, and then back.

* There is another difficulty arising from code equivalences. For
example, in a `LaTeX' charset file, the string `\^\i{}' could be
recoded back and forth through another charset and become
`\^{\i}'. Even if the resulting file is equivalent to the
original one, it is not identical.

Unless option `-s' is used, `recode' automatically tries to fill
mappings with invented correspondences, often making them fully
reversible. This filling is not made at random. The algorithm tries to
stick to the identity mapping and, when this is not possible, it prefers
generating many small permutation cycles, each involving only a few
codes.

For example, here is how `IBM-PC' code 186 gets translated to
`control-U' in `Latin-1'. `Control-U' is 21. Code 21 is the `IBM-PC'
section sign, which is 167 in `Latin-1'. `recode' cannot reciprocate
167 to 21, because 167 is the masculine ordinal indicator within
`IBM-PC', which is 186 in `Latin-1'. Code 186 within `IBM-PC' has no
`Latin-1' equivalent; by assigning it back to 21, `recode' closes this
short permutation loop.

As a consequence of this map filling, `recode' may sometimes produce
_funny_ characters. They may look annoying, they are nevertheless
helpful when one changes his (her) mind and wants to revert to the prior
recoding. If you cannot stand these, use option `-s', which asks for a
very strict recoding.

This map filling sometimes has a few surprising consequences, which
some users wrongly interpreted as bugs. Here are two examples.

1. In some cases, `recode' seems to copy a file without recoding it.
But in fact, it does. Consider a request:

recode l1..us < File-Latin1 > File-ASCII
cmp File-Latin1 File-ASCII

then `cmp' will not report any difference. This is quite normal.
`Latin-1' gets correctly recoded to ASCII for charsets
commonalities (which are the first 128 characters, in this case).
The remaining last 128 `Latin-1' characters have no ASCII
correspondent. Instead of losing them, `recode' elects to map
them to unspecified characters of ASCII, so making the recoding
reversible. The simplest way of achieving this is merely to keep
those last 128 characters unchanged. The overall effect is
copying the file verbatim.

If you feel this behaviour is too generous and if you do not wish
to care about reversibility, simply use option `-s'. By doing so,
`recode' will strictly map only those `Latin-1' characters which
have an ASCII equivalent, and will merely drop those which do not.
Then, there is more chance that you will observe a difference
between the input and the output file.

2. Recoding the wrong way could sometimes give the false impression
that recoding has _almost_ been done properly. Consider the
requests:

recode 437..l1 < File-Latin1 > Temp1
recode 437..l1 < Temp1 > Temp2

so declaring wrongly `File-Latin1' to be an IBM-PC file, and
recoding to `Latin-1'. This is surely ill defined and not
meaningful. Yet, if you repeat this step a second time, you might
notice that many (not all) characters in `Temp2' are identical to
those in `File-Latin1'. Sometimes, people try to discover how
`recode' works by experimenting a little at random, rather than
reading and understanding the documentation; results such as this
are surely confusing, as they provide those people with a false
feeling that they understood something.

Reversible codings have this property that, if applied several
times in the same direction, they will eventually bring any
character back to its original value. Since `recode' seeks small
permutation cycles when creating reversible codings, besides
characters unchanged by the recoding, most permutation cycles will
be of length 2, and fewer of length 3, etc. So, it is just
expectable that applying the recoding twice in the same direction
will recover most characters, but will fail to recover those
participating in permutation cycles of length 3. On the other
end, recoding six times in the same direction would recover all
characters in cycles of length 1, 2, 3 or 6.

---------- Footnotes ----------

(1) There are still some cases of ambiguous output which are rather
difficult to detect, and for which the protection is not active.

File: recode.info, Node: Sequencing, Next: Mixed, Prev: Reversibility, Up: Invoking recode

Selecting sequencing methods
============================

This program uses a few techniques when it is discovered that many
passes are needed to comply with the REQUEST. For example, suppose
that four elementary steps were selected at recoding path optimisation
time. Then `recode' will split itself into four different
interconnected tasks, logically equivalent to:

STEP1 <INPUT | STEP2 | STEP3 | STEP4 >OUTPUT

The splitting into subtasks is often done using Unix pipes. But the
splitting may also be completely avoided, and rather simulated by using
memory buffer, or intermediate files. The various
`--sequence=STRATEGY' options gives you control over the flow methods,
by replacing STRATEGY with `memory', `pipe' or `files'. So, these
options may be used to override the default behaviour, which is also
explained below.

`--sequence=memory'
When the recoding requires a combination of two or more elementary
recoding steps, this option forces many passes over the data, using
in-memory buffers to hold all intermediary results.

`-i'
`--sequence=files'
When the recoding requires a combination of two or more elementary
recoding steps, this option forces many passes over the data, using
intermediate files between passes. This is the default behaviour
when files are recoded over themselves. If this option is
selected in filter mode, that is, when the program reads standard
input and writes standard output, it might take longer for
programs further down the pipe chain to start receiving some
recoded data.

`-p'
`--sequence=pipe'
When the recoding requires a combination of two or more elementary
recoding steps, this option forces the program to fork itself into
a few copies interconnected with pipes, using the `pipe(2)' system
call. All copies of the program operate in parallel. This is the
default behaviour in filter mode. If this option is used when
files are recoded over themselves, this should also save disk
space because some temporary files might not be needed, at the
cost of more system overhead.

If, at installation time, the `pipe(2)' call is said to be
unavailable, selecting option `-p' is equivalent to selecting
option `-i'. (This happens, for example, on MS-DOS systems.)

File: recode.info, Node: Mixed, Next: Emacs, Prev: Sequencing, Up: Invoking recode

Using mixed charset input
=========================

In real life and practice, textual files are often made up of many
charsets at once. Some parts of the file encode one charset, while
other parts encode another charset, and so forth. Usually, a file does
not toggle between more than two or three charsets. The means to
distinguish which charsets are encoded at various places is not always
available. The `recode' program is able to handle only a few simple
cases of mixed input.

The default `recode' behaviour is to expect pure charset files, to
be recoded as other pure charset files. However, the following options
allow for a few precise kinds of mixed charset files.

`-d'
`--diacritics'
While converting to or from one of `HTML' or `LaTeX' charset,
limit conversion to some subset of all characters. For `HTML',
limit conversion to the subset of all non-ASCII characters. For
`LaTeX', limit conversion to the subset of all non-English
letters. This is particularly useful, for example, when people
create what would be valid `HTML', TeX or LaTeX files, if only
they were using provided sequences for applying diacritics instead
of using the diacriticised characters directly from the underlying
character set.

While converting to `HTML' or `LaTeX' charset, this option assumes
that characters not in the said subset are properly coded or
protected already, `recode' then transmit them literally. While
converting the other way, this option prevents translating back
coded or protected versions of characters not in the said subset.
*Note HTML::. *Note LaTeX::.

`-S[LANGUAGE]'
`--source[=LANGUAGE]'
The bulk of the input file is expected to be written in `ASCII',
except for parts, like comments and string constants, which are
written using another charset than `ASCII'. When LANGUAGE is `c',
the recoding will proceed only with the contents of comments or
strings, while everything else will be copied without recoding.
When LANGUAGE is `po', the recoding will proceed only within
translator comments (those having whitespace immediately following
the initial `#') and with the contents of `msgstr' strings.

For the above things to work, the non-`ASCII' encoding of the
comment or string should be such that an `ASCII' scan will
successfully find where the comment or string ends.

Even if `ASCII' is the usual charset for writing programs, some
compilers are able to directly read other charsets, like `UTF-8',
say. There is currently no provision in `recode' for reading
mixed charset sources which are not based on `ASCII'. It is
probable that the need for mixed recoding is not as pressing in
such cases.

For example, after one does:

recode -Spo pc/..u8 < INPUT.po > OUTPUT.po

file `OUTPUT.po' holds a copy of `INPUT.po' in which _only_
translator comments and the contents of `msgstr' strings have been
recoded from the `IBM-PC' charset to pure `UTF-8', without
attempting conversion of end-of-lines. Machine generated comments
and original `msgid' strings are not to be touched by this
recoding.

If LANGUAGE is not specified, `c' is assumed.

File: recode.info, Node: Emacs, Next: Debugging, Prev: Mixed, Up: Invoking recode

Using `recode' within Emacs
===========================

The fact `recode' is a filter makes it quite easy to use from within
GNU Emacs. For example, recoding the whole buffer from the `IBM-PC'
charset to current charset (`Latin-1' on Unix) is easily done with:

C-x h C-u M-| recode ibmpc RET

`C-x h' selects the whole buffer, and `C-u M-|' filters and replaces
the current region through the given shell command. Here is another
example, binding the keys `C-c T' to the recoding of the current region
from Easy French to `Latin-1' (on Unix) and the key `C-u C-c T' from
`Latin-1' (on Unix) to Easy French:

(global-set-key "\C-cT" 'recode-texte)

(defun recode-texte (flag)
(interactive "P")
(shell-command-on-region
(region-beginning) (region-end)
(concat "recode " (if flag "..txte" "txte")) t)
(exchange-point-and-mark))

File: recode.info, Node: Debugging, Prev: Emacs, Up: Invoking recode

Debugging considerations
========================

It is our experience that when `recode' does not provide satisfying
results, either `recode' was not called properly, correct results
raised some doubts nevertheless, or files to recode were somewhat
mangled. Genuine bugs are surely possible.

Unless you already are a `recode' expert, it might be a good idea to
quickly revisit the tutorial (*note Tutorial::) or the prior sections
in this chapter, to make sure that you properly formatted your recoding
request. In the case you intended to use `recode' as a filter, make
sure that you did not forget to redirect your standard input (through
using the `<' symbol in the shell, say). Some `recode' false mysteries
are also easily explained, *Note Reversibility::.

For the other cases, some investigation is needed. To illustrate
how to proceed, let's presume that you want to recode the `nicepage'
file, coded `UTF-8', into `HTML'. The problem is that the command
`recode u8..h nicepage' yields:

recode: Invalid input in step `UTF-8..ISO-10646-UCS-2'

One good trick is to use `recode' in filter mode instead of in file
replacement mode, *Note Synopsis::. Another good trick is to use the
`-v' option asking for a verbose description of the recoding steps. We
could rewrite our recoding call as `recode -v u8..h <nicepage', to get
something like:

Request: UTF-8..:libiconv:..ISO-10646-UCS-2..HTML_4.0
Shrunk to: UTF-8..ISO-10646-UCS-2..HTML_4.0
[...SOME OUTPUT...]
recode: Invalid input in step `UTF-8..ISO-10646-UCS-2'

This might help you to better understand what the diagnostic means.
The recoding request is achieved in two steps, the first recodes `UTF-8'
into `UCS-2', the second recodes `UCS-2' into `HTML'. The problem
occurs within the first of these two steps, and since, the input of
this step is the input file given to `recode', this is this overall
input file which seems to be invalid. Also, when used in filter mode,
`recode' processes as much input as possible before the error occurs
and sends the result of this processing to standard output. Since the
standard output has not been redirected to a file, it is merely
displayed on the user screen. By inspecting near the end of the
resulting `HTML' output, that is, what was recoding a bit before the
recoding was interrupted, you may infer about where the error stands in
the real `UTF-8' input file.

If you have the proper tools to examine the intermediate recoding
data, you might also prefer to reduce the problem to a single step to
better study it. This is what I usually do. For example, the last
`recode' call above is more or less equivalent to:

recode -v UTF-8..ISO_10646-UCS-2 <nicepage >temporary
recode -v ISO_10646-UCS-2..HTML_4.0 <temporary
rm temporary

If you know that the problem is within the first step, you might
prefer to concentrate on using the first `recode' line. If you know
that the problem is within the second step, you might execute the first
`recode' line once and for all, and then play with the second `recode'
call, repeatedly using the `temporary' file created once by the first
call.

Note that the `-f' switch may be used to force the production of
`HTML' output despite invalid input, it might be satisfying enough for
you, and easier than repairing the input file. That depends on how
strict you would like to be about the precision of the recoding process.

If you later see that your HTML file begins with `@lt;html@gt;' when
you expected `<html>', then `recode' might have done a bit more that
you wanted. In this case, your input file was half-`UTF-8',
half-`HTML' already, that is, a mixed file (*note Mixed::). There is a
special `-d' switch for this case. So, your might be end up calling
`recode -fd nicepage'. Until you are quite sure that you accept
overwriting your input file whatever what, I recommend that you stick
with filter mode.

If, after such experiments, you seriously think that the `recode'
program does not behave properly, there might be a genuine bug in the
program itself, in which case I invite you to to contribute a bug
report, *Note Contributing::.

File: recode.info, Node: Library, Next: Universal, Prev: Invoking recode, Up: Top

A recoding library
******************

The program named `recode' is just an application of its recoding
library. The recoding library is available separately for other C
programs. A good way to acquire some familiarity with the recoding
library is to get acquainted with the `recode' program itself.

To use the recoding library once it is installed, a C program needs
to have a line:

#include <recode.h>

near its beginning, and the user should have `-lrecode' on the linking
call, so modules from the recoding library are found.

The library is still under development. As it stands, it contains
four identifiable sets of routines: the outer level functions, the
request level functions, the task level functions and the charset level
functions. There are discussed in separate sections.

For effectively using the recoding library in most applications, it
should be rarely needed to study anything beyond the main
initialisation function at outer level, and then, various functions at
request level.

* Menu:

* Outer level:: Outer level functions
* Request level:: Request level functions
* Task level:: Task level functions
* Charset level:: Charset level functions
* Errors:: Handling errors

File: recode.info, Node: Outer level, Next: Request level, Prev: Library, Up: Library

Outer level functions
=====================

The outer level functions mainly prepare the whole recoding library
for use, or do actions which are unrelated to specific recodings. Here
is an example of a program which does not really make anything useful.

#include <stdbool.h>
#include <recode.h>

const char *program_name;

int
main (int argc, char *const *argv)
{
program_name = argv[0];
RECODE_OUTER outer = recode_new_outer (true);

recode_delete_outer (outer);
exit (0);
}

The header file `<recode.h>' declares an opaque `RECODE_OUTER'
structure, which the programmer should use for allocating a variable in
his program (let's assume the programmer is a male, here, no prejudice
intended). This `outer' variable is given as a first argument to all
outer level functions.

The `<recode.h>' header file uses the Boolean type setup by the
system header file `<stdbool.h>'. But this header file is still fairly
new in C standards, and likely does not exist everywhere. If you
system does not offer this system header file yet, the proper
compilation of the `<recode.h>' file could be guaranteed through the
replacement of the inclusion line by:

typedef enum {false = 0, true = 1} bool;

People wanting wider portability, or Autoconf lovers, might arrange
their `configure.in' for being able to write something more general,
like:

#if STDC_HEADERS
# include <stdlib.h>
#endif

/* Some systems do not define EXIT_*, even with STDC_HEADERS. */
#ifndef EXIT_SUCCESS
# define EXIT_SUCCESS 0
#endif
#ifndef EXIT_FAILURE
# define EXIT_FAILURE 1
#endif
/* The following test is to work around the gross typo in systems like Sony
NEWS-OS Release 4.0C, whereby EXIT_FAILURE is defined to 0, not 1. */
#if !EXIT_FAILURE
# undef EXIT_FAILURE
# define EXIT_FAILURE 1
#endif

#if HAVE_STDBOOL_H
# include <stdbool.h>
#else
typedef enum {false = 0, true = 1} bool;
#endif

#include <recode.h>

const char *program_name;

int
main (int argc, char *const *argv)
{
program_name = argv[0];
RECODE_OUTER outer = recode_new_outer (true);

recode_term_outer (outer);
exit (EXIT_SUCCESS);
}

but we will not insist on such details in the examples to come.

* Initialisation functions

RECODE_OUTER recode_new_outer (AUTO_ABORT);
bool recode_delete_outer (OUTER);

The recoding library absolutely needs to be initialised before
being used, and `recode_new_outer' has to be called once, first.
Besides the OUTER it is meant to initialise, the function accepts
a Boolean argument whether or not the library should automatically
issue diagnostics on standard and abort the whole program on
errors. When AUTO_ABORT is `true', the library later conveniently
issues diagnostics itself, and aborts the calling program on
errors. This is merely a convenience, because if this parameter
was `false', the calling program should always take care of
checking the return value of all other calls to the recoding
library functions, and when any error is detected, issue a
diagnostic and abort processing itself.

Regardless of the setting of AUTO_ABORT, all recoding library
functions return a success status. Most functions are geared for
returning `false' for an error, and `true' if everything went fine.
Functions returning structures or strings return `NULL' instead of
the result, when the result cannot be produced. If AUTO_ABORT is
selected, functions either return `true', or do not return at all.

As in the example above, `recode_new_outer' is called only once in
most cases. Calling `recode_new_outer' implies some overhead, so
calling it more than once should preferably be avoided.

The termination function `recode_delete_outer' reclaims the memory
allocated by `recode_new_outer' for a given OUTER variable.
Calling `recode_delete_outer' prior to program termination is more
aesthetic then useful, as all memory resources are automatically
reclaimed when the program ends. You may spare this terminating
call if you prefer.

* The `program_name' declaration

As we just explained, the user may set the `recode' library so
that, in case of problems error, it issues the diagnostic itself
and aborts the whole processing. This capability may be quite
convenient. When this feature is used, the aborting routine
includes the name of the running program in the diagnostic. On
the other hand, when this feature is not used, the library merely
return error codes, giving the library user fuller control over
all this. This behaviour is more like what usual libraries do:
they return codes and never abort. However, I would rather not
force library users to necessarily check all return codes
themselves, by leaving no other choice. In most simple
applications, letting the library diagnose and abort is much
easier, and quite welcome. This is precisely because both
possibilities exist that the `program_name' variable is needed: it
may be used by the library _when_ the user sets it to diagnose
itself.

File: recode.info, Node: Request level, Next: Task level, Prev: Outer level, Up: Library

Request level functions
=======================

The request level functions are meant to cover most recoding needs
programmers may have; they should provide all usual functionality.
Their API is almost stable by now. To get started with request level
functions, here is a full example of a program which sole job is to
filter `ibmpc' code on its standard input into `latin1' code on its
standard output.

#include <stdio.h>
#include <stdbool.h>
#include <recode.h>

const char *program_name;

int
main (int argc, char *const *argv)
{
program_name = argv[0];
RECODE_OUTER outer = recode_new_outer (true);
RECODE_REQUEST request = recode_new_request (outer);
bool success;

recode_scan_request (request, "ibmpc..latin1");

success = recode_file_to_file (request, stdin, stdout);

recode_delete_request (request);
recode_delete_outer (outer);

exit (success ? 0 : 1);
}

The header file `<recode.h>' declares a `RECODE_REQUEST' structure,
which the programmer should use for allocating a variable in his
program. This REQUEST variable is given as a first argument to all
request level functions, and in most cases, may be considered as opaque.

* Initialisation functions

RECODE_REQUEST recode_new_request (OUTER);
bool recode_delete_request (REQUEST);

No REQUEST variable may not be used in other request level
functions of the recoding library before having been initialised by
`recode_new_request'. There may be many such REQUEST variables,
in which case, they are independent of one another and they all
need to be initialised separately. To avoid memory leaks, a
REQUEST variable should not be initialised a second time without
calling `recode_delete_request' to "un-initialise" it.

Like for `recode_delete_outer', calling `recode_delete_request'
prior to program termination, in the example above, may be left
out.

* Fields of `struct recode_request'

Here are the fields of a `struct recode_request' which may be
meaningfully changed, once a REQUEST has been initialised by
`recode_new_request', but before it gets used. It is not very
frequent, in practice, that these fields need to be changed. To
access the fields, you need to include `recodext.h' _instead_ of
`recode.h', in which case there also is a greater chance that you
need to recompile your programs if a new version of the recoding
library gets installed.

`verbose_flag'
This field is initially `false'. When set to `true', the
library will echo to stderr the sequence of elementary
recoding steps needed to achieve the requested recoding.

`diaeresis_char'
This field is initially the ASCII value of a double quote `"',
but it may also be the ASCII value of a colon `:'. In `texte'
charset, some countries use double quotes to mark diaeresis,
while other countries prefer colons. This field contains the
diaeresis character for the `texte' charset.

`make_header_flag'
This field is initially `false'. When set to `true', it
indicates that the program is merely trying to produce a
recoding table in source form rather than completing any
actual recoding. In such a case, the optimisation of step
sequence can be attempted much more aggressively. If the
step sequence cannot be reduced to a single step, table
production will fail.

`diacritics_only'
This field is initially `false'. For `HTML' and `LaTeX'
charset, it is often convenient to recode the diacriticized
characters only, while just not recoding other HTML code
using ampersands or angular brackets, or LaTeX code using
backslashes. Set the field to `true' for getting this
behaviour. In the other charset, one can edit text as well
as HTML or LaTeX directives.

`ascii_graphics'
This field is initially `false', and relate to characters 176
to 223 in the `ibmpc' charset, which are use to draw boxes.
When set to `true', while getting out of `ibmpc', ASCII
characters are selected so to graphically approximate these
boxes.

* Study of request strings

bool recode_scan_request (REQUEST, "STRING");

The main role of a REQUEST variable is to describe a set of
recoding transformations. Function `recode_scan_request' studies
the given STRING, and stores an internal representation of it into
REQUEST. Note that STRING may be a full-fledged `recode' request,
possibly including surfaces specifications, intermediary charsets,
sequences, aliases or abbreviations (*note Requests::).

The internal representation automatically receives some
pre-conditioning and optimisation, so the REQUEST may then later
be used many times to achieve many actual recodings. It would not
be efficient calling `recode_scan_request' many times with the
same STRING, it is better having many REQUEST variables instead.

* Actual recoding jobs

Once the REQUEST variable holds the description of a recoding
transformation, a few functions use it for achieving an actual
recoding. Either input or output of a recoding may be string, an
in-memory buffer, or a file.

Functions with names like `recode_INPUT-TYPE_to_OUTPUT-TYPE'
request an actual recoding, and are described below. It is easy
to remember which arguments each function accepts, once grasped
some simple principles for each possible TYPE. However, one of
the recoding function escapes these principles and is discussed
separately, first.

recode_string (REQUEST, STRING);

The function `recode_string' recodes STRING according to REQUEST,
and directly returns the resulting recoded string freshly
allocated, or `NULL' if the recoding could not succeed for some
reason. When this function is used, it is the responsibility of
the programmer to ensure that the memory used by the returned
string is later reclaimed.

char *recode_string_to_buffer (REQUEST,
INPUT_STRING,
&OUTPUT_BUFFER, &OUTPUT_LENGTH, &OUTPUT_ALLOCATED);
bool recode_string_to_file (REQUEST,
INPUT_FILE,
OUTPUT_FILE);
bool recode_buffer_to_buffer (REQUEST,
INPUT_BUFFER, INPUT_LENGTH,
&OUTPUT_BUFFER, &OUTPUT_LENGTH, &OUTPUT_ALLOCATED);
bool recode_buffer_to_file (REQUEST,
INPUT_BUFFER, INPUT_LENGTH,
OUTPUT_FILE);
bool recode_file_to_buffer (REQUEST,
INPUT_FILE,
&OUTPUT_BUFFER, &OUTPUT_LENGTH, &OUTPUT_ALLOCATED);
bool recode_file_to_file (REQUEST,
INPUT_FILE,
OUTPUT_FILE);

All these functions return a `bool' result, `false' meaning that
the recoding was not successful, often because of reversibility
issues. The name of the function well indicates on which types it
reads and which type it produces. Let's discuss these three types
in turn.

string
A string is merely an in-memory buffer which is terminated by
a `NUL' character (using as many bytes as needed), instead of
being described by a byte length. For input, a pointer to
the buffer is given through one argument.

It is notable that there is no `to_string' functions. Only
one function recodes into a string, and it is
`recode_string', which has already been discussed separately,
above.

buffer
A buffer is a sequence of bytes held in computer memory. For
input, two arguments provide a pointer to the start of the
buffer and its byte size. Note that for charsets using many
bytes per character, the size is given in bytes, not in
characters.

For output, three arguments provide the address of three
variables, which will receive the buffer pointer, the used
buffer size in bytes, and the allocated buffer size in bytes.
If at the time of the call, the buffer pointer is `NULL',
then the allocated buffer size should also be zero, and the
buffer will be allocated afresh by the recoding functions.
However, if the buffer pointer is not `NULL', it should be
already allocated, the allocated buffer size then gives its
size. If the allocated size gets exceeded while the recoding
goes, the buffer will be automatically reallocated bigger,
probably elsewhere, and the allocated buffer size will be
adjusted accordingly.

The second variable, giving the in-memory buffer size, will
receive the exact byte size which was needed for the
recoding. A `NUL' character is guaranteed at the end of the
produced buffer, but is not counted in the byte size of the
recoding. Beyond that `NUL', there might be some extra space
after the recoded data, extending to the allocated buffer
size.

file
A file is a sequence of bytes held outside computer memory,
but buffered through it. For input, one argument provides a
pointer to a file already opened for read. The file is then
read and recoded from its current position until the end of
the file, effectively swallowing it in memory if the
destination of the recoding is a buffer. For reading a file
filtered through the recoding library, but only a little bit
at a time, one should rather use `recode_filter_open' and
`recode_filter_close' (these two functions are not yet
available).

For output, one argument provides a pointer to a file already
opened for write. The result of the recoding is written to
that file starting at its current position.

The following special function is still subject to change:

void recode_format_table (REQUEST, LANGUAGE, "NAME");

and is not documented anymore for now.

File: recode.info, Node: Task level, Next: Charset level, Prev: Request level, Up: Library

Task level functions
====================

The task level functions are used internally by the request level
functions, they allow more explicit control over files and memory
buffers holding input and output to recoding processes. The interface
specification of task level functions is still subject to change a bit.

To get started with task level functions, here is a full example of a
program which sole job is to filter `ibmpc' code on its standard input
into `latin1' code on its standard output. That is, this program has
the same goal as the one from the previous section, but does its things
a bit differently.

#include <stdio.h>
#include <stdbool.h>
#include <recodext.h>

const char *program_name;

int
main (int argc, char *const *argv)
{
program_name = argv[0];
RECODE_OUTER outer = recode_new_outer (false);
RECODE_REQUEST request = recode_new_request (outer);
RECODE_TASK task;
bool success;

recode_scan_request (request, "ibmpc..latin1");

task = recode_new_task (request);
task->input.file = "";
task->output.file = "";
success = recode_perform_task (task);

recode_delete_task (task);
recode_delete_request (request);
recode_delete_outer (outer);

exit (success ? 0 : 1);
}

The header file `<recode.h>' declares a `RECODE_TASK' structure,
which the programmer should use for allocating a variable in his
program. This `task' variable is given as a first argument to all task
level functions. The programmer ought to change and possibly consult a
few fields in this structure, using special functions.

* Initialisation functions

RECODE_TASK recode_new_task (REQUEST);
bool recode_delete_task (TASK);

No TASK variable may be used in other task level functions of the
recoding library without having first been initialised with
`recode_new_task'. There may be many such TASK variables, in
which case, they are independent of one another and they all need
to be initialised separately. To avoid memory leaks, a TASK
variable should not be initialised a second time without calling
`recode_delete_task' to "un-initialise" it. This function also
accepts a REQUEST argument and associates the request to the task.
In fact, a task is essentially a set of recoding transformations
with the specification for its current input and its current
output.

The REQUEST variable may be scanned before or after the call to
`recode_new_task', it does not matter so far. Immediately after
initialisation, before further changes, the TASK variable
associates REQUEST empty in-memory buffers for both input and
output. The output buffer will later get allocated automatically
on the fly, as needed, by various task processors.

Even if a call to `recode_delete_task' is not strictly mandatory
before ending the program, it is cleaner to always include it.
Moreover, in some future version of the recoding library, it might
become required.

* Fields of `struct task_request'

Here are the fields of a `struct task_request' which may be
meaningfully changed, once a TASK has been initialised by
`recode_new_task'. In fact, fields are expected to change. Once
again, to access the fields, you need to include `recodext.h'
_instead_ of `recode.h', in which case there also is a greater
chance that you need to recompile your programs if a new version
of the recoding library gets installed.

`request'
The field `request' points to the current recoding request,
but may be changed as needed between recoding calls, for
example when there is a need to achieve the construction of a
resulting text made up of many pieces, each being recoded
differently.

`input.name'
`input.file'
If `input.name' is not `NULL' at start of a recoding, this is
a request that a file by that name be first opened for
reading and later automatically closed once the whole file
has been read. If the file name is not `NULL' but an empty
string, it means that standard input is to be used. The
opened file pointer is then held into `input.file'.

If `input.name' is `NULL' and `input.file' is not, than
`input.file' should point to a file already opened for read,
which is meant to be recoded.

`input.buffer'
`input.cursor'
`input.limit'
When both `input.name' and `input.file' are `NULL', three
pointers describe an in-memory buffer containing the text to
be recoded. The buffer extends from `input.buffer' to
`input.limit', yet the text to be recoded only extends from
`input.cursor' to `input.limit'. In most situations,
`input.cursor' starts with the value that `input.buffer' has.
(Its value will internally advance as the recoding goes,
until it reaches the value of `input.limit'.)

`output.name'
`output.file'
If `output.name' is not `NULL' at start of a recoding, this
is a request that a file by that name be opened for write and
later automatically closed after the recoding is done. If
the file name is not `NULL' but an empty string, it means
that standard output is to be used. The opened file pointer
is then held into `output.file'. If several passes with
intermediate files are needed to produce the recoding, the
`output.name' file is opened only for the final pass.

If `output.name' is `NULL' and `output.file' is not, then
`output.file' should point to a file already opened for
write, which will receive the result of the recoding.

`output.buffer'
`output.cursor'
`output.limit'
When both `output.name' and `output.file' are `NULL', three
pointers describe an in-memory buffer meant to receive the
text, once it is recoded. The buffer is already allocated
from `output.buffer' to `output.limit'. In most situations,
`output.cursor' starts with the value that `output.buffer'
has. Once the recoding is done, `output.cursor' will point
at the next free byte in the buffer, just after the recoded
text, so another recoding could be called without changing
any of these three pointers, for appending new information to
it. The number of recoded bytes in the buffer is the
difference between `output.cursor' and `output.buffer'.

Each time `output.cursor' reaches `output.limit', the buffer
is reallocated bigger, possibly at a different location in
memory, always held up-to-date in `output.buffer'. It is
still possible to call a task level function with no output
buffer at all to start with, in which case all three fields
should have `NULL' as a value. This is the situation
immediately after a call to `recode_new_task'.

`strategy'
This field, which is of type `enum recode_sequence_strategy',
tells how various recoding steps (passes) will be
interconnected. Its initial value is
`RECODE_STRATEGY_UNDECIDED', which is a constant defined in
the header file `<recodext.h>'. Other possible values are:

`RECODE_SEQUENCE_IN_MEMORY'
Keep intermediate recodings in memory.

`RECODE_SEQUENCE_WITH_FILES'
Do not fork, use intermediate files.

`RECODE_SEQUENCE_WITH_PIPE'
Fork processes connected with `pipe(2)'.

The best for now is to leave this field alone, and let the
recoding library decide its strategy, as many combinations
have not been tested yet.

`byte_order_mark'
This field, which is preset to `true', indicates that a byte
order mark is to be expected at the beginning of any
canonical `UCS-2' or `UTF-16' text, and that such a byte
order mark should be also produced for these charsets.

`fail_level'
This field, which is of type `enum recode_error' (*note
Errors::), sets the error level at which task level functions
should report a failure. If an error being detected is equal
or greater than `fail_level', the function will eventually
return `false' instead of `true'. The preset value for this
field is `RECODE_NOT_CANONICAL', that means that if not reset
to another value, the library will report failure on _any_
error.

`abort_level'
This field, which is of type `enum recode_error' (*note
Errors::), sets the error level at which task level functions
should immediately interrupt their processing. If an error
being detected is equal or greater than `abort_level', the
function returns immediately, but the returned value (`true'
or `false') is still is decided from the setting of
`fail_level', not `abort_level'. The preset value for this
field is `RECODE_MAXIMUM_ERROR', that means that is not reset
to another value, the library will never interrupt a recoding
task.

`error_so_far'
This field, which is of type `enum recode_error' (*note
Errors::), maintains the maximum error level met so far while
the recoding task was proceeding. The preset value is
`RECODE_NO_ERROR'.

* Task execution

recode_perform_task (TASK);
recode_filter_open (TASK, FILE);
recode_filter_close (TASK);

The function `recode_perform_task' reads as much input as possible,
and recode all of it on prescribed output, given a properly
initialised TASK.

Functions `recode_filter_open' and `recode_filter_close' are only
planned for now. They are meant to read input in piecemeal ways.
Even if functionality already exists informally in the library, it
has not been made available yet through such interface functions.

File: recode.info, Node: Charset level, Next: Errors, Prev: Task level, Up: Library

Charset level functions
=======================

Many functions are internal to the recoding library. Some of them
have been made external and available, for the `recode' program had to
retain all its previous functionality while being transformed into a
mere application of the recoding library. These functions are not
really documented here for the time being, as we hope that many of them
will vanish over time. When this set of routines will stabilise, it
would be convenient to document them as an API for handling charset
names and contents.

RECODE_CHARSET find_charset (NAME, CLEANING-TYPE);
bool list_all_charsets (CHARSET);
bool list_concise_charset (CHARSET, LIST-FORMAT);
bool list_full_charset (CHARSET);

File: recode.info, Node: Errors, Prev: Charset level, Up: Library

Handling errors
===============

The `recode' program, while using the `recode' library, needs to
control whether recoding problems are reported or not, and then reflect
these in the exit status. The program should also instruct the library
whether the recoding should be abruptly interrupted when an error is
met (so sparing processing when it is known in advance that a wrong
result would be discarded anyway), or if it should proceed nevertheless.
Here is how the library groups errors into levels, listed here in order
of increasing severity.

`RECODE_NO_ERROR'
No error was met on previous library calls.

`RECODE_NOT_CANONICAL'
The input text was using one of the many alternative codings for
some phenomenon, but not the one `recode' would have canonically
generated. So, if the reverse recoding is later attempted, it
would produce a text having the same _meaning_ as the original
text, yet not being byte identical.

For example, a `Base64' block in which end-of-lines appear
elsewhere that at every 76 characters is not canonical. An
e-circumflex in TeX which is coded as `\^{e}' instead of `\^e' is
not canonical.

`RECODE_AMBIGUOUS_OUTPUT'
It has been discovered that if the reverse recoding was attempted
on the text output by this recoding, we would not obtain the
original text, only because an ambiguity was generated by accident
in the output text. This ambiguity would then cause the wrong
interpretation to be taken.

Here are a few examples. If the `Latin-1' sequence `e^' is
converted to Easy French and back, the result will be interpreted
as e-circumflex and so, will not reflect the intent of the
original two characters. Recoding an `IBM-PC' text to `Latin-1'
and back, where the input text contained an isolated `LF', will
have a spurious `CR' inserted before the `LF'.

Currently, there are many cases in the library where the
production of ambiguous output is not properly detected, as it is
sometimes a difficult problem to accomplish this detection, or to
do it speedily.

`RECODE_UNTRANSLATABLE'
One or more input character could not be recoded, because there is
just no representation for this character in the output charset.

Here are a few examples. Non-strict mode often allows `recode' to
compute on-the-fly mappings for unrepresentable characters, but
strict mode prohibits such attribution of reversible translations:
so strict mode might often trigger such an error. Most `UCS-2'
codes used to represent Asian characters cannot be expressed in
various Latin charsets.

`RECODE_INVALID_INPUT'
The input text does not comply with the coding it is declared to
hold. So, there is no way by which a reverse recoding would
reproduce this text, because `recode' should never produce invalid
output.

Here are a few examples. In strict mode, `ASCII' text is not
allowed to contain characters with the eight bit set. `UTF-8'
encodings ought to be minimal(1).

`RECODE_SYSTEM_ERROR'
The underlying system reported an error while the recoding was
going on, likely an input/output error. (This error symbol is
currently unused in the library.)

`RECODE_USER_ERROR'
The programmer or user requested something the recoding library is
unable to provide, or used the API wrongly. (This error symbol is
currently unused in the library.)

`RECODE_INTERNAL_ERROR'
Something really wrong, which should normally never happen, was
detected within the recoding library. This might be due to
genuine bugs in the library, or maybe due to un-initialised or
overwritten arguments to the API. (This error symbol is currently
unused in the library.)

`RECODE_MAXIMUM_ERROR'
This error code should never be returned, it is only internally
used as a sentinel for the list of all possible error codes.

One should be able to set the error level threshold for returning
failure at end of recoding, and also the threshold for immediate
interruption. If many errors occur while the recoding proceed, which
are not severe enough to interrupt the recoding, then the most severe
error is retained, while others are forgotten(2). So, in case of an
error, the possible actions currently are:

* do nothing and let go, returning success at end of recoding,

* just let go for now, but return failure at end of recoding,

* interrupt recoding right away and return failure now.

*Note Task level::, and particularly the description of the fields
`fail_level', `abort_level' and `error_so_far', for more information
about how errors are handled.

---------- Footnotes ----------

(1) The minimality of an `UTF-8' encoding is guaranteed on output,
but currently, it is not checked on input.

(2) Another approach would have been to define the level symbols as
masks instead, and to give masks to threshold setting routines, and to
retain all errors--yet I never met myself such a need in practice, and
so I fear it would be overkill. On the other hand, it might be
interesting to maintain counters about how many times each kind of
error occurred.

File: recode.info, Node: Universal, Next: libiconv, Prev: Library, Up: Top

The universal charset
*********************

Standard ISO 10646 defines a universal character set, intended to
encompass in the long run all languages written on this planet. It is
based on wide characters, and offer possibilities for two billion
characters (2^31).

This charset was to become available in `recode' under the name
`UCS', with many external surfaces for it. But in the current version,
only surfaces of `UCS' are offered, each presented as a genuine charset
rather than a surface. Such surfaces are only meaningful for the `UCS'
charset, so it is not that useful to draw a line between the surfaces
and the only charset to which they may apply.

`UCS' stands for Universal Character Set. `UCS-2' and `UCS-4' are
fixed length encodings, using two or four bytes per character
respectively. `UTF' stands for `UCS' Transformation Format, and are
variable length encodings dedicated to `UCS'. `UTF-1' was based on
ISO 2022, it did not succeed(1). `UTF-2' replaced it, it has been
called `UTF-FSS' (File System Safe) in Unicode or Plan9 context, but is
better known today as `UTF-8'. To complete the picture, there is
`UTF-16' based on 16 bits bytes, and `UTF-7' which is meant for
transmissions limited to 7-bit bytes. Most often, one might see
`UTF-8' used for external storage, and `UCS-2' used for internal
storage.

When `recode' is producing any representation of `UCS', it uses the
replacement character `U+FFFD' for any _valid_ character which is not
representable in the goal charset(2). This happens, for example, when
`UCS-2' is not capable to echo a wide `UCS-4' character, or for a
similar reason, an `UTF-8' sequence using more than three bytes. The
replacement character is meant to represent an existing character. So,
it is never produced to represent an invalid sequence or ill-formed
character in the input text. In such cases, `recode' just gets rid of
the noise, while taking note of the error in its usual ways.

Even if `UTF-8' is an encoding, really, it is the encoding of a
single character set, and nothing else. It is useful to distinguish
between an encoding (a _surface_ within `recode') and a charset, but
only when the surface may be applied to several charsets. Specifying a
charset is a bit simpler than specifying a surface in a `recode'
request. There would not be a practical advantage at imposing a more
complex syntax to `recode' users, when it is simple to assimilate
`UTF-8' to a charset. Similar considerations apply for `UCS-2',
`UCS-4', `UTF-16' and `UTF-7'. These are all considered to be charsets.

* Menu:

---------- Footnotes ----------

(1) It is not probable that `recode' will ever support `UTF-1'.

(2) This is when the goal charset allows for 16-bits. For shorter
charsets, the `--strict' (`-s') option decides what happens: either the
character is dropped, or a reversible mapping is produced on the fly.

File: recode.info, Node: UCS-2, Next: UCS-4, Prev: Universal, Up: Universal

Universal Character Set, 2 bytes
================================

One surface of `UCS' is usable for the subset defined by its first
sixty thousand characters (in fact, 31 * 2^11 codes), and uses exactly
two bytes per character. It is a mere dump of the internal memory
representation which is _natural_ for this subset and as such, conveys
with it endianness problems.

A non-empty `UCS-2' file normally begins with a so called "byte
order mark", having value `0xFEFF'. The value `0xFFFE' is not an `UCS'
character, so if this value is seen at the beginning of a file,
`recode' reacts by swapping all pairs of bytes. The library also
properly reacts to other occurrences of `0xFEFF' or `0xFFFE' elsewhere
than at the beginning, because concatenation of `UCS-2' files should
stay a simple matter, but it might trigger a diagnostic about non
canonical input.

By default, when producing an `UCS-2' file, `recode' always outputs
the high order byte before the low order byte. But this could be
easily overridden through the `21-Permutation' surface (*note
Permutations::). For example, the command:

recode u8..u2/21 < INPUT > OUTPUT

asks for an `UTF-8' to `UCS-2' conversion, with swapped byte output.

Use `UCS-2' as a genuine charset. This charset is available in
`recode' under the name `ISO-10646-UCS-2'. Accepted aliases are
`UCS-2', `BMP', `rune' and `u2'.

The `recode' library is able to combine `UCS-2' some sequences of
codes into single code characters, to represent a few diacriticized
characters, ligatures or diphtongs which have been included to ease
mapping with other existing charsets. It is also able to explode such
single code characters into the corresponding sequence of codes. The
request syntax for triggering such operations is rudimentary and
temporary. The `combined-UCS-2' pseudo character set is a special form
of `UCS-2' in which known combinings have been replaced by the simpler
code. Using `combined-UCS-2' instead of `UCS-2' in an _after_ position
of a request forces a combining step, while using `combined-UCS-2'
instead of `UCS-2' in a _before_ position of a request forces an
exploding step. For the time being, one has to resort to advanced
request syntax to achieve other effects. For example:

recode u8..co,u2..u8 < INPUT > OUTPUT

copies an `UTF-8' INPUT over OUTPUT, still to be in `UTF-8', yet
merging combining characters into single codes whenever possible.

File: recode.info, Node: UCS-4, Next: UTF-7, Prev: UCS-2, Up: Universal

Universal Character Set, 4 bytes
================================

Another surface of `UCS' uses exactly four bytes per character, and
is a mere dump of the internal memory representation which is _natural_
for the whole charset and as such, conveys with it endianness problems.

Use it as a genuine charset. This charset is available in `recode'
under the name `ISO-10646-UCS-4'. Accepted aliases are `UCS', `UCS-4',
`ISO_10646', `10646' and `u4'.

File: recode.info, Node: UTF-7, Next: UTF-8, Prev: UCS-4, Up: Universal

Universal Transformation Format, 7 bits
=======================================

`UTF-7' comes from IETF rather than ISO, and is described by
RFC 2152, in the MIME series. The `UTF-7' encoding is meant to fit
`UCS-2' over channels limited to seven bits per byte. It proceeds from
a mix between the spirit of `Quoted-Printable' and methods of `Base64',
adapted to Unicode contexts.

This charset is available in `recode' under the name
`UNICODE-1-1-UTF-7'. Accepted aliases are `UTF-7', `TF-7' and `u7'.

File: recode.info, Node: UTF-8, Next: UTF-16, Prev: UTF-7, Up: Universal

Universal Transformation Format, 8 bits
=======================================

Even if `UTF-8' does not originally come from IETF, there is now
RFC 2279 to describe it. In letters sent on 1995-01-21 and 1995-04-20,
Markus Kuhn writes:

`UTF-8' is an `ASCII' compatible multi-byte encoding of the
ISO 10646 universal character set (`UCS'). `UCS' is a 31-bit
superset of all other character set standards. The first 256
characters of `UCS' are identical to those of ISO 8859-1
(Latin-1). The `UCS-2' encoding of UCS is a sequence of bigendian
16-bit words, the `UCS-4' encoding is a sequence of bigendian
32-bit words. The `UCS-2' subset of ISO 10646 is also known as
"Unicode". As both `UCS-2' and `UCS-4' require heavy
modifications to traditional `ASCII' oriented system designs (e.g.
Unix), the `UTF-8' encoding has been designed for these
applications.

In `UTF-8', only `ASCII' characters are encoded using bytes below
128. All other non-ASCII characters are encoded as multi-byte
sequences consisting only of bytes in the range 128-253. This
avoids critical bytes like `NUL' and `/' in `UTF-8' strings, which
makes the `UTF-8' encoding suitable for being handled by the
standard C string library and being used in Unix file names.
Other properties include the preserved lexical sorting order and
that `UTF-8' allows easy self-synchronisation of software
receiving `UTF-8' strings.

`UTF-8' is the most common external surface of `UCS', each character
uses from one to six bytes, and is able to encode all 2^31 characters
of the `UCS'. It is implemented as a charset, with the following
properties:

* Strict 7-bit `ASCII' is completely invariant under `UTF-8', and
those are the only one-byte characters. `UCS' values and `ASCII'
values coincide. No multi-byte characters ever contain bytes less
than 128. `NUL' _is_ `NUL'. A multi-byte character always starts
with a byte of 192 or more, and is always followed by a number of
bytes between 128 to 191. That means that you may read at random
on disk or memory, and easily discover the start of the current,
next or previous character. You can count, skip or extract
characters with this only knowledge.

* If you read the first byte of a multi-byte character in binary, it
contains many `1' bits in successions starting with the most
significant one (from the left), at least two. The length of this
`1' sequence equals the byte size of the character. All
succeeding bytes start by `10'. This is a lot of redundancy,
making it fairly easy to guess that a file is valid `UTF-8', or to
safely state that it is not.

* In a multi-byte character, if you remove all leading `1' bits of
the first byte of a multi-byte character, and the initial `10'
bits of all remaining bytes (so keeping 6 bits per byte for
those), the remaining bits concatenated are the UCS value.

These properties also have a few nice consequences:

* Conversion to/from values is algorithmically simple, and
reasonably speedy.

* A sequence of N bytes can hold characters needing up to 2 + 5N
bits in their `UCS' representation. Here, N is a number between 1
and 6. So, `UTF-8' is most economical when mapping ASCII (1 byte),
followed by `UCS-2' (1 to 3 bytes) and `UCS-4' (1 to 6 bytes).

* The lexicographic sorting order of `UCS' strings is preserved.

* Bytes with value 254 or 255 never appear, and because of that,
these are sometimes used when escape mechanisms are needed.

In some case, when little processing is done on a lot of strings,
one may choose for efficiency reasons to handle `UTF-8' strings
directly even if variable length, as it is easy to get start of
characters. Character insertion or replacement might require moving
the remainder of the string in either direction. In most cases, it is
faster and easier to convert from `UTF-8' to `UCS-2' or `UCS-4' prior
to processing.

This charset is available in `recode' under the name `UTF-8'.
Accepted aliases are `UTF-2', `UTF-FSS', `FSS_UTF', `TF-8' and `u8'.

File: recode.info, Node: UTF-16, Next: count-characters, Prev: UTF-8, Up: Universal

Universal Transformation Format, 16 bits
========================================

Another external surface of `UCS' is also variable length, each
character using either two or four bytes. It is usable for the subset
defined by the first million characters (17 * 2^16) of `UCS'.

Martin J. Du"rst writes (to `comp.std.internat', on 1995-03-28):

`UTF-16' is another method that reserves two times 1024 codepoints
in Unicode and uses them to index around one million additional
characters. `UTF-16' is a little bit like former multibyte codes,
but quite not so, as both the first and the second 16-bit code
clearly show what they are. The idea is that one million
codepoints should be enough for all the rare Chinese ideograms and
historical scripts that do not fit into the Base Multilingual
Plane of ISO 10646 (with just about 63,000 positions available,
now that 2,000 are gone).

This charset is available in `recode' under the name `UTF-16'.
Accepted aliases are `Unicode', `TF-16' and `u6'.

File: recode.info, Node: count-characters, Next: dump-with-names, Prev: UTF-16, Up: Universal

Frequency count of characters
=============================

A device may be used to obtain a list of characters in a file, and
how many times each character appears. Each count is followed by the
`UCS-2' value of the character and, when known, the RFC 1345 mnemonic
for that character.

This charset is available in `recode' under the name
`count-characters'.

This `count' feature has been implemented as a charset. This may
change in some later version, as it would sometimes be convenient to
count original bytes, instead of their `UCS-2' equivalent.

File: recode.info, Node: dump-with-names, Prev: count-characters, Up: Universal

Fully interpreted UCS dump
==========================

Another device may be used to get fully interpreted dumps of an
`UCS-2' stream of characters, with one `UCS-2' character displayed on a
full output line. Each line receives the RFC 1345 mnemonic for the
character if it exists, the `UCS-2' value of the character, and a
descriptive comment for that character. As each input character
produces its own output line, beware that the output file from this
conversion may be much, much bigger than the input file.

This charset is available in `recode' under the name
`dump-with-names'.

This `dump-with-names' feature has been implemented as a charset
rather than a surface. This is surely debatable. The current
implementation allows for dumping charsets other than `UCS-2'. For
example, the command `recode l2..full < INPUT' implies a necessary
conversion from `Latin-2' to `UCS-2', as `dump-with-names' is only
connected out from `UCS-2'. In such cases, `recode' does not display
the original `Latin-2' codes in the dump, only the corresponding
`UCS-2' values. To give a simpler example, the command

echo 'Hello, world!' | recode us..dump

produces the following output:

UCS2 Mne Description

0048 H latin capital letter h
0065 e latin small letter e
006C l latin small letter l
006C l latin small letter l
006F o latin small letter o
002C , comma
0020 SP space
0077 w latin small letter w
006F o latin small letter o
0072 r latin small letter r
006C l latin small letter l
0064 d latin small letter d
0021 ! exclamation mark
000A LF line feed (lf)

The descriptive comment is given in English and `ASCII', yet if the
English description is not available but a French one is, then the
French description is given instead, using `Latin-1'. However, if the
`LANGUAGE' or `LANG' environment variable begins with the letters `fr',
then listing preference goes to French when both descriptions are
available.

Here is another example. To get the long description of the code
237 in Latin-5 table, one may use the following command.

echo -n 237 | recode l5/d..dump

If your `echo' does not grok `-n', use `echo 237\c' instead. Here is
how to see what Unicode `U+03C6' means, while getting rid of the title
lines.

echo -n 0x03C6 | recode u2/x2..dump | tail +3

File: recode.info, Node: libiconv, Next: Tabular, Prev: Universal, Up: Top

The `iconv' library
*******************

The `recode' library itself contains most code and tables from the
portable `iconv' library, written by Bruno Haible. In fact, many
capabilities of the `recode' library are duplicated because of this
merging, as the older `recode' and `iconv' libraries share many
charsets. We discuss, here, the issues related to this duplication, and
other peculiarities specific to the `iconv' library. The plan is to
remove duplications and better merge specificities, as `recode' evolves.

As implemented, if a recoding request can be satisfied by the
`recode' library both with and without its `iconv' library part, it is
likely that the `iconv' library will be used. To sort out if the
`iconv' is indeed used of not, just use the `-v' or `--verbose' option,
*note Recoding::.

The `:libiconv:' charset represents a conceptual pivot charset
within the `iconv' part of the `recode' library (in fact, this pivot
exists, but is not directly reachable). This charset has a mere `:' (a
colon) for an alias. It is not allowed to recode from or to this
charset directly. But when this charset is selected as an
intermediate, usually by automatic means, then the `iconv' part of the
`recode' library is called to handle the transformations. By using an
`--ignore=:libiconv:' option on the `recode' call or equivalently, but
more simply, `-x:', `recode' is instructed to fully avoid this charset
as an intermediate, with the consequence that the `iconv' part of the
library is defeated. Consider these two calls:

recode l1..1250 < INPUT > OUTPUT
recode -x: l1..1250 < INPUT > OUTPUT

Both should transform INPUT from `ISO-8859-1' to `CP1250' on OUTPUT.
The first call uses the `iconv' part of the library, while the second
call avoids it. Whatever the path used, the results should normally be
identical. However, there might be observable differences. Most of
them might result from reversibility issues, as the `iconv' engine,
which the `recode' library directly uses for the time being, does not
address reversibility. Even if much less likely, some differences
might result from slight errors in the tables used, such differences
should then be reported as bugs.

Other irregularities might be seen in the area of error detection and
recovery. The `recode' library usually tries to detect canonicity
errors in input, and production of ambiguous output, but the `iconv'
part of the library currently does not. Input is always validated,
however. The `recode' library may not always react properly when its
`iconv' part has no translation for a given character.

Within a collection of names for a single charset, the `recode'
library distinguishes one of them as being the genuine charset name,
while the others are said to be aliases. When `recode' lists all
charsets, for example with the `-l' or `--list' option, the list
integrates all `iconv' library charsets. The selection of one of the
aliases as the genuine charset name is an artifact added by `recode',
it does not come from `iconv'. Moreover, the `recode' library
dynamically resolves some conflicts when it initialises itself at
runtime. This might explain some discrepancies in the table below, as
for what is the genuine charset name.

* General character sets
`US-ASCII'
`ASCII', `ISO646-US', `ISO_646.IRV:1991', `ISO-IR-6',
`ANSI_X3.4-1968', `CP367', `IBM367', `US', `csASCII' and
`ISO646.1991-IRV' are aliases for this charset.

* General multi-byte encodings
`UTF-8'
`UTF8' is an alias for this charset.

`UCS-2'
`ISO-10646-UCS-2' and `csUnicode' are aliases for this
charset.

`UCS-2BE'
`UNICODEBIG', `UNICODE-1-1' and `csUnicode11' are aliases for
this charset.

`UCS-2LE'
`UNICODELITTLE' is an alias for this charset.

`UCS-4'
`ISO-10646-UCS-4' and `csUCS4' are aliases for this charset.

`UCS-4BE'

`UCS-4LE'

`UTF-16'

`UTF-16BE'

`UTF-16LE'

`UTF-7'
`UNICODE-1-1-UTF-7' and `csUnicode11UTF7' are aliases for
this charset.

`UCS-2-INTERNAL'

`UCS-2-SWAPPED'

`UCS-4-INTERNAL'

`UCS-4-SWAPPED'

`JAVA'
* Standard 8-bit encodings
`ISO-8859-1'
`ISO_8859-1', `ISO_8859-1:1987', `ISO-IR-100', `CP819',
`IBM819', `LATIN1', `L1', `csISOLatin1', `ISO8859-1' and
`ISO8859_1' are aliases for this charset.

`ISO-8859-2'
`ISO_8859-2', `ISO_8859-2:1987', `ISO-IR-101', `LATIN2',
`L2', `csISOLatin2', `ISO8859-2' and `ISO8859_2' are aliases
for this charset.

`ISO-8859-3'
`ISO_8859-3', `ISO_8859-3:1988', `ISO-IR-109', `LATIN3',
`L3', `csISOLatin3', `ISO8859-3' and `ISO8859_3' are aliases
for this charset.

`ISO-8859-4'
`ISO_8859-4', `ISO_8859-4:1988', `ISO-IR-110', `LATIN4',
`L4', `csISOLatin4', `ISO8859-4' and `ISO8859_4' are aliases
for this charset.

`ISO-8859-5'
`ISO_8859-5', `ISO_8859-5:1988', `ISO-IR-144', `CYRILLIC',
`csISOLatinCyrillic', `ISO8859-5' and `ISO8859_5' are aliases
for this charset.

`ISO-8859-6'
`ISO_8859-6', `ISO_8859-6:1987', `ISO-IR-127', `ECMA-114',
`ASMO-708', `ARABIC', `csISOLatinArabic', `ISO8859-6' and
`ISO8859_6' are aliases for this charset.

`ISO-8859-7'
`ISO_8859-7', `ISO_8859-7:1987', `ISO-IR-126', `ECMA-118',
`ELOT_928', `GREEK8', `GREEK', `csISOLatinGreek', `ISO8859-7'
and `ISO8859_7' are aliases for this charset.

`ISO-8859-8'
`ISO_8859-8', `ISO_8859-8:1988', `ISO-IR-138', `HEBREW',
`csISOLatinHebrew', `ISO8859-8' and `ISO8859_8' are aliases
for this charset.

`ISO-8859-9'
`ISO_8859-9', `ISO_8859-9:1989', `ISO-IR-148', `LATIN5',
`L5', `csISOLatin5', `ISO8859-9' and `ISO8859_9' are aliases
for this charset.

`ISO-8859-10'
`ISO_8859-10', `ISO_8859-10:1992', `ISO-IR-157', `LATIN6',
`L6', `csISOLatin6' and `ISO8859-10' are aliases for this
charset.

`ISO-8859-13'
`ISO_8859-13', `ISO-IR-179', `LATIN7' and `L7' are aliases
for this charset.

`ISO-8859-14'
`ISO_8859-14', `ISO_8859-14:1998', `ISO-IR-199', `LATIN8' and
`L8' are aliases for this charset.

`ISO-8859-15'
`ISO_8859-15', `ISO_8859-15:1998' and `ISO-IR-203' are
aliases for this charset.

`ISO-8859-16'
`ISO_8859-16', `ISO_8859-16:2000' and `ISO-IR-226' are
aliases for this charset.

`KOI8-R'
`csKOI8R' is an alias for this charset.

`KOI8-U'

`KOI8-RU'
* Windows 8-bit encodings
`CP1250'
`WINDOWS-1250' and `MS-EE' are aliases for this charset.

`CP1251'
`WINDOWS-1251' and `MS-CYRL' are aliases for this charset.

`CP1252'
`WINDOWS-1252' and `MS-ANSI' are aliases for this charset.

`CP1253'
`WINDOWS-1253' and `MS-GREEK' are aliases for this charset.

`CP1254'
`WINDOWS-1254' and `MS-TURK' are aliases for this charset.

`CP1255'
`WINDOWS-1255' and `MS-HEBR' are aliases for this charset.

`CP1256'
`WINDOWS-1256' and `MS-ARAB' are aliases for this charset.

`CP1257'
`WINDOWS-1257' and `WINBALTRIM' are aliases for this charset.

`CP1258'
`WINDOWS-1258' is an alias for this charset.

* DOS 8-bit encodings
`CP850'
`IBM850', `850' and `csPC850Multilingual' are aliases for
this charset.

`CP866'
`IBM866', `866' and `csIBM866' are aliases for this charset.

* Macintosh 8-bit encodings
`MacRoman'
`Macintosh', `MAC' and `csMacintosh' are aliases for this
charset.

`MacCentralEurope'

`MacIceland'

`MacCroatian'

`MacRomania'

`MacCyrillic'

`MacUkraine'

`MacGreek'

`MacTurkish'

`MacHebrew'

`MacArabic'

`MacThai'
* Other platform specific 8-bit encodings
`HP-ROMAN8'
`ROMAN8', `R8' and `csHPRoman8' are aliases for this charset.

`NEXTSTEP'
* Regional 8-bit encodings used for a single language
`ARMSCII-8'

`Georgian-Academy'

`Georgian-PS'

`MuleLao-1'

`CP1133'
`IBM-CP1133' is an alias for this charset.

`TIS-620'
`TIS620', `TIS620-0', `TIS620.2529-1', `TIS620.2533-0',
`TIS620.2533-1' and `ISO-IR-166' are aliases for this charset.

`CP874'
`WINDOWS-874' is an alias for this charset.

`VISCII'
`VISCII1.1-1' and `csVISCII' are aliases for this charset.

`TCVN'
`TCVN-5712', `TCVN5712-1' and `TCVN5712-1:1993' are aliases
for this charset.

* CJK character sets (not documented)
`JIS_C6220-1969-RO'
`ISO646-JP', `ISO-IR-14', `JP' and `csISO14JISC6220ro' are
aliases for this charset.

`JIS_X0201'
`JISX0201-1976', `X0201', `csHalfWidthKatakana',
`JISX0201.1976-0' and `JIS0201' are aliases for this charset.

`JIS_X0208'
`JIS_X0208-1983', `JIS_X0208-1990', `JIS0208', `X0208',
`ISO-IR-87', `csISO87JISX0208', `JISX0208.1983-0',
`JISX0208.1990-0' and `JIS0208' are aliases for this charset.

`JIS_X0212'
`JIS_X0212.1990-0', `JIS_X0212-1990', `X0212', `ISO-IR-159',
`csISO159JISX02121990', `JISX0212.1990-0' and `JIS0212' are
aliases for this charset.

`GB_1988-80'
`ISO646-CN', `ISO-IR-57', `CN' and `csISO57GB1988' are
aliases for this charset.

`GB_2312-80'
`ISO-IR-58', `csISO58GB231280', `CHINESE' and `GB2312.1980-0'
are aliases for this charset.

`ISO-IR-165'
`CN-GB-ISOIR165' is an alias for this charset.

`KSC_5601'
`KS_C_5601-1987', `KS_C_5601-1989', `ISO-IR-149',
`csKSC56011987', `KOREAN', `KSC5601.1987-0' and
`KSX1001:1992' are aliases for this charset.

* CJK encodings
`EUC-JP'
`EUCJP', `Extended_UNIX_Code_Packed_Format_for_Japanese',
`csEUCPkdFmtJapanese' and `EUC_JP' are aliases for this
charset.

`SJIS'
`SHIFT_JIS', `SHIFT-JIS', `MS_KANJI' and `csShiftJIS' are
aliases for this charset.

`CP932'

`ISO-2022-JP'
`csISO2022JP' and `ISO2022JP' are aliases for this charset.

`ISO-2022-JP-1'

`ISO-2022-JP-2'
`csISO2022JP2' is an alias for this charset.

`EUC-CN'
`EUCCN', `GB2312', `CN-GB', `csGB2312' and `EUC_CN' are
aliases for this charset.

`GBK'
`CP936' is an alias for this charset.

`GB18030'

`ISO-2022-CN'
`csISO2022CN' and `ISO2022CN' are aliases for this charset.

`ISO-2022-CN-EXT'

`HZ'
`HZ-GB-2312' is an alias for this charset.

`EUC-TW'
`EUCTW', `csEUCTW' and `EUC_TW' are aliases for this charset.

`BIG5'
`BIG-5', `BIG-FIVE', `BIGFIVE', `CN-BIG5' and `csBig5' are
aliases for this charset.

`CP950'

`BIG5HKSCS'

`EUC-KR'
`EUCKR', `csEUCKR' and `EUC_KR' are aliases for this charset.

`CP949'
`UHC' is an alias for this charset.

`JOHAB'
`CP1361' is an alias for this charset.

`ISO-2022-KR'
`csISO2022KR' and `ISO2022KR' are aliases for this charset.

`CHAR'

`WCHAR_T'

File: recode.info, Node: Tabular, Next: ASCII misc, Prev: libiconv, Up: Top

Tabular sources (RFC 1345)
**************************

An important part of the tabular charset knowledge in `recode' comes
from RFC 1345 or, alternatively, from the `chset' tools, both
maintained by Keld Simonsen. The RFC 1345 document:

"Character Mnemonics & Character Sets", K. Simonsen, Request for
Comments no. 1345, Network Working Group, June 1992.

defines many character mnemonics and character sets. The `recode'
library implements most of RFC 1345, however:

* It does not recognise those charsets which overload character
positions: `dk-us' and `us-dk'. However, *Note Mixed::.

* It does not recognise those charsets which combine two characters
for representing a third: `ANSI_X3.110-1983', `ISO_6937-2-add',
`T.101-G2', `T.61-8bit', `iso-ir-90' and `videotex-suppl'.

* It does not recognise 16-bits charsets: `GB_2312-80',
`JIS_C6226-1978', `JIS_C6226-1983', `JIS_X0212-1990' and
`KS_C_5601-1987'.

* It interprets the charset `isoir91' as `NATS-DANO' (alias
`iso-ir-9-1'), _not_ as `JIS_C6229-1984-a' (alias `iso-ir-91').
It also interprets the charset `isoir92' as `NATS-DANO-ADD' (alias
`iso-ir-9-2'), _not_ as `JIS_C6229-1984-b' (alias `iso-ir-92').
It might be better just avoiding these two alias names.

Keld Simonsen <keld AT dkuug.dk> did most of RFC 1345 himself, with
some funding from Danish Standards and Nordic standards (INSTA) project.
He also did the character set design work, with substantial input from
Olle Jaernefors. Keld typed in almost all of the tables, some have been
contributed. A number of people have checked the tables in various
ways. The RFC lists a number of people who helped.

Keld and the `recode' maintainer have an arrangement by which any new
discovered information submitted by `recode' users, about tabular
charsets, is forwarded to Keld, eventually merged into Keld's work, and
only then, reimported into `recode'. Neither the `recode' program nor
its library try to compete, nor even establish themselves as an
alternate or diverging reference: RFC 1345 and its new drafts stay the
genuine source for most tabular information conveyed by `recode'. Keld
has been more than collaborative so far, so there is no reason that we
act otherwise. In a word, `recode' should be perceived as the
application of external references, but not as a reference in itself.

Internally, RFC 1345 associates which each character an unambiguous
mnemonic of a few characters, taken from ISO 646, which is a minimal
ASCII subset of 83 characters. The charset made up by these mnemonics
is available in `recode' under the name `RFC1345'. It has `mnemonic'
and `1345' for aliases. As implemened, this charset exactly
corresponds to `mnemonic+ascii+38', using RFC 1345 nomenclature.
Roughly said, ISO 646 characters represent themselves, except for the
ampersand (`&') which appears doubled. A prefix of a single ampersand
introduces a mnemonic. For mnemonics using two characters, the prefix
is immediately by the mnemonic. For longer mnemonics, the prefix is
followed by an underline (`_'), the mmemonic, and another underline.
Conversions to this charset are usually reversible.

Currently, `recode' does not offer any of the many other possible
variations of this family of representations. They will likely be
implemented in some future version, however.

`ANSI_X3.4-1968'
`367', `ANSI_X3.4-1986', `ASCII', `CP367', `IBM367', `ISO646-US',
`ISO_646.irv:1991', `US-ASCII', `iso-ir-6' and `us' are aliases
for this charset. Source: ISO 2375 registry.

`ASMO_449'
`ISO_9036', `arabic7' and `iso-ir-89' are aliases for this charset.
Source: ISO 2375 registry.

`BS_4730'
`ISO646-GB', `gb', `iso-ir-4' and `uk' are aliases for this
charset. Source: ISO 2375 registry.

`BS_viewdata'
`iso-ir-47' is an alias for this charset. Source: ISO 2375
registry.

`CP1250'
`1250', `ms-ee' and `windows-1250' are aliases for this charset.
Source: UNICODE 1.0.

`CP1251'
`1251', `ms-cyrl' and `windows-1251' are aliases for this charset.
Source: UNICODE 1.0.

`CP1252'
`1252', `ms-ansi' and `windows-1252' are aliases for this charset.
Source: UNICODE 1.0.

`CP1253'
`1253', `ms-greek' and `windows-1253' are aliases for this charset.
Source: UNICODE 1.0.

`CP1254'
`1254', `ms-turk' and `windows-1254' are aliases for this charset.
Source: UNICODE 1.0.

`CP1255'
`1255', `ms-hebr' and `windows-1255' are aliases for this charset.
Source: UNICODE 1.0.

`CP1256'
`1256', `ms-arab' and `windows-1256' are aliases for this charset.
Source: UNICODE 1.0.

`CP1257'
`1257', `WinBaltRim' and `windows-1257' are aliases for this
charset. Source: CEN/TC304 N283.

`CSA_Z243.4-1985-1'
`ISO646-CA', `ca', `csa7-1' and `iso-ir-121' are aliases for this
charset. Source: ISO 2375 registry.

`CSA_Z243.4-1985-2'
`ISO646-CA2', `csa7-2' and `iso-ir-122' are aliases for this
charset. Source: ISO 2375 registry.

`CSA_Z243.4-1985-gr'
`iso-ir-123' is an alias for this charset. Source: ISO 2375
registry.

`CSN_369103'
`KOI-8_L2', `iso-ir-139' and `koi8l2' are aliases for this charset.
Source: ISO 2375 registry.

`CWI'
`CWI-2' and `cp-hu' are aliases for this charset. Source:
Computerworld Sza'mita'stechnika vol 3 issue 13 1988-06-29.

`DEC-MCS'
`dec' is an alias for this charset. VAX/VMS User's Manual, Order
Number: AI-Y517A-TE, April 1986.

`DIN_66003'
`ISO646-DE', `de' and `iso-ir-21' are aliases for this charset.
Source: ISO 2375 registry.

`DS_2089'
`DS2089', `ISO646-DK' and `dk' are aliases for this charset.
Source: Danish Standard, DS 2089, February 1974.

`EBCDIC-AT-DE'
Source: IBM 3270 Char Set Ref Ch 10, GA27-2837-9, April 1987.

`EBCDIC-AT-DE-A'
Source: IBM 3270 Char Set Ref Ch 10, GA27-2837-9, April 1987.

`EBCDIC-CA-FR'
Source: IBM 3270 Char Set Ref Ch 10, GA27-2837-9, April 1987.

`EBCDIC-DK-NO'
Source: IBM 3270 Char Set Ref Ch 10, GA27-2837-9, April 1987.

`EBCDIC-DK-NO-A'
Source: IBM 3270 Char Set Ref Ch 10, GA27-2837-9, April 1987.

`EBCDIC-ES'
Source: IBM 3270 Char Set Ref Ch 10, GA27-2837-9, April 1987.

`EBCDIC-ES-A'
Source: IBM 3270 Char Set Ref Ch 10, GA27-2837-9, April 1987.

`EBCDIC-ES-S'
Source: IBM 3270 Char Set Ref Ch 10, GA27-2837-9, April 1987.

`EBCDIC-FI-SE'
Source: IBM 3270 Char Set Ref Ch 10, GA27-2837-9, April 1987.

`EBCDIC-FI-SE-A'
Source: IBM 3270 Char Set Ref Ch 10, GA27-2837-9, April 1987.

`EBCDIC-FR'
Source: IBM 3270 Char Set Ref Ch 10, GA27-2837-9, April