package Encode;
use strict;
-our $VERSION = do { my @r = (q$Revision: 0.99 $ =~ /\d+/g); sprintf "%d."."%02d" x $#r, @r };
+our $VERSION = do { my @r = (q$Revision: 1.0 $ =~ /\d+/g); sprintf "%d."."%02d" x $#r, @r };
our $DEBUG = 0;
require DynaLoader;
use Encode;
+
+=head2 Table of Contents
+
+Encode consists of a collection of modules which details are too big
+to fit in one document. This POD itself explains the top-level APIs
+and general topics at a glance. For other topics and more details,
+see the PODs below;
+
+ Name Description
+ --------------------------------------------------------
+ Encode::Alias Alias defintions to encodings
+ Encode::Encoding Encode Implementation Base Class
+ Encode::Supported List of Supported Encodings
+ Encode::CN Simplified Chinese Encodings
+ Encode::JP Japanese Encodings
+ Encode::KR Korean Encodings
+ Encode::TW Traditional Chinese Encodings
+ --------------------------------------------------------
+
=head1 DESCRIPTION
The C<Encode> module provides the interfaces between Perl's strings
-and the rest of the system. Perl strings are sequences of B<characters>.
+and the rest of the system. Perl strings are sequences of
+B<characters>.
+
+The repertoire of characters that Perl can represent is at least that
+defined by the Unicode Consortium. On most platforms the ordinal
+values of the characters (as returned by C<ord(ch)>) is the "Unicode
+codepoint" for the character (the exceptions are those platforms where
+the legacy encoding is some variant of EBCDIC rather than a super-set
+of ASCII - see L<perlebcdic>).
+
+Traditionally computer data has been moved around in 8-bit chunks
+often called "bytes". These chunks are also known as "octets" in
+networking standards. Perl is widely used to manipulate data of many
+types - not only strings of characters representing human or computer
+languages but also "binary" data being the machines representation of
+numbers, pixels in an image - or just about anything.
+
+When Perl is processing "binary data" the programmer wants Perl to
+process "sequences of bytes". This is not a problem for Perl - as a
+byte has 256 possible values it easily fits in Perl's much larger
+"logical character".
+
+=head2 TERMINOLOGY
-To find more about character encodings, please consult
-L<Encode::Details>. This document focuses on programming references.
+=over 4
-=head1 PERL ENCODING API
+=item *
+
+I<character>: a character in the range 0..(2**32-1) (or more).
+(What Perl's strings are made of.)
+
+=item *
+
+I<byte>: a character in the range 0..255
+(A special case of a Perl character.)
+
+=item *
+
+I<octet>: 8 bits of data, with ordinal values 0..255
+(Term for bytes passed to or from a non-Perl context, e.g. disk file.)
+
+=back
-=head2 Generic Encoding Interface
+The marker [INTERNAL] marks Internal Implementation Details, in
+general meant only for those who think they know what they are doing,
+and such details may change in future releases.
+
+=head1 PERL ENCODING API
=over 4
=item $bytes = encode(ENCODING, $string[, CHECK])
Encodes string from Perl's internal form into I<ENCODING> and returns
-a sequence of octets. For CHECK see L</"Handling Malformed Data">.
+a sequence of octets. ENCODING can be either a canonical name or
+alias. For encoding names and aliases, see L</"Defining Aliases">.
+For CHECK see L</"Handling Malformed Data">.
-For example to convert (internally UTF-8 encoded) Unicode data
-to octets:
+For example to convert (internally UTF-8 encoded) Unicode string to
+iso-8859-1 (also known as Latin1),
- $octets = encode("utf8", $unicode);
+ $octets = encode("iso-8859-1", $unicode);
=item $string = decode(ENCODING, $bytes[, CHECK])
Decode sequence of octets assumed to be in I<ENCODING> into Perl's
-internal form and returns the resulting string. For CHECK see
+internal form and returns the resulting string. as in encode(),
+ENCODING can be either a canonical name or alias. For encoding names
+and aliases, see L</"Defining Aliases">. For CHECK see
L</"Handling Malformed Data">.
For example to convert ISO-8859-1 data to UTF-8:
- $utf8 = decode("latin1", $latin1);
+ $utf8 = decode("iso-8859-1", $latin1);
=item from_to($string, FROM_ENCODING, TO_ENCODING[, CHECK])
Convert B<in-place> the data between two encodings. How did the data
in $string originally get to be in FROM_ENCODING? Either using
-encode() or through PerlIO: See L</"Encoding and IO">. For CHECK
-see L</"Handling Malformed Data">.
+encode() or through PerlIO: See L</"Encoding and IO">.
+For encoding names and aliases, see L</"Defining Aliases">.
+For CHECK see L</"Handling Malformed Data">.
For example to convert ISO-8859-1 data to UTF-8:
=back
-=head2 Handling Malformed Data
-
-If CHECK is not set, C<undef> is returned. If the data is supposed to
-be UTF-8, an optional lexical warning (category utf8) is given. If
-CHECK is true but not a code reference, dies.
-
-It would desirable to have a way to indicate that transform should use
-the encodings "replacement character" - no such mechanism is defined yet.
-
-It is also planned to allow I<CHECK> to be a code reference.
-
-This is not yet implemented as there are design issues with what its
-arguments should be and how it returns its results.
-
-=over 4
-
-=item Scheme 1
-
-Passed remaining fragment of string being processed.
-Modifies it in place to remove bytes/characters it can understand
-and returns a string used to represent them.
-e.g.
-
- sub fixup {
- my $ch = substr($_[0],0,1,'');
- return sprintf("\x{%02X}",ord($ch);
- }
-
-This scheme is close to how underlying C code for Encode works, but gives
-the fixup routine very little context.
-
-=item Scheme 2
-
-Passed original string, and an index into it of the problem area, and
-output string so far. Appends what it will to output string and
-returns new index into original string. For example:
-
- sub fixup {
- # my ($s,$i,$d) = @_;
- my $ch = substr($_[0],$_[1],1);
- $_[2] .= sprintf("\x{%02X}",ord($ch);
- return $_[1]+1;
- }
-
-This scheme gives maximal control to the fixup routine but is more
-complicated to code, and may need internals of Encode to be tweaked to
-keep original string intact.
-
-=item Other Schemes
-
-Hybrids of above.
-
-Multiple return values rather than in-place modifications.
-
-Index into the string could be C<pos($str)> allowing C<s/\G...//>.
-
-=back
-
-=head2 UTF-8 / utf8
-
-The Unicode consortium defines the UTF-8 standard as a way of encoding
-the entire Unicode repertoire as sequences of octets. This encoding is
-expected to become very widespread. Perl can use this form internally
-to represent strings, so conversions to and from this form are
-particularly efficient (as octets in memory do not have to change,
-just the meta-data that tells Perl how to treat them).
-
-=over 4
-
-=item $bytes = encode_utf8($string);
-
-The characters that comprise string are encoded in Perl's superset of UTF-8
-and the resulting octets returned as a sequence of bytes. All possible
-characters have a UTF-8 representation so this function cannot fail.
-
-=item $string = decode_utf8($bytes [, CHECK]);
-
-The sequence of octets represented by $bytes is decoded from UTF-8
-into a sequence of logical characters. Not all sequences of octets
-form valid UTF-8 encodings, so it is possible for this call to fail.
-For CHECK see L</"Handling Malformed Data">.
-
-=back
-
=head2 Listing available encodings
use Encode;
To find which encodings are supported by this package in details,
see L<Encode::Supported>.
+
=head2 Defining Aliases
+To add new alias to a given encoding, Use;
+
use Encode;
use Encode::Alias;
define_alias(newName => ENCODING);
-Allows newName to be used as am alias for ENCODING. ENCODING may be
-either the name of an encoding or and encoding object (as above).
+After that, newName can be to be used as am alias for ENCODING.
+ENCODING may be either the name of an encoding or and I<encoding
+object>
See L<Encode::Alias> on details.
-=head1 Defining Encodings
-
- use Encode qw(define_alias);
- define_encoding($object, 'canonicalName' [, alias...]);
-
-Causes I<canonicalName> to be associated with I<$object>. The object
-should provide the interface described in L<Encode::Encoding>
-below. If more than two arguments are provided then additional
-arguments are taken as aliases for I<$object> as for C<define_alias>.
-
=head1 Encoding and IO
It is very common to want to do encoding transformations when
See also L<encoding> for how to change the default encoding of the
data in your script.
+=head1 Handling Malformed Data
+
+If CHECK is not set, C<undef> is returned. If the data is supposed to
+be UTF-8, an optional lexical warning (category utf8) is given. If
+CHECK is true but not a code reference, dies.
+
+It would desirable to have a way to indicate that transform should use
+the encodings "replacement character" - no such mechanism is defined yet.
+
+It is also planned to allow I<CHECK> to be a code reference.
+
+This is not yet implemented as there are design issues with what its
+arguments should be and how it returns its results.
+
+=over 4
+
+=item Scheme 1
+
+Passed remaining fragment of string being processed.
+Modifies it in place to remove bytes/characters it can understand
+and returns a string used to represent them.
+e.g.
+
+ sub fixup {
+ my $ch = substr($_[0],0,1,'');
+ return sprintf("\x{%02X}",ord($ch);
+ }
+
+This scheme is close to how underlying C code for Encode works, but gives
+the fixup routine very little context.
+
+=item Scheme 2
+
+Passed original string, and an index into it of the problem area, and
+output string so far. Appends what it will to output string and
+returns new index into original string. For example:
+
+ sub fixup {
+ # my ($s,$i,$d) = @_;
+ my $ch = substr($_[0],$_[1],1);
+ $_[2] .= sprintf("\x{%02X}",ord($ch);
+ return $_[1]+1;
+ }
+
+This scheme gives maximal control to the fixup routine but is more
+complicated to code, and may need internals of Encode to be tweaked to
+keep original string intact.
+
+=item Other Schemes
+
+Hybrids of above.
+
+Multiple return values rather than in-place modifications.
+
+Index into the string could be C<pos($str)> allowing C<s/\G...//>.
+
+=back
+
+=head2 UTF-8 / utf8
+
+The Unicode consortium defines the UTF-8 standard as a way of encoding
+the entire Unicode repertoire as sequences of octets. This encoding is
+expected to become very widespread. Perl can use this form internally
+to represent strings, so conversions to and from this form are
+particularly efficient (as octets in memory do not have to change,
+just the meta-data that tells Perl how to treat them).
+
+=over 4
+
+=item $bytes = encode_utf8($string);
+
+The characters that comprise string are encoded in Perl's superset of UTF-8
+and the resulting octets returned as a sequence of bytes. All possible
+characters have a UTF-8 representation so this function cannot fail.
+
+=item $string = decode_utf8($bytes [, CHECK]);
+
+The sequence of octets represented by $bytes is decoded from UTF-8
+into a sequence of logical characters. Not all sequences of octets
+form valid UTF-8 encodings, so it is possible for this call to fail.
+For CHECK see L</"Handling Malformed Data">.
+
+=back
+
+=head1 Defining Encodings
+
+To define a new encoding, use:
+
+ use Encode qw(define_alias);
+ define_encoding($object, 'canonicalName' [, alias...]);
+
+I<canonicalName> will be associated with I<$object>. The object
+should provide the interface described in L<Encode::Encoding>
+If more than two arguments are provided then additional
+arguments are taken as aliases for I<$object> as for C<define_alias>.
+
=head1 Messing with Perl's Internals
The following API uses parts of Perl's internals in the current
=head1 SEE ALSO
-L<Encode::Details>,
L<Encode::Encoding>,
L<Encode::Supported>,
L<PerlIO>,
https://perl5.git.perl.org / perl5.git / blobdiff