This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Adding new files to MANIFEST is nice.
[perl5.git] / pod / perluniintro.pod
CommitLineData
ba62762e
JH
1=head1 NAME
2
07fcf8ff 3perluniintro - Perl Unicode introduction
ba62762e
JH
4
5=head1 DESCRIPTION
6
7This document gives a general idea of Unicode and how to use Unicode
8in Perl.
9
10=head2 Unicode
11
12Unicode is a character set standard with plans to cover all of the
13writing systems of the world, plus many other symbols.
14
15Unicode and ISO/IEC 10646 are coordinated standards that provide code
16points for the characters in almost all modern character set standards,
17covering more than 30 writing systems and hundreds of languages,
18including all commercially important modern languages. All characters
19in the largest Chinese, Japanese, and Korean dictionaries are also
20encoded. The standards will eventually cover almost all characters in
21more than 250 writing systems and thousands of languages.
22
23A Unicode I<character> is an abstract entity. It is not bound to any
24particular integer width, and especially not to the C language C<char>.
25Unicode is language neutral and display neutral: it doesn't encode the
26language of the text, and it doesn't define fonts or other graphical
27layout details. Unicode operates on characters and on text built from
28those characters.
29
30Unicode defines characters like C<LATIN CAPITAL LETTER A> or C<GREEK
31SMALL LETTER ALPHA>, and then unique numbers for those, hexadecimal
320x0041 or 0x03B1 for those particular characters. Such unique
33numbers are called I<code points>.
34
35The Unicode standard prefers using hexadecimal notation for the code
36points. (In case this notation, numbers like 0x0041, is unfamiliar to
37you, take a peek at a later section, L</"Hexadecimal Notation">.)
38The Unicode standard uses the notation C<U+0041 LATIN CAPITAL LETTER A>,
39which gives the hexadecimal code point, and the normative name of
40the character.
41
42Unicode also defines various I<properties> for the characters, like
43"uppercase" or "lowercase", "decimal digit", or "punctuation":
44these properties are independent of the names of the characters.
45Furthermore, various operations on the characters like uppercasing,
46lowercasing, and collating (sorting), are defined.
47
48A Unicode character consists either of a single code point, or a
49I<base character> (like C<LATIN CAPITAL LETTER A>), followed by one or
50more I<modifiers> (like C<COMBINING ACUTE ACCENT>). This sequence of
51a base character and modifiers is called a I<combining character
52sequence>.
53
54Whether to call these combining character sequences, as a whole,
55"characters" depends on your point of view. If you are a programmer, you
56probably would tend towards seeing each element in the sequences as one
57unit, one "character", but from the user viewpoint, the sequence as a
58whole is probably considered one "character", since that's probably what
59it looks like in the context of the user's language.
60
61With this "as a whole" view of characters, the number of characters is
62open-ended. But in the programmer's "one unit is one character" point of
63view, the concept of "characters" is more deterministic, and so we take
64that point of view in this document: one "character" is one Unicode
65code point, be it a base character or a combining character.
66
67For some of the combinations there are I<precomposed> characters,
68for example C<LATIN CAPITAL LETTER A WITH ACUTE> is defined as
69a single code point. These precomposed characters are, however,
70often available only for some combinations, and mainly they are
71meant to support round-trip conversions between Unicode and legacy
72standards (like the ISO 8859), and in general case the composing
73method is more extensible. To support conversion between the
74different compositions of the characters, various I<normalization
75forms> are also defined.
76
77Because of backward compatibility with legacy encodings, the "a unique
78number for every character" breaks down a bit: "at least one number
79for every character" is closer to truth. (This happens when the same
80character has been encoded in several legacy encodings.) The converse
81is also not true: not every code point has an assigned character.
82Firstly, there are unallocated code points within otherwise used
83blocks. Secondly, there are special Unicode control characters that
84do not represent true characters.
85
86A common myth about Unicode is that it would be "16-bit", that is,
870x10000 (or 65536) characters from 0x0000 to 0xFFFF. B<This is untrue.>
88Since Unicode 2.0 Unicode has been defined all the way up to 21 bits
89(0x10FFFF), and since 3.1 characters have been defined beyond 0xFFFF.
90The first 0x10000 characters are called the I<Plane 0>, or the I<Basic
91Multilingual Plane> (BMP). With the Unicode 3.1, 17 planes in all are
92defined (but nowhere near full of defined characters yet).
93
94Another myth is that the 256-character blocks have something to do
95with languages: a block per language. B<Also this is untrue.>
96The division into the blocks exists but it is almost completely
97accidental, an artifact of how the characters have been historically
98allocated. Instead, there is a concept called I<scripts>, which may
99be more useful: there is C<Latin> script, C<Greek> script, and so on.
100Scripts usually span several parts of several blocks. For further
101information see L<Unicode::UCD>.
102
103The Unicode code points are just abstract numbers. To input and
104output these abstract numbers, the numbers must be I<encoded> somehow.
105Unicode defines several I<character encoding forms>, of which I<UTF-8>
106is perhaps the most popular. UTF-8 is a variable length encoding that
107encodes Unicode characters as 1 to 6 bytes (only 4 with the currently
108defined characters). Other encodings are UTF-16 and UTF-32 and their
109big and little endian variants (UTF-8 is byteorder independent).
110The ISO/IEC 10646 defines the UCS-2 and UCS-4 encoding forms.
111
112For more information about encodings, for example to learn what
113I<surrogates> and I<byte order marks> (BOMs) are, see L<perlunicode>.
114
115=head2 Perl's Unicode Support
116
117Starting from Perl 5.6.0, Perl has had the capability of handling
118Unicode natively. The first recommended release for serious Unicode
119work is Perl 5.8.0, however. The maintenance release 5.6.1 fixed many
120of the problems of the initial implementation of Unicode, but for
121example regular expressions didn't really work with Unicode.
122
123B<Starting from Perl 5.8.0, the use of C<use utf8> is no longer
124necessary.> In earlier releases the C<utf8> pragma was used to declare
125that operations in the current block or file would be Unicode-aware.
126This model was found to be wrong, or at least clumsy: the Unicodeness
127is now carried with the data, not attached to the operations. (There
128is one remaining case where an explicit C<use utf8> is needed: if your
129Perl script is in UTF-8, you can use UTF-8 in your variable and
130subroutine names, and in your string and regular expression literals,
131by saying C<use utf8>. This is not the default because that would
132break existing scripts having legacy 8-bit data in them.)
133
134=head2 Perl's Unicode Model
135
136Perl supports both the old, pre-5.6, model of strings of eight-bit
137native bytes, and strings of Unicode characters. The principle is
138that Perl tries to keep its data as eight-bit bytes for as long as
139possible, but as soon as Unicodeness cannot be avoided, the data is
140transparently upgraded to Unicode.
141
142The internal encoding of Unicode in Perl is UTF-8. The internal
143encoding is normally hidden, however, and one need not and should not
144worry about the internal encoding at all: it is all just characters.
145
146Perl 5.8.0 will also support Unicode on EBCDIC platforms. There the
147support is somewhat harder to implement since additional conversions
148are needed at every step. Because of these difficulties the Unicode
149support won't be quite as full as in other, mainly ASCII-based,
150platforms (the Unicode support will be better than in the 5.6 series,
151which didn't work much at all for EBCDIC platform). On EBCDIC
152platforms the internal encoding form used is UTF-EBCDIC.
153
154=head2 Creating Unicode
155
156To create Unicode literals, use the C<\x{...}> notation in
157doublequoted strings:
158
159 my $smiley = "\x{263a}";
160
161Similarly for regular expression literals
162
163 $smiley =~ /\x{263a}/;
164
165At run-time you can use C<chr()>:
166
167 my $hebrew_alef = chr(0x05d0);
168
169(See L</"Further Resources"> for how to find all these numeric codes.)
170
171Naturally, C<ord()> will do the reverse: turn a character to a code point.
172
173Note that C<\x..>, C<\x{..}> and C<chr(...)> for arguments less than
1740x100 (decimal 256) will generate an eight-bit character for backward
175compatibility with older Perls. For arguments of 0x100 or more,
176Unicode will always be produced. If you want UTF-8 always, use
177C<pack("U", ...)> instead of C<\x..>, C<\x{..}>, or C<chr()>.
178
179You can also use the C<charnames> pragma to invoke characters
180by name in doublequoted strings:
181
182 use charnames ':full';
183 my $arabic_alef = "\N{ARABIC LETTER ALEF}";
184
185And, as mentioned above, you can also C<pack()> numbers into Unicode
186characters:
187
188 my $georgian_an = pack("U", 0x10a0);
189
190=head2 Handling Unicode
191
192Handling Unicode is for the most part transparent: just use the
193strings as usual. Functions like C<index()>, C<length()>, and
194C<substr()> will work on the Unicode characters; regular expressions
195will work on the Unicode characters (see L<perlunicode> and L<perlretut>).
196
197Note that Perl does B<not> consider combining character sequences
198to be characters, such for example
199
200 use charnames ':full';
201 print length("\N{LATIN CAPITAL LETTER A}\N{COMBINING ACUTE ACCENT}"), "\n";
202
203will print 2, not 1. The only exception is that regular expressions
204have C<\X> for matching a combining character sequence.
205
206When life is not quite so transparent is working with legacy
207encodings, and I/O, and certain special cases.
208
209=head2 Legacy Encodings
210
211When you combine legacy data and Unicode the legacy data needs
212to be upgraded to Unicode. Normally ISO 8859-1 (or EBCDIC, if
213applicable) is assumed. You can override this assumption by
214using the C<encoding> pragma, for example
215
216 use encoding 'latin2'; # ISO 8859-2
217
218in which case literals (string or regular expression) and chr/ord
219in your whole script are assumed to produce Unicode characters from
220ISO 8859-2 code points. Note that the matching for the encoding
221names is forgiving: instead of C<latin2> you could have said
222C<Latin 2>, or C<iso8859-2>, and so forth. With just
223
224 use encoding;
225
226first the environment variable C<PERL_ENCODING> will be consulted,
227and if that doesn't exist, ISO 8859-1 (Latin 1) will be assumed.
228
229The C<Encode> module knows about many encodings and it has interfaces
230for doing conversions between those encodings:
231
232 use Encode 'from_to';
233 from_to($data, "iso-8859-3", "utf-8"); # from legacy to utf-8
234
235=head2 Unicode I/O
236
237Normally writing out Unicode data
238
239 print chr(0x100), "\n";
240
241will print out the raw UTF-8 bytes.
242
243But reading in correctly formed UTF-8 data will not magically turn
244the data into Unicode in Perl's eyes.
245
246You can use either the C<':utf8'> I/O discipline when opening files
247
248 open(my $fh,'<:utf8', 'anything');
249 my $line_of_utf8 = <$fh>;
250
251The I/O disciplines can also be specified more flexibly with
252the C<open> pragma; see L<open>:
253
254 use open ':utf8'; # input and output will be UTF-8
255 open X, ">utf8";
256 print X chr(0x100), "\n"; # this would have been UTF-8 without the pragma
257 close X;
258 open Y, "<utf8";
259 printf "%#x\n", ord(<Y>); # this should print 0x100
260 close Y;
261
262With the C<open> pragma you can use the C<:locale> discipline
263
264 $ENV{LANG} = 'ru_RU.KOI8-R';
265 # the :locale will probe the locale environment variables like LANG
266 use open OUT => ':locale'; # russki parusski
267 open(O, ">koi8");
268 print O chr(0x430); # Unicode CYRILLIC SMALL LETTER A = KOI8-R 0xc1
269 close O;
270 open(I, "<koi8");
271 printf "%#x\n", ord(<I>), "\n"; # this should print 0xc1
272 close I;
273
274or you can also use the C<':encoding(...)'> discipline
275
276 open(my $epic,'<:encoding(iso-8859-7)','iliad.greek');
277 my $line_of_iliad = <$epic>;
278
279Both of these methods install a transparent filter on the I/O stream that
280will convert data from the specified encoding when it is read in from the
281stream. In the first example the F<anything> file is assumed to be UTF-8
282encoded Unicode, in the second example the F<iliad.greek> file is assumed
283to be ISO-8858-7 encoded Greek, but the lines read in will be in both
284cases Unicode.
285
286The L<open> pragma affects all the C<open()> calls after the pragma by
287setting default disciplines. If you want to affect only certain
288streams, use explicit disciplines directly in the C<open()> call.
289
290You can switch encodings on an already opened stream by using
291C<binmode()>, see L<perlfunc/binmode>.
292
293The C<:locale> does not currently work with C<open()> and
294C<binmode()>, only with the C<open> pragma. The C<:utf8> and
295C<:encoding(...)> do work with all of C<open()>, C<binmode()>,
296and the C<open> pragma.
297
298Similarly, you may use these I/O disciplines on input streams to
299automatically convert data from the specified encoding when it is
300written to the stream.
301
302 open(my $unicode, '<:utf8', 'japanese.uni');
303 open(my $nihongo, '>:encoding(iso2022-jp)', 'japanese.jp');
304 while (<$unicode>) { print $nihongo }
305
306The naming of encodings, both by the C<open()> and by the C<open>
307pragma, is similarly understanding as with the C<encoding> pragma:
308C<koi8-r> and C<KOI8R> will both be understood.
309
310Common encodings recognized by ISO, MIME, IANA, and various other
311standardisation organisations are recognised, for a more detailed
312list see L<Encode>.
313
314C<read()> reads characters and returns the number of characters.
315C<seek()> and C<tell()> operate on byte counts, as do C<sysread()>
316and C<sysseek()>.
317
318Notice that because of the default behaviour "input is not UTF-8"
319it is easy to mistakenly write code that keeps on expanding a file
320by repeatedly encoding it in UTF-8:
321
322 # BAD CODE WARNING
323 open F, "file";
324 local $/; # read in the whole file
325 $t = <F>;
326 close F;
327 open F, ">:utf8", "file";
328 print F $t;
329 close F;
330
331If you run this code twice, the contents of the F<file> will be twice
332UTF-8 encoded. A C<use open ':utf8'> would have avoided the bug.
333
334=head2 Special Cases
335
336=over 4
337
338=item *
339
340Bit Complement Operator ~ And vec()
341
342The bit complement operator C<~> will produce surprising results if
343used on strings containing Unicode characters. The results are
344consistent with the internal UTF-8 encoding of the characters, but not
345with much else. So don't do that. Similarly for vec(): you will be
346operating on the UTF-8 bit patterns of the Unicode characters, not on
347the bytes, which is very probably not what you want.
348
349=item *
350
351Peeking At UTF-8
352
353One way of peeking inside the internal encoding of Unicode characters
354is to use C<unpack("C*", ...> to get the bytes, or C<unpack("H*", ...)>
355to display the bytes:
356
357 # this will print c4 80 for the UTF-8 bytes 0xc4 0x80
358 print join(" ", unpack("H*", pack("U", 0x100))), "\n";
359
360Yet another way would be to use the Devel::Peek module:
361
362 perl -MDevel::Peek -e 'Dump(chr(0x100))'
363
364That will show the UTF8 flag in FLAGS and both the UTF-8 bytes
365and Unicode characters in PV. See also later in this document
366the discussion about the C<is_utf8> function of the C<Encode> module.
367
368=back
369
370=head2 Advanced Topics
371
372=over 4
373
374=item *
375
376String Equivalence
377
378The question of string equivalence turns somewhat complicated
379in Unicode: what do you mean by equal?
380
381 Is C<LATIN CAPITAL LETTER A WITH ACUTE> equal to
382 C<LATIN CAPITAL LETTER A>?
383
384The short answer is that by default Perl compares equivalence
385(C<eq>, C<ne>) based only on code points of the characters.
386In the above case, no (because 0x00C1 != 0x0041). But sometimes any
387CAPITAL LETTER As being considered equal, or even any As of any case,
388would be desirable.
389
390The long answer is that you need to consider character normalization
391and casing issues: see L<Unicode::Normalize>, and Unicode Technical
392Reports #15 and #21, I<Unicode Normalization Forms> and I<Case
393Mappings>, http://www.unicode.org/unicode/reports/tr15/
394http://www.unicode.org/unicode/reports/tr21/
395
396As of Perl 5.8.0, the's regular expression case-ignoring matching
397implements only 1:1 semantics: one character matches one character.
398In I<Case Mappings> both 1:N and N:1 matches are defined.
399
400=item *
401
402String Collation
403
404People like to see their strings nicely sorted, or as Unicode
405parlance goes, collated. But again, what do you mean by collate?
406
407 Does C<LATIN CAPITAL LETTER A WITH ACUTE> come before or after
408 C<LATIN CAPITAL LETTER A WITH GRAVE>?
409
410The short answer is that by default Perl compares strings (C<lt>,
411C<le>, C<cmp>, C<ge>, C<gt>) based only on the code points of the
412characters. In the above case, after, since 0x00C1 > 0x00C0.
413
414The long answer is that "it depends", and a good answer cannot be
415given without knowing (at the very least) the language context.
416See L<Unicode::Collate>, and I<Unicode Collation Algorithm>
417http://www.unicode.org/unicode/reports/tr10/
418
419=back
420
421=head2 Miscellaneous
422
423=over 4
424
425=item *
426
427Character Ranges
428
429Character ranges in regular expression character classes (C</[a-z]/>)
430and in the C<tr///> (also known as C<y///>) operator are not magically
431Unicode-aware. What this means that C<[a-z]> will not magically start
432to mean "all alphabetic letters" (not that it does mean that even for
4338-bit characters, you should be using C</[[:alpha]]/> for that).
434
435For specifying things like that in regular expressions you can use the
436various Unicode properties, C<\pL> in this particular case. You can
437use Unicode code points as the end points of character ranges, but
438that means that particular code point range, nothing more. For
439further information, see L<perlunicode>.
440
441=item *
442
443String-To-Number Conversions
444
445Unicode does define several other decimal (and numeric) characters
446than just the familiar 0 to 9, such as the Arabic and Indic digits.
447Perl does not support string-to-number conversion for digits other
448than the 0 to 9 (and a to f for hexadecimal).
449
450=back
451
452=head2 Questions With Answers
453
454=over 4
455
456=item Will My Old Scripts Break?
457
458Very probably not. Unless you are generating Unicode characters
459somehow, any old behaviour should be preserved. About the only
460behaviour that has changed and which could start generating Unicode
461is the old behaviour of C<chr()> where supplying an argument more
462than 255 produced a character modulo 255 (for example, C<chr(300)>
463was equal to C<chr(45)>).
464
465=item How Do I Make My Scripts Work With Unicode?
466
467Very little work should be needed since nothing changes until you
468somehow generate Unicode data. The greatest trick will be getting
469input as Unicode, and for that see the earlier I/O discussion.
470
471=item How Do I Know Whether My String Is In Unicode?
472
473You shouldn't care. No, you really shouldn't. If you have
474to care (beyond the cases described above), it means that we
475didn't get the transparency of Unicode quite right.
476
477Okay, if you insist:
478
479 use Encode 'is_utf8';
480 print is_utf8($string) ? 1 : 0, "\n";
481
482But note that this doesn't mean that any of the characters in the
483string are necessary UTF-8 encoded, or that any of the characters have
484code points greater than 0xFF (255) or even 0x80 (128), or that the
485string has any characters at all. All the C<is_utf8()> does is to
486return the value of the internal "utf8ness" flag attached to the
487$string. If the flag is on, characters added to that string will be
488automatically upgraded to UTF-8 (and even then only if they really
489need to be upgraded, that is, if their code point is greater than 0xFF).
490
491Sometimes you might really need to know the byte length of a string
492instead of the character length. For that use the C<bytes> pragma
493and its only defined function C<length()>:
494
495 my $unicode = chr(0x100);
496 print length($unicode), "\n"; # will print 1
497 use bytes;
498 print length($unicode), "\n"; # will print 2 (the 0xC4 0x80 of the UTF-8)
499
500=item How Do I Detect Invalid UTF-8?
501
502Either
503
504 use Encode 'encode_utf8';
505 if (encode_utf8($string)) {
506 # valid
507 } else {
508 # invalid
509 }
510
511or
512
513 use warnings;
514 @chars = unpack("U0U*", "\xFF"); # will warn
515
516The warning will be C<Malformed UTF-8 character (byte 0xff) in
517unpack>. The "U0" means "expect strictly UTF-8 encoded Unicode".
518Without that the C<unpack("U*", ...)> would accept also data like
519C<chr(0xFF>).
520
521=item How Do I Convert Data Into UTF-8? Or Vice Versa?
522
523This probably isn't as useful (or simple) as you might think.
524Also, normally you shouldn't need to.
525
526In one sense what you are asking doesn't make much sense: UTF-8 is
527(intended as an) Unicode encoding, so converting "data" into UTF-8
528isn't meaningful unless you know in what character set and encoding
529the binary data is in, and in this case you can use C<Encode>.
530
531 use Encode 'from_to';
532 from_to($data, "iso-8859-1", "utf-8"); # from latin-1 to utf-8
533
534If you have ASCII (really 7-bit US-ASCII), you already have valid
535UTF-8, the lowest 128 characters of UTF-8 encoded Unicode and US-ASCII
536are equivalent.
537
538If you have Latin-1 (or want Latin-1), you can just use pack/unpack:
539
540 $latin1 = pack("C*", unpack("U*", $utf8));
541 $utf8 = pack("U*", unpack("C*", $latin1));
542
543(The same works for EBCDIC.)
544
545If you have a sequence of bytes you B<know> is valid UTF-8,
546but Perl doesn't know it yet, you can make Perl a believer, too:
547
548 use Encode 'decode_utf8';
549 $utf8 = decode_utf8($bytes);
550
551You can convert well-formed UTF-8 to a sequence of bytes, but if
552you just want to convert random binary data into UTF-8, you can't.
553Any random collection of bytes isn't well-formed UTF-8. You can
554use C<unpack("C*", $string)> for the former, and you can create
555well-formed Unicode/UTF-8 data by C<pack("U*", 0xff, ...)>.
556
557=item How Do I Display Unicode? How Do I Input Unicode?
558
559See http://www.hclrss.demon.co.uk/unicode/ and
560http://www.cl.cam.ac.uk/~mgk25/unicode.html
561
562=item How Does Unicode Work With Traditional Locales?
563
564In Perl, not very well. Avoid using locales through the C<locale>
565pragma. Use only one or the other.
566
567=back
568
569=head2 Hexadecimal Notation
570
571The Unicode standard prefers using hexadecimal notation because that
572shows better the division of Unicode into blocks of 256 characters.
573Hexadecimal is also simply shorter than decimal. You can use decimal
574notation, too, but learning to use hexadecimal just makes life easier
575with the Unicode standard.
576
577The C<0x> prefix means a hexadecimal number, the digits are 0-9 I<and>
578a-f (or A-F, case doesn't matter). Each hexadecimal digit represents
579four bits, or half a byte. C<print 0x..., "\n"> will show a
580hexadecimal number in decimal, and C<printf "%x\n", $decimal> will
581show a decimal number in hexadecimal. If you have just the
582"hexdigits" of a hexadecimal number, you can use the C<hex()>
583function.
584
585 print 0x0009, "\n"; # 9
586 print 0x000a, "\n"; # 10
587 print 0x000f, "\n"; # 15
588 print 0x0010, "\n"; # 16
589 print 0x0011, "\n"; # 17
590 print 0x0100, "\n"; # 256
591
592 print 0x0041, "\n"; # 65
593
594 printf "%x\n", 65; # 41
595 printf "%#x\n", 65; # 0x41
596
597 print hex("41"), "\n"; # 65
598
599=head2 Further Resources
600
601=over 4
602
603=item *
604
605Unicode Consortium
606
607 http://www.unicode.org/
608
609=item *
610
611Unicode FAQ
612
613 http://www.unicode.org/unicode/faq/
614
615=item *
616
617Unicode Glossary
618
619 http://www.unicode.org/glossary/
620
621=item *
622
623Unicode Useful Resources
624
625 http://www.unicode.org/unicode/onlinedat/resources.html
626
627=item *
628
629Unicode and Multilingual Support in HTML, Fonts, Web Browsers and Other Applications
630
631 http://www.hclrss.demon.co.uk/unicode/
632
633=item *
634
635UTF-8 and Unicode FAQ for Unix/Linux
636
637 http://www.cl.cam.ac.uk/~mgk25/unicode.html
638
639=item *
640
641Legacy Character Sets
642
643 http://www.czyborra.com/
644 http://www.eki.ee/letter/
645
646=item *
647
648The Unicode support files live within the Perl installation in the
649directory
650
651 $Config{installprivlib}/unicore
652
653in Perl 5.8.0 or newer, and
654
655 $Config{installprivlib}/unicode
656
657in the Perl 5.6 series. (The renaming to F<lib/unicore> was done to
658avoid naming conflicts with lib/Unicode in case-insensitive filesystems.)
659The main Unicode data file is F<Unicode.txt> (or F<Unicode.301> in
660Perl 5.6.1.) You can find the C<$Config{installprivlib}> by
661
662 perl "-V:installprivlib"
663
664Note that some of the files have been renamed from the Unicode
665standard since the Perl installation tries to live by the "8.3"
666filenaming restrictions. The renamings are shown in the
667accompanying F<rename> file.
668
669You can explore various information from the Unicode data files using
670the C<Unicode::UCD> module.
671
672=back
673
674=head1 SEE ALSO
675
676L<perlunicode>, L<Encode>, L<encoding>, L<open>, L<utf8>, L<bytes>,
677L<perlretut>, L<Unicode::Collate>, L<Unicode::Normalize>, L<Unicode::UCD>
678
679=head1 ACKNOWLEDGEMENTS
680
681Thanks to the kind readers of the perl5-porters@perl.org,
682perl-unicode@perl.org, linux-utf8@nl.linux.org, and unicore@unicode.org
683mailing lists for their valuable feedback.
684
685=head1 AUTHOR, COPYRIGHT, AND LICENSE
686
687Copyright 2001 Jarkko Hietaniemi <jhi@iki.fi>
688
689This document may be distributed under the same terms as Perl itself.