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