This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
remove incorrect documentation about implicit split to @_ in
[perl5.git] / pod / perllocale.pod
CommitLineData
5f05dabc
PP
1=head1 NAME
2
b0c42ed9 3perllocale - Perl locale handling (internationalization and localization)
5f05dabc
PP
4
5=head1 DESCRIPTION
6
5a964f20
TC
7Perl supports language-specific notions of data such as "is this
8a letter", "what is the uppercase equivalent of this letter", and
9"which of these letters comes first". These are important issues,
10especially for languages other than English--but also for English: it
11would be naE<iuml>ve to imagine that C<A-Za-z> defines all the "letters"
12needed to write in English. Perl is also aware that some character other
13than '.' may be preferred as a decimal point, and that output date
14representations may be language-specific. The process of making an
15application take account of its users' preferences in such matters is
16called B<internationalization> (often abbreviated as B<i18n>); telling
17such an application about a particular set of preferences is known as
18B<localization> (B<l10n>).
14280422
DD
19
20Perl can understand language-specific data via the standardized (ISO C,
21XPG4, POSIX 1.c) method called "the locale system". The locale system is
b0c42ed9 22controlled per application using one pragma, one function call, and
14280422
DD
23several environment variables.
24
25B<NOTE>: This feature is new in Perl 5.004, and does not apply unless an
5a964f20 26application specifically requests it--see L<Backward compatibility>.
e38874e2
DD
27The one exception is that write() now B<always> uses the current locale
28- see L<"NOTES">.
5f05dabc
PP
29
30=head1 PREPARING TO USE LOCALES
31
5a964f20 32If Perl applications are to understand and present your data
14280422 33correctly according a locale of your choice, B<all> of the following
5f05dabc
PP
34must be true:
35
36=over 4
37
38=item *
39
40B<Your operating system must support the locale system>. If it does,
14280422 41you should find that the setlocale() function is a documented part of
5f05dabc
PP
42its C library.
43
44=item *
45
5a964f20 46B<Definitions for locales that you use must be installed>. You, or
14280422
DD
47your system administrator, must make sure that this is the case. The
48available locales, the location in which they are kept, and the manner
5a964f20
TC
49in which they are installed all vary from system to system. Some systems
50provide only a few, hard-wired locales and do not allow more to be
51added. Others allow you to add "canned" locales provided by the system
52supplier. Still others allow you or the system administrator to define
14280422 53and add arbitrary locales. (You may have to ask your supplier to
5a964f20 54provide canned locales that are not delivered with your operating
14280422 55system.) Read your system documentation for further illumination.
5f05dabc
PP
56
57=item *
58
59B<Perl must believe that the locale system is supported>. If it does,
60C<perl -V:d_setlocale> will say that the value for C<d_setlocale> is
61C<define>.
62
63=back
64
65If you want a Perl application to process and present your data
66according to a particular locale, the application code should include
2ae324a7 67the S<C<use locale>> pragma (see L<The use locale pragma>) where
5f05dabc
PP
68appropriate, and B<at least one> of the following must be true:
69
70=over 4
71
72=item *
73
14280422 74B<The locale-determining environment variables (see L<"ENVIRONMENT">)
5a964f20
TC
75must be correctly set up> at the time the application is started, either
76by yourself or by whoever set up your system account.
5f05dabc
PP
77
78=item *
79
14280422
DD
80B<The application must set its own locale> using the method described in
81L<The setlocale function>.
5f05dabc
PP
82
83=back
84
85=head1 USING LOCALES
86
87=head2 The use locale pragma
88
14280422
DD
89By default, Perl ignores the current locale. The S<C<use locale>>
90pragma tells Perl to use the current locale for some operations:
5f05dabc
PP
91
92=over 4
93
94=item *
95
14280422
DD
96B<The comparison operators> (C<lt>, C<le>, C<cmp>, C<ge>, and C<gt>) and
97the POSIX string collation functions strcoll() and strxfrm() use
5a964f20
TC
98C<LC_COLLATE>. sort() is also affected if used without an
99explicit comparison function, because it uses C<cmp> by default.
14280422 100
5a964f20 101B<Note:> C<eq> and C<ne> are unaffected by locale: they always
14280422
DD
102perform a byte-by-byte comparison of their scalar operands. What's
103more, if C<cmp> finds that its operands are equal according to the
104collation sequence specified by the current locale, it goes on to
105perform a byte-by-byte comparison, and only returns I<0> (equal) if the
106operands are bit-for-bit identical. If you really want to know whether
5a964f20 107two strings--which C<eq> and C<cmp> may consider different--are equal
14280422
DD
108as far as collation in the locale is concerned, see the discussion in
109L<Category LC_COLLATE: Collation>.
5f05dabc
PP
110
111=item *
112
14280422
DD
113B<Regular expressions and case-modification functions> (uc(), lc(),
114ucfirst(), and lcfirst()) use C<LC_CTYPE>
5f05dabc
PP
115
116=item *
117
14280422 118B<The formatting functions> (printf(), sprintf() and write()) use
5f05dabc
PP
119C<LC_NUMERIC>
120
121=item *
122
14280422 123B<The POSIX date formatting function> (strftime()) uses C<LC_TIME>.
5f05dabc
PP
124
125=back
126
14280422
DD
127C<LC_COLLATE>, C<LC_CTYPE>, and so on, are discussed further in L<LOCALE
128CATEGORIES>.
5f05dabc 129
5a964f20
TC
130The default behavior is restored with the S<C<no locale>> pragma, or
131upon reaching the end of block enclosing C<use locale>.
5f05dabc 132
5a964f20 133The string result of any operation that uses locale
14280422
DD
134information is tainted, as it is possible for a locale to be
135untrustworthy. See L<"SECURITY">.
5f05dabc
PP
136
137=head2 The setlocale function
138
14280422
DD
139You can switch locales as often as you wish at run time with the
140POSIX::setlocale() function:
5f05dabc
PP
141
142 # This functionality not usable prior to Perl 5.004
143 require 5.004;
144
145 # Import locale-handling tool set from POSIX module.
146 # This example uses: setlocale -- the function call
147 # LC_CTYPE -- explained below
148 use POSIX qw(locale_h);
149
14280422 150 # query and save the old locale
5f05dabc
PP
151 $old_locale = setlocale(LC_CTYPE);
152
153 setlocale(LC_CTYPE, "fr_CA.ISO8859-1");
154 # LC_CTYPE now in locale "French, Canada, codeset ISO 8859-1"
155
156 setlocale(LC_CTYPE, "");
157 # LC_CTYPE now reset to default defined by LC_ALL/LC_CTYPE/LANG
158 # environment variables. See below for documentation.
159
160 # restore the old locale
161 setlocale(LC_CTYPE, $old_locale);
162
14280422
DD
163The first argument of setlocale() gives the B<category>, the second the
164B<locale>. The category tells in what aspect of data processing you
165want to apply locale-specific rules. Category names are discussed in
166L<LOCALE CATEGORIES> and L<"ENVIRONMENT">. The locale is the name of a
167collection of customization information corresponding to a particular
168combination of language, country or territory, and codeset. Read on for
169hints on the naming of locales: not all systems name locales as in the
170example.
171
502a173a
JH
172If no second argument is provided and the category is something else
173than LC_ALL, the function returns a string naming the current locale
174for the category. You can use this value as the second argument in a
175subsequent call to setlocale().
176
177If no second argument is provided and the category is LC_ALL, the
178result is implementation-dependent. It may be a string of
179concatenated locales names (separator also implementation-dependent)
180or a single locale name. Please consult your L<setlocale(3)> for
181details.
182
183If a second argument is given and it corresponds to a valid locale,
184the locale for the category is set to that value, and the function
185returns the now-current locale value. You can then use this in yet
186another call to setlocale(). (In some implementations, the return
187value may sometimes differ from the value you gave as the second
188argument--think of it as an alias for the value you gave.)
5f05dabc
PP
189
190As the example shows, if the second argument is an empty string, the
191category's locale is returned to the default specified by the
192corresponding environment variables. Generally, this results in a
5a964f20 193return to the default that was in force when Perl started up: changes
54310121 194to the environment made by the application after startup may or may not
5a964f20 195be noticed, depending on your system's C library.
5f05dabc 196
14280422
DD
197If the second argument does not correspond to a valid locale, the locale
198for the category is not changed, and the function returns I<undef>.
5f05dabc 199
14280422 200For further information about the categories, consult L<setlocale(3)>.
3e6e419a
JH
201
202=head2 Finding locales
203
5a964f20
TC
204For locales available in your system, consult also L<setlocale(3)> to
205see whether it leads to the list of available locales (search for the
206I<SEE ALSO> section). If that fails, try the following command lines:
5f05dabc
PP
207
208 locale -a
209
210 nlsinfo
211
212 ls /usr/lib/nls/loc
213
214 ls /usr/lib/locale
215
216 ls /usr/lib/nls
217
b478f28d
JH
218 ls /usr/share/locale
219
5f05dabc
PP
220and see whether they list something resembling these
221
2bdf8add 222 en_US.ISO8859-1 de_DE.ISO8859-1 ru_RU.ISO8859-5
502a173a 223 en_US.iso88591 de_DE.iso88591 ru_RU.iso88595
2bdf8add 224 en_US de_DE ru_RU
14280422 225 en de ru
2bdf8add
JH
226 english german russian
227 english.iso88591 german.iso88591 russian.iso88595
502a173a 228 english.roman8 russian.koi8r
5f05dabc 229
528d65ad
JH
230Sadly, even though the calling interface for setlocale() has been
231standardized, names of locales and the directories where the
5a964f20 232configuration resides have not been. The basic form of the name is
528d65ad
JH
233I<language_territory>B<.>I<codeset>, but the latter parts after
234I<language> are not always present. The I<language> and I<country>
235are usually from the standards B<ISO 3166> and B<ISO 639>, the
236two-letter abbreviations for the countries and the languages of the
237world, respectively. The I<codeset> part often mentions some B<ISO
2388859> character set, the Latin codesets. For example, C<ISO 8859-1>
239is the so-called "Western European codeset" that can be used to encode
240most Western European languages adequately. Again, there are several
241ways to write even the name of that one standard. Lamentably.
5f05dabc 242
14280422
DD
243Two special locales are worth particular mention: "C" and "POSIX".
244Currently these are effectively the same locale: the difference is
5a964f20
TC
245mainly that the first one is defined by the C standard, the second by
246the POSIX standard. They define the B<default locale> in which
14280422 247every program starts in the absence of locale information in its
5a964f20 248environment. (The I<default> default locale, if you will.) Its language
14280422 249is (American) English and its character codeset ASCII.
5f05dabc 250
14280422
DD
251B<NOTE>: Not all systems have the "POSIX" locale (not all systems are
252POSIX-conformant), so use "C" when you need explicitly to specify this
253default locale.
5f05dabc 254
3e6e419a
JH
255=head2 LOCALE PROBLEMS
256
5a964f20 257You may encounter the following warning message at Perl startup:
3e6e419a
JH
258
259 perl: warning: Setting locale failed.
260 perl: warning: Please check that your locale settings:
261 LC_ALL = "En_US",
262 LANG = (unset)
263 are supported and installed on your system.
264 perl: warning: Falling back to the standard locale ("C").
265
5a964f20
TC
266This means that your locale settings had LC_ALL set to "En_US" and
267LANG exists but has no value. Perl tried to believe you but could not.
268Instead, Perl gave up and fell back to the "C" locale, the default locale
269that is supposed to work no matter what. This usually means your locale
270settings were wrong, they mention locales your system has never heard
271of, or the locale installation in your system has problems (for example,
272some system files are broken or missing). There are quick and temporary
273fixes to these problems, as well as more thorough and lasting fixes.
3e6e419a
JH
274
275=head2 Temporarily fixing locale problems
276
5a964f20 277The two quickest fixes are either to render Perl silent about any
3e6e419a
JH
278locale inconsistencies or to run Perl under the default locale "C".
279
280Perl's moaning about locale problems can be silenced by setting the
900bd440
JH
281environment variable PERL_BADLANG to a zero value, for example "0".
282This method really just sweeps the problem under the carpet: you tell
283Perl to shut up even when Perl sees that something is wrong. Do not
284be surprised if later something locale-dependent misbehaves.
3e6e419a
JH
285
286Perl can be run under the "C" locale by setting the environment
5a964f20
TC
287variable LC_ALL to "C". This method is perhaps a bit more civilized
288than the PERL_BADLANG approach, but setting LC_ALL (or
289other locale variables) may affect other programs as well, not just
290Perl. In particular, external programs run from within Perl will see
3e6e419a 291these changes. If you make the new settings permanent (read on), all
106325ad 292programs you run see the changes. See L<ENVIRONMENT> for
5a964f20
TC
293the full list of relevant environment variables and L<USING LOCALES>
294for their effects in Perl. Effects in other programs are
295easily deducible. For example, the variable LC_COLLATE may well affect
296your B<sort> program (or whatever the program that arranges `records'
3e6e419a
JH
297alphabetically in your system is called).
298
5a964f20
TC
299You can test out changing these variables temporarily, and if the
300new settings seem to help, put those settings into your shell startup
301files. Consult your local documentation for the exact details. For in
302Bourne-like shells (B<sh>, B<ksh>, B<bash>, B<zsh>):
3e6e419a
JH
303
304 LC_ALL=en_US.ISO8859-1
305 export LC_ALL
306
5a964f20
TC
307This assumes that we saw the locale "en_US.ISO8859-1" using the commands
308discussed above. We decided to try that instead of the above faulty
309locale "En_US"--and in Cshish shells (B<csh>, B<tcsh>)
3e6e419a
JH
310
311 setenv LC_ALL en_US.ISO8859-1
c47ff5f1 312
5a964f20 313If you do not know what shell you have, consult your local
3e6e419a
JH
314helpdesk or the equivalent.
315
316=head2 Permanently fixing locale problems
317
5a964f20
TC
318The slower but superior fixes are when you may be able to yourself
319fix the misconfiguration of your own environment variables. The
3e6e419a
JH
320mis(sing)configuration of the whole system's locales usually requires
321the help of your friendly system administrator.
322
5a964f20
TC
323First, see earlier in this document about L<Finding locales>. That tells
324how to find which locales are really supported--and more importantly,
325installed--on your system. In our example error message, environment
326variables affecting the locale are listed in the order of decreasing
327importance (and unset variables do not matter). Therefore, having
328LC_ALL set to "En_US" must have been the bad choice, as shown by the
329error message. First try fixing locale settings listed first.
3e6e419a 330
5a964f20
TC
331Second, if using the listed commands you see something B<exactly>
332(prefix matches do not count and case usually counts) like "En_US"
333without the quotes, then you should be okay because you are using a
334locale name that should be installed and available in your system.
4a4eefd0 335In this case, see L<Permanently fixing your system's locale configuration>.
3e6e419a 336
4a4eefd0 337=head2 Permanently fixing your system's locale configuration
3e6e419a 338
5a964f20 339This is when you see something like:
3e6e419a
JH
340
341 perl: warning: Please check that your locale settings:
342 LC_ALL = "En_US",
343 LANG = (unset)
344 are supported and installed on your system.
345
346but then cannot see that "En_US" listed by the above-mentioned
5a964f20
TC
347commands. You may see things like "en_US.ISO8859-1", but that isn't
348the same. In this case, try running under a locale
349that you can list and which somehow matches what you tried. The
3e6e419a 350rules for matching locale names are a bit vague because
5a964f20
TC
351standardization is weak in this area. See again the L<Finding
352locales> about general rules.
3e6e419a 353
b687b08b 354=head2 Fixing system locale configuration
3e6e419a 355
5a964f20
TC
356Contact a system administrator (preferably your own) and report the exact
357error message you get, and ask them to read this same documentation you
358are now reading. They should be able to check whether there is something
359wrong with the locale configuration of the system. The L<Finding locales>
360section is unfortunately a bit vague about the exact commands and places
361because these things are not that standardized.
3e6e419a 362
5f05dabc
PP
363=head2 The localeconv function
364
14280422
DD
365The POSIX::localeconv() function allows you to get particulars of the
366locale-dependent numeric formatting information specified by the current
367C<LC_NUMERIC> and C<LC_MONETARY> locales. (If you just want the name of
368the current locale for a particular category, use POSIX::setlocale()
5a964f20 369with a single parameter--see L<The setlocale function>.)
5f05dabc
PP
370
371 use POSIX qw(locale_h);
5f05dabc
PP
372
373 # Get a reference to a hash of locale-dependent info
374 $locale_values = localeconv();
375
376 # Output sorted list of the values
377 for (sort keys %$locale_values) {
14280422 378 printf "%-20s = %s\n", $_, $locale_values->{$_}
5f05dabc
PP
379 }
380
14280422 381localeconv() takes no arguments, and returns B<a reference to> a hash.
5a964f20 382The keys of this hash are variable names for formatting, such as
502a173a
JH
383C<decimal_point> and C<thousands_sep>. The values are the
384corresponding, er, values. See L<POSIX (3)/localeconv> for a longer
385example listing the categories an implementation might be expected to
386provide; some provide more and others fewer. You don't need an
387explicit C<use locale>, because localeconv() always observes the
388current locale.
5f05dabc 389
5a964f20
TC
390Here's a simple-minded example program that rewrites its command-line
391parameters as integers correctly formatted in the current locale:
5f05dabc
PP
392
393 # See comments in previous example
394 require 5.004;
395 use POSIX qw(locale_h);
5f05dabc
PP
396
397 # Get some of locale's numeric formatting parameters
398 my ($thousands_sep, $grouping) =
14280422 399 @{localeconv()}{'thousands_sep', 'grouping'};
5f05dabc
PP
400
401 # Apply defaults if values are missing
402 $thousands_sep = ',' unless $thousands_sep;
502a173a
JH
403
404 # grouping and mon_grouping are packed lists
405 # of small integers (characters) telling the
406 # grouping (thousand_seps and mon_thousand_seps
407 # being the group dividers) of numbers and
408 # monetary quantities. The integers' meanings:
409 # 255 means no more grouping, 0 means repeat
410 # the previous grouping, 1-254 means use that
411 # as the current grouping. Grouping goes from
412 # right to left (low to high digits). In the
413 # below we cheat slightly by never using anything
414 # else than the first grouping (whatever that is).
415 if ($grouping) {
416 @grouping = unpack("C*", $grouping);
417 } else {
418 @grouping = (3);
419 }
5f05dabc
PP
420
421 # Format command line params for current locale
14280422
DD
422 for (@ARGV) {
423 $_ = int; # Chop non-integer part
5f05dabc 424 1 while
502a173a 425 s/(\d)(\d{$grouping[0]}($|$thousands_sep))/$1$thousands_sep$2/;
14280422 426 print "$_";
5f05dabc
PP
427 }
428 print "\n";
429
5f05dabc
PP
430=head1 LOCALE CATEGORIES
431
5a964f20
TC
432The following subsections describe basic locale categories. Beyond these,
433some combination categories allow manipulation of more than one
434basic category at a time. See L<"ENVIRONMENT"> for a discussion of these.
5f05dabc
PP
435
436=head2 Category LC_COLLATE: Collation
437
5a964f20
TC
438In the scope of S<C<use locale>>, Perl looks to the C<LC_COLLATE>
439environment variable to determine the application's notions on collation
440(ordering) of characters. For example, 'b' follows 'a' in Latin
441alphabets, but where do 'E<aacute>' and 'E<aring>' belong? And while
442'color' follows 'chocolate' in English, what about in Spanish?
5f05dabc 443
60f0fa02
JH
444The following collations all make sense and you may meet any of them
445if you "use locale".
446
447 A B C D E a b c d e
448 A a B b C c D d D e
449 a A b B c C d D e E
450 a b c d e A B C D E
451
5a964f20
TC
452Here is a code snippet to tell what alphanumeric
453characters are in the current locale, in that locale's order:
5f05dabc
PP
454
455 use locale;
456 print +(sort grep /\w/, map { chr() } 0..255), "\n";
457
14280422
DD
458Compare this with the characters that you see and their order if you
459state explicitly that the locale should be ignored:
5f05dabc
PP
460
461 no locale;
462 print +(sort grep /\w/, map { chr() } 0..255), "\n";
463
464This machine-native collation (which is what you get unless S<C<use
465locale>> has appeared earlier in the same block) must be used for
466sorting raw binary data, whereas the locale-dependent collation of the
b0c42ed9 467first example is useful for natural text.
5f05dabc 468
14280422
DD
469As noted in L<USING LOCALES>, C<cmp> compares according to the current
470collation locale when C<use locale> is in effect, but falls back to a
5a964f20 471byte-by-byte comparison for strings that the locale says are equal. You
14280422
DD
472can use POSIX::strcoll() if you don't want this fall-back:
473
474 use POSIX qw(strcoll);
475 $equal_in_locale =
476 !strcoll("space and case ignored", "SpaceAndCaseIgnored");
477
478$equal_in_locale will be true if the collation locale specifies a
5a964f20 479dictionary-like ordering that ignores space characters completely and
9e3a2af8 480which folds case.
14280422 481
5a964f20 482If you have a single string that you want to check for "equality in
14280422
DD
483locale" against several others, you might think you could gain a little
484efficiency by using POSIX::strxfrm() in conjunction with C<eq>:
485
486 use POSIX qw(strxfrm);
487 $xfrm_string = strxfrm("Mixed-case string");
488 print "locale collation ignores spaces\n"
489 if $xfrm_string eq strxfrm("Mixed-casestring");
490 print "locale collation ignores hyphens\n"
491 if $xfrm_string eq strxfrm("Mixedcase string");
492 print "locale collation ignores case\n"
493 if $xfrm_string eq strxfrm("mixed-case string");
494
495strxfrm() takes a string and maps it into a transformed string for use
496in byte-by-byte comparisons against other transformed strings during
497collation. "Under the hood", locale-affected Perl comparison operators
5a964f20
TC
498call strxfrm() for both operands, then do a byte-by-byte
499comparison of the transformed strings. By calling strxfrm() explicitly
14280422 500and using a non locale-affected comparison, the example attempts to save
5a964f20 501a couple of transformations. But in fact, it doesn't save anything: Perl
2ae324a7 502magic (see L<perlguts/Magic Variables>) creates the transformed version of a
5a964f20 503string the first time it's needed in a comparison, then keeps this version around
14280422 504in case it's needed again. An example rewritten the easy way with
e38874e2 505C<cmp> runs just about as fast. It also copes with null characters
14280422 506embedded in strings; if you call strxfrm() directly, it treats the first
5a964f20
TC
507null it finds as a terminator. don't expect the transformed strings
508it produces to be portable across systems--or even from one revision
e38874e2
DD
509of your operating system to the next. In short, don't call strxfrm()
510directly: let Perl do it for you.
14280422 511
5a964f20 512Note: C<use locale> isn't shown in some of these examples because it isn't
14280422
DD
513needed: strcoll() and strxfrm() exist only to generate locale-dependent
514results, and so always obey the current C<LC_COLLATE> locale.
5f05dabc
PP
515
516=head2 Category LC_CTYPE: Character Types
517
5a964f20 518In the scope of S<C<use locale>>, Perl obeys the C<LC_CTYPE> locale
14280422
DD
519setting. This controls the application's notion of which characters are
520alphabetic. This affects Perl's C<\w> regular expression metanotation,
5a964f20 521which stands for alphanumeric characters--that is, alphabetic and
14280422
DD
522numeric characters. (Consult L<perlre> for more information about
523regular expressions.) Thanks to C<LC_CTYPE>, depending on your locale
524setting, characters like 'E<aelig>', 'E<eth>', 'E<szlig>', and
525'E<oslash>' may be understood as C<\w> characters.
5f05dabc 526
2c268ad5 527The C<LC_CTYPE> locale also provides the map used in transliterating
68dc0745 528characters between lower and uppercase. This affects the case-mapping
5a964f20
TC
529functions--lc(), lcfirst, uc(), and ucfirst(); case-mapping
530interpolation with C<\l>, C<\L>, C<\u>, or C<\U> in double-quoted strings
531and C<s///> substitutions; and case-independent regular expression
e38874e2
DD
532pattern matching using the C<i> modifier.
533
5a964f20
TC
534Finally, C<LC_CTYPE> affects the POSIX character-class test
535functions--isalpha(), islower(), and so on. For example, if you move
536from the "C" locale to a 7-bit Scandinavian one, you may find--possibly
537to your surprise--that "|" moves from the ispunct() class to isalpha().
5f05dabc 538
14280422
DD
539B<Note:> A broken or malicious C<LC_CTYPE> locale definition may result
540in clearly ineligible characters being considered to be alphanumeric by
5a964f20
TC
541your application. For strict matching of (mundane) letters and
542digits--for example, in command strings--locale-aware applications
14280422 543should use C<\w> inside a C<no locale> block. See L<"SECURITY">.
5f05dabc
PP
544
545=head2 Category LC_NUMERIC: Numeric Formatting
546
5a964f20
TC
547In the scope of S<C<use locale>>, Perl obeys the C<LC_NUMERIC> locale
548information, which controls an application's idea of how numbers should
549be formatted for human readability by the printf(), sprintf(), and
550write() functions. String-to-numeric conversion by the POSIX::strtod()
551function is also affected. In most implementations the only effect is to
552change the character used for the decimal point--perhaps from '.' to ','.
553These functions aren't aware of such niceties as thousands separation and
554so on. (See L<The localeconv function> if you care about these things.)
555
556Output produced by print() is B<never> affected by the
5f05dabc 557current locale: it is independent of whether C<use locale> or C<no
14280422 558locale> is in effect, and corresponds to what you'd get from printf()
5f05dabc
PP
559in the "C" locale. The same is true for Perl's internal conversions
560between numeric and string formats:
561
562 use POSIX qw(strtod);
563 use locale;
14280422 564
5f05dabc
PP
565 $n = 5/2; # Assign numeric 2.5 to $n
566
567 $a = " $n"; # Locale-independent conversion to string
568
569 print "half five is $n\n"; # Locale-independent output
570
571 printf "half five is %g\n", $n; # Locale-dependent output
572
14280422
DD
573 print "DECIMAL POINT IS COMMA\n"
574 if $n == (strtod("2,5"))[0]; # Locale-dependent conversion
5f05dabc
PP
575
576=head2 Category LC_MONETARY: Formatting of monetary amounts
577
5a964f20
TC
578The C standard defines the C<LC_MONETARY> category, but no function
579that is affected by its contents. (Those with experience of standards
b0c42ed9 580committees will recognize that the working group decided to punt on the
14280422 581issue.) Consequently, Perl takes no notice of it. If you really want
5a964f20
TC
582to use C<LC_MONETARY>, you can query its contents--see L<The localeconv
583function>--and use the information that it returns in your application's
584own formatting of currency amounts. However, you may well find that
585the information, voluminous and complex though it may be, still does not
586quite meet your requirements: currency formatting is a hard nut to crack.
5f05dabc
PP
587
588=head2 LC_TIME
589
5a964f20 590Output produced by POSIX::strftime(), which builds a formatted
5f05dabc
PP
591human-readable date/time string, is affected by the current C<LC_TIME>
592locale. Thus, in a French locale, the output produced by the C<%B>
593format element (full month name) for the first month of the year would
5a964f20 594be "janvier". Here's how to get a list of long month names in the
5f05dabc
PP
595current locale:
596
597 use POSIX qw(strftime);
14280422
DD
598 for (0..11) {
599 $long_month_name[$_] =
600 strftime("%B", 0, 0, 0, 1, $_, 96);
5f05dabc
PP
601 }
602
5a964f20 603Note: C<use locale> isn't needed in this example: as a function that
14280422
DD
604exists only to generate locale-dependent results, strftime() always
605obeys the current C<LC_TIME> locale.
5f05dabc
PP
606
607=head2 Other categories
608
5a964f20
TC
609The remaining locale category, C<LC_MESSAGES> (possibly supplemented
610by others in particular implementations) is not currently used by
98a6f11e 611Perl--except possibly to affect the behavior of library functions
612called by extensions outside the standard Perl distribution and by the
613operating system and its utilities. Note especially that the string
614value of C<$!> and the error messages given by external utilities may
615be changed by C<LC_MESSAGES>. If you want to have portable error
265f5c4a 616codes, use C<%!>. See L<Errno>.
14280422
DD
617
618=head1 SECURITY
619
5a964f20 620Although the main discussion of Perl security issues can be found in
14280422
DD
621L<perlsec>, a discussion of Perl's locale handling would be incomplete
622if it did not draw your attention to locale-dependent security issues.
5a964f20
TC
623Locales--particularly on systems that allow unprivileged users to
624build their own locales--are untrustworthy. A malicious (or just plain
14280422
DD
625broken) locale can make a locale-aware application give unexpected
626results. Here are a few possibilities:
627
628=over 4
629
630=item *
631
632Regular expression checks for safe file names or mail addresses using
5a964f20 633C<\w> may be spoofed by an C<LC_CTYPE> locale that claims that
14280422
DD
634characters such as "E<gt>" and "|" are alphanumeric.
635
636=item *
637
e38874e2
DD
638String interpolation with case-mapping, as in, say, C<$dest =
639"C:\U$name.$ext">, may produce dangerous results if a bogus LC_CTYPE
640case-mapping table is in effect.
641
642=item *
643
eb1050c4
GS
644Some systems are broken in that they allow the "C" locale to be
645overridden by users. If the decimal point character in the
646C<LC_NUMERIC> category of the "C" locale is surreptitiously changed
647from a dot to a comma, C<sprintf("%g", 0.123456e3)> produces a
648string result of "123,456". Many people would interpret this as
649one hundred and twenty-three thousand, four hundred and fifty-six.
14280422
DD
650
651=item *
652
653A sneaky C<LC_COLLATE> locale could result in the names of students with
654"D" grades appearing ahead of those with "A"s.
655
656=item *
657
5a964f20 658An application that takes the trouble to use information in
14280422 659C<LC_MONETARY> may format debits as if they were credits and vice versa
5a964f20 660if that locale has been subverted. Or it might make payments in US
14280422
DD
661dollars instead of Hong Kong dollars.
662
663=item *
664
665The date and day names in dates formatted by strftime() could be
666manipulated to advantage by a malicious user able to subvert the
5a964f20 667C<LC_DATE> locale. ("Look--it says I wasn't in the building on
14280422
DD
668Sunday.")
669
670=back
671
672Such dangers are not peculiar to the locale system: any aspect of an
5a964f20 673application's environment which may be modified maliciously presents
14280422 674similar challenges. Similarly, they are not specific to Perl: any
5a964f20 675programming language that allows you to write programs that take
14280422
DD
676account of their environment exposes you to these issues.
677
5a964f20
TC
678Perl cannot protect you from all possibilities shown in the
679examples--there is no substitute for your own vigilance--but, when
14280422 680C<use locale> is in effect, Perl uses the tainting mechanism (see
5a964f20 681L<perlsec>) to mark string results that become locale-dependent, and
14280422 682which may be untrustworthy in consequence. Here is a summary of the
5a964f20 683tainting behavior of operators and functions that may be affected by
14280422
DD
684the locale:
685
686=over 4
687
688=item B<Comparison operators> (C<lt>, C<le>, C<ge>, C<gt> and C<cmp>):
689
690Scalar true/false (or less/equal/greater) result is never tainted.
691
7b8d334a 692=item B<Case-mapping interpolation> (with C<\l>, C<\L>, C<\u> or C<\U>)
e38874e2
DD
693
694Result string containing interpolated material is tainted if
695C<use locale> is in effect.
696
14280422
DD
697=item B<Matching operator> (C<m//>):
698
699Scalar true/false result never tainted.
700
5a964f20 701Subpatterns, either delivered as a list-context result or as $1 etc.
14280422 702are tainted if C<use locale> is in effect, and the subpattern regular
e38874e2
DD
703expression contains C<\w> (to match an alphanumeric character), C<\W>
704(non-alphanumeric character), C<\s> (white-space character), or C<\S>
5a964f20 705(non white-space character). The matched-pattern variable, $&, $`
e38874e2
DD
706(pre-match), $' (post-match), and $+ (last match) are also tainted if
707C<use locale> is in effect and the regular expression contains C<\w>,
708C<\W>, C<\s>, or C<\S>.
14280422
DD
709
710=item B<Substitution operator> (C<s///>):
711
e38874e2 712Has the same behavior as the match operator. Also, the left
5a964f20
TC
713operand of C<=~> becomes tainted when C<use locale> in effect
714if modified as a result of a substitution based on a regular
e38874e2 715expression match involving C<\w>, C<\W>, C<\s>, or C<\S>; or of
7b8d334a 716case-mapping with C<\l>, C<\L>,C<\u> or C<\U>.
14280422 717
14280422
DD
718=item B<Output formatting functions> (printf() and write()):
719
720Success/failure result is never tainted.
721
722=item B<Case-mapping functions> (lc(), lcfirst(), uc(), ucfirst()):
723
724Results are tainted if C<use locale> is in effect.
725
726=item B<POSIX locale-dependent functions> (localeconv(), strcoll(),
727strftime(), strxfrm()):
728
729Results are never tainted.
730
731=item B<POSIX character class tests> (isalnum(), isalpha(), isdigit(),
732isgraph(), islower(), isprint(), ispunct(), isspace(), isupper(),
733isxdigit()):
734
735True/false results are never tainted.
736
737=back
738
739Three examples illustrate locale-dependent tainting.
740The first program, which ignores its locale, won't run: a value taken
54310121 741directly from the command line may not be used to name an output file
14280422
DD
742when taint checks are enabled.
743
744 #/usr/local/bin/perl -T
745 # Run with taint checking
746
54310121 747 # Command line sanity check omitted...
14280422
DD
748 $tainted_output_file = shift;
749
750 open(F, ">$tainted_output_file")
751 or warn "Open of $untainted_output_file failed: $!\n";
752
753The program can be made to run by "laundering" the tainted value through
5a964f20
TC
754a regular expression: the second example--which still ignores locale
755information--runs, creating the file named on its command line
14280422
DD
756if it can.
757
758 #/usr/local/bin/perl -T
759
760 $tainted_output_file = shift;
761 $tainted_output_file =~ m%[\w/]+%;
762 $untainted_output_file = $&;
763
764 open(F, ">$untainted_output_file")
765 or warn "Open of $untainted_output_file failed: $!\n";
766
5a964f20 767Compare this with a similar but locale-aware program:
14280422
DD
768
769 #/usr/local/bin/perl -T
770
771 $tainted_output_file = shift;
772 use locale;
773 $tainted_output_file =~ m%[\w/]+%;
774 $localized_output_file = $&;
775
776 open(F, ">$localized_output_file")
777 or warn "Open of $localized_output_file failed: $!\n";
778
779This third program fails to run because $& is tainted: it is the result
5a964f20 780of a match involving C<\w> while C<use locale> is in effect.
5f05dabc
PP
781
782=head1 ENVIRONMENT
783
784=over 12
785
786=item PERL_BADLANG
787
14280422 788A string that can suppress Perl's warning about failed locale settings
54310121 789at startup. Failure can occur if the locale support in the operating
5a964f20 790system is lacking (broken) in some way--or if you mistyped the name of
900bd440
JH
791a locale when you set up your environment. If this environment
792variable is absent, or has a value that does not evaluate to integer
793zero--that is, "0" or ""-- Perl will complain about locale setting
794failures.
5f05dabc 795
14280422
DD
796B<NOTE>: PERL_BADLANG only gives you a way to hide the warning message.
797The message tells about some problem in your system's locale support,
798and you should investigate what the problem is.
5f05dabc
PP
799
800=back
801
802The following environment variables are not specific to Perl: They are
14280422
DD
803part of the standardized (ISO C, XPG4, POSIX 1.c) setlocale() method
804for controlling an application's opinion on data.
5f05dabc
PP
805
806=over 12
807
808=item LC_ALL
809
5a964f20 810C<LC_ALL> is the "override-all" locale environment variable. If
5f05dabc
PP
811set, it overrides all the rest of the locale environment variables.
812
528d65ad
JH
813=item LANGUAGE
814
815B<NOTE>: C<LANGUAGE> is a GNU extension, it affects you only if you
816are using the GNU libc. This is the case if you are using e.g. Linux.
817If you are using "commercial" UNIXes you are most probably I<not>
22b6f60d
JH
818using GNU libc and you can ignore C<LANGUAGE>.
819
820However, in the case you are using C<LANGUAGE>: it affects the
821language of informational, warning, and error messages output by
822commands (in other words, it's like C<LC_MESSAGES>) but it has higher
823priority than L<LC_ALL>. Moreover, it's not a single value but
824instead a "path" (":"-separated list) of I<languages> (not locales).
825See the GNU C<gettext> library documentation for more information.
528d65ad 826
5f05dabc
PP
827=item LC_CTYPE
828
829In the absence of C<LC_ALL>, C<LC_CTYPE> chooses the character type
830locale. In the absence of both C<LC_ALL> and C<LC_CTYPE>, C<LANG>
831chooses the character type locale.
832
833=item LC_COLLATE
834
14280422
DD
835In the absence of C<LC_ALL>, C<LC_COLLATE> chooses the collation
836(sorting) locale. In the absence of both C<LC_ALL> and C<LC_COLLATE>,
837C<LANG> chooses the collation locale.
5f05dabc
PP
838
839=item LC_MONETARY
840
14280422
DD
841In the absence of C<LC_ALL>, C<LC_MONETARY> chooses the monetary
842formatting locale. In the absence of both C<LC_ALL> and C<LC_MONETARY>,
843C<LANG> chooses the monetary formatting locale.
5f05dabc
PP
844
845=item LC_NUMERIC
846
847In the absence of C<LC_ALL>, C<LC_NUMERIC> chooses the numeric format
848locale. In the absence of both C<LC_ALL> and C<LC_NUMERIC>, C<LANG>
849chooses the numeric format.
850
851=item LC_TIME
852
14280422
DD
853In the absence of C<LC_ALL>, C<LC_TIME> chooses the date and time
854formatting locale. In the absence of both C<LC_ALL> and C<LC_TIME>,
855C<LANG> chooses the date and time formatting locale.
5f05dabc
PP
856
857=item LANG
858
14280422
DD
859C<LANG> is the "catch-all" locale environment variable. If it is set, it
860is used as the last resort after the overall C<LC_ALL> and the
5f05dabc
PP
861category-specific C<LC_...>.
862
863=back
864
865=head1 NOTES
866
867=head2 Backward compatibility
868
b0c42ed9 869Versions of Perl prior to 5.004 B<mostly> ignored locale information,
5a964f20
TC
870generally behaving as if something similar to the C<"C"> locale were
871always in force, even if the program environment suggested otherwise
872(see L<The setlocale function>). By default, Perl still behaves this
873way for backward compatibility. If you want a Perl application to pay
874attention to locale information, you B<must> use the S<C<use locale>>
b687b08b 875pragma (see L<The use locale pragma>) to instruct it to do so.
b0c42ed9
JH
876
877Versions of Perl from 5.002 to 5.003 did use the C<LC_CTYPE>
5a964f20
TC
878information if available; that is, C<\w> did understand what
879were the letters according to the locale environment variables.
b0c42ed9
JH
880The problem was that the user had no control over the feature:
881if the C library supported locales, Perl used them.
882
883=head2 I18N:Collate obsolete
884
5a964f20 885In versions of Perl prior to 5.004, per-locale collation was possible
b0c42ed9
JH
886using the C<I18N::Collate> library module. This module is now mildly
887obsolete and should be avoided in new applications. The C<LC_COLLATE>
888functionality is now integrated into the Perl core language: One can
889use locale-specific scalar data completely normally with C<use locale>,
890so there is no longer any need to juggle with the scalar references of
891C<I18N::Collate>.
5f05dabc 892
14280422 893=head2 Sort speed and memory use impacts
5f05dabc
PP
894
895Comparing and sorting by locale is usually slower than the default
14280422
DD
896sorting; slow-downs of two to four times have been observed. It will
897also consume more memory: once a Perl scalar variable has participated
898in any string comparison or sorting operation obeying the locale
899collation rules, it will take 3-15 times more memory than before. (The
900exact multiplier depends on the string's contents, the operating system
901and the locale.) These downsides are dictated more by the operating
902system's implementation of the locale system than by Perl.
5f05dabc 903
e38874e2
DD
904=head2 write() and LC_NUMERIC
905
5a964f20 906Formats are the only part of Perl that unconditionally use information
e38874e2
DD
907from a program's locale; if a program's environment specifies an
908LC_NUMERIC locale, it is always used to specify the decimal point
909character in formatted output. Formatted output cannot be controlled by
910C<use locale> because the pragma is tied to the block structure of the
911program, and, for historical reasons, formats exist outside that block
912structure.
913
5f05dabc
PP
914=head2 Freely available locale definitions
915
916There is a large collection of locale definitions at
14280422
DD
917C<ftp://dkuug.dk/i18n/WG15-collection>. You should be aware that it is
918unsupported, and is not claimed to be fit for any purpose. If your
5a964f20 919system allows installation of arbitrary locales, you may find the
14280422
DD
920definitions useful as they are, or as a basis for the development of
921your own locales.
5f05dabc 922
14280422 923=head2 I18n and l10n
5f05dabc 924
b0c42ed9
JH
925"Internationalization" is often abbreviated as B<i18n> because its first
926and last letters are separated by eighteen others. (You may guess why
927the internalin ... internaliti ... i18n tends to get abbreviated.) In
928the same way, "localization" is often abbreviated to B<l10n>.
14280422
DD
929
930=head2 An imperfect standard
931
932Internationalization, as defined in the C and POSIX standards, can be
933criticized as incomplete, ungainly, and having too large a granularity.
934(Locales apply to a whole process, when it would arguably be more useful
935to have them apply to a single thread, window group, or whatever.) They
936also have a tendency, like standards groups, to divide the world into
937nations, when we all know that the world can equally well be divided
938into bankers, bikers, gamers, and so on. But, for now, it's the only
939standard we've got. This may be construed as a bug.
5f05dabc
PP
940
941=head1 BUGS
942
943=head2 Broken systems
944
5a964f20 945In certain systems, the operating system's locale support
2bdf8add
JH
946is broken and cannot be fixed or used by Perl. Such deficiencies can
947and will result in mysterious hangs and/or Perl core dumps when the
948C<use locale> is in effect. When confronted with such a system,
9607fc9c 949please report in excruciating detail to <F<perlbug@perl.com>>, and
5a964f20 950complain to your vendor: bug fixes may exist for these problems
2bdf8add
JH
951in your operating system. Sometimes such bug fixes are called an
952operating system upgrade.
5f05dabc
PP
953
954=head1 SEE ALSO
955
7b8d334a
GS
956L<POSIX (3)/isalnum>
957
958L<POSIX (3)/isalpha>
959
960L<POSIX (3)/isdigit>
961
962L<POSIX (3)/isgraph>
963
964L<POSIX (3)/islower>
965
966L<POSIX (3)/isprint>,
967
968L<POSIX (3)/ispunct>
969
970L<POSIX (3)/isspace>
971
972L<POSIX (3)/isupper>,
973
974L<POSIX (3)/isxdigit>
975
976L<POSIX (3)/localeconv>
977
978L<POSIX (3)/setlocale>,
979
980L<POSIX (3)/strcoll>
981
982L<POSIX (3)/strftime>
983
984L<POSIX (3)/strtod>,
985
14280422 986L<POSIX (3)/strxfrm>
5f05dabc
PP
987
988=head1 HISTORY
989
b0c42ed9 990Jarkko Hietaniemi's original F<perli18n.pod> heavily hacked by Dominic
5a964f20
TC
991Dunlop, assisted by the perl5-porters. Prose worked over a bit by
992Tom Christiansen.
5f05dabc 993
5a964f20 994Last update: Thu Jun 11 08:44:13 MDT 1998