from cover to cover, Perl does support many Unicode features.
People who want to learn to use Unicode in Perl, should probably read
-L<the Perl Unicode tutorial, perlunitut|perlunitut>, before reading
+the L<Perl Unicode tutorial, perlunitut|perlunitut>, before reading
this reference document.
+Also, the use of Unicode may present security issues that aren't obvious.
+Read L<Unicode Security Considerations|http://www.unicode.org/reports/tr36>.
+
=over 4
=item Input and Output Layers
The regular expression compiler produces polymorphic opcodes. That is,
the pattern adapts to the data and automatically switches to the Unicode
character scheme when presented with data that is internally encoded in
-UTF-8 -- or instead uses a traditional byte scheme when presented with
+UTF-8, or instead uses a traditional byte scheme when presented with
byte data.
=item C<use utf8> still needed to enable UTF-8/UTF-EBCDIC in scripts
semantics in a particular lexical scope. See L<bytes>.
The C<use feature 'unicode_strings'> pragma is intended to always, regardless
-of platform, force Unicode semantics in a particular lexical scope. In
-release 5.12, it is partially implemented, applying only to case changes.
+of platform, force character (Unicode) semantics in a particular lexical scope.
+In release 5.12, it is partially implemented, applying only to case changes.
See L</The "Unicode Bug"> below.
The C<utf8> pragma is primarily a compatibility device that enables
If strings operating under byte semantics and strings with Unicode
character data are concatenated, the new string will have
-character semantics. This can cause surprises: See L</BUGS>, below
+character semantics. This can cause surprises: See L</BUGS>, below.
+You can choose to be warned when this happens. See L<encoding::warnings>.
Under character semantics, many operations that formerly operated on
bytes now operate on characters. A character in Perl is
occur directly within the literal strings in UTF-8 encoding, or UTF-16.
(The former requires a BOM or C<use utf8>, the latter requires a BOM.)
-Unicode characters can also be added to a string by using the C<\x{...}>
+Unicode characters can also be added to a string by using the C<\N{U+...}>
notation. The Unicode code for the desired character, in hexadecimal,
-should be placed in the braces. For instance, a smiley face is
-C<\x{263A}>. This encoding scheme works for all characters, but
-for characters under 0x100, note that Perl may use an 8 bit encoding
-internally, for optimization and/or backward compatibility.
+should be placed in the braces, after the C<U>. For instance, a smiley face is
+C<\N{U+263A}>.
+
+Alternatively, you can use the C<\x{...}> notation for characters 0x100 and
+above. For characters below 0x100 you may get byte semantics instead of
+character semantics; see L</The "Unicode Bug">. On EBCDIC machines there is
+the additional problem that the value for such characters gives the EBCDIC
+character rather than the Unicode one.
Additionally, if you
you can use the C<\N{...}> notation and put the official Unicode
character name within the braces, such as C<\N{WHITE SMILING FACE}>.
+See L<charnames>.
=item *
=item *
-Character classes in regular expressions match characters instead of
+Bracketed character classes in regular expressions match characters instead of
bytes and match against the character properties specified in the
Unicode properties database. C<\w> can be used to match a Japanese
ideograph, for instance.
=item *
-Named Unicode properties, scripts, and block ranges may be used like
-character classes via the C<\p{}> "matches property" construct and
+Named Unicode properties, scripts, and block ranges may be used (like bracketed
+character classes) by using the C<\p{}> "matches property" construct and
the C<\P{}> negation, "doesn't match property".
See L</"Unicode Character Properties"> for more details.
=item *
-The special pattern C<\X> matches a logical character, an C<extended grapheme
-cluster> in Standardese. In Unicode what appears to the user to be a single
+The special pattern C<\X> matches a logical character, an "extended grapheme
+cluster" in Standardese. In Unicode what appears to the user to be a single
character, for example an accented C<G>, may in fact be composed of a sequence
of characters, in this case a C<G> followed by an accent character. C<\X>
will match the entire sequence.
=item *
-You can define your own mappings to be used in lc(),
-lcfirst(), uc(), and ucfirst() (or their string-inlined versions).
+You can define your own mappings to be used in C<lc()>,
+C<lcfirst()>, C<uc()>, and C<ucfirst()> (or their double-quoted string inlined
+versions such as C<\U>).
See L</"User-Defined Case Mappings"> for more details.
=back
=head2 Unicode Character Properties
Most Unicode character properties are accessible by using regular expressions.
-They are used like character classes via the C<\p{}> "matches property"
-construct and the C<\P{}> negation, "doesn't match property".
+They are used (like bracketed character classes) by using the C<\p{}> "matches
+property" construct and the C<\P{}> negation, "doesn't match property".
+
+Note that the only time that Perl considers a sequence of individual code
+points as a single logical character is in the C<\X> construct, already
+mentioned above. Therefore "character" in this discussion means a single
+Unicode code point.
-For instance, C<\p{Uppercase}> matches any character with the Unicode
+For instance, C<\p{Uppercase}> matches any single character with the Unicode
"Uppercase" property, while C<\p{L}> matches any character with a
General_Category of "L" (letter) property. Brackets are not
-required for single letter properties, so C<\p{L}> is equivalent to C<\pL>.
+required for single letter property names, so C<\p{L}> is equivalent to C<\pL>.
-More formally, C<\p{Uppercase}> matches any character whose Unicode Uppercase
-property value is True, and C<\P{Uppercase}> matches any character whose
-Uppercase property value is False, and they could have been written as
-C<\p{Uppercase=True}> and C<\p{Uppercase=False}>, respectively
+More formally, C<\p{Uppercase}> matches any single character whose Unicode
+Uppercase property value is True, and C<\P{Uppercase}> matches any character
+whose Uppercase property value is False, and they could have been written as
+C<\p{Uppercase=True}> and C<\p{Uppercase=False}>, respectively.
This formality is needed when properties are not binary, that is if they can
take on more values than just True and False. For example, the Bidi_Class (see
L</"Bidirectional Character Types"> below), can take on a number of different
values, such as Left, Right, Whitespace, and others. To match these, one needs
to specify the property name (Bidi_Class), and the value being matched against
-(Left, Right, etc.). This is done, as in the examples above, by having the two
-components separated by an equal sign (or interchangeably, a colon), like
+(Left, Right, etc.). This is done, as in the examples above, by having the
+two components separated by an equal sign (or interchangeably, a colon), like
C<\p{Bidi_Class: Left}>.
All Unicode-defined character properties may be written in these compound forms
usual categorization of a character" (from
L<http://www.unicode.org/reports/tr44>).
-The compound way of writing these is like C<{\p{General_Category=Number}>
+The compound way of writing these is like C<\p{General_Category=Number}>
(short, C<\p{gc:n}>). But Perl furnishes shortcuts in which everything up
through the equal or colon separator is omitted. So you can instead just write
C<\pN>.
Zp Paragraph_Separator
C Other
- Cc Control (also Cntrl)
+ Cc Control (also Cntrl)
Cf Format
Cs Surrogate (not usable)
Co Private_Use
Single-letter properties match all characters in any of the
two-letter sub-properties starting with the same letter.
-C<LC> and C<L&> are special cases, which are aliases for the set of
-C<Ll>, C<Lu>, and C<Lt>.
+C<LC> and C<L&> are special cases, which are both aliases for the set consisting of everything matched by C<Ll>, C<Lu>, and C<Lt>.
Because Perl hides the need for the user to understand the internal
representation of Unicode characters, there is no need to implement
=head3 B<Bidirectional Character Types>
-Because scripts differ in their directionality--Hebrew is
-written right to left, for example--Unicode supplies these properties in
+Because scripts differ in their directionality (Hebrew is
+written right to left, for example) Unicode supplies these properties in
the Bidi_Class class:
Property Meaning
Hiragana or Katakana. There are many more.
The Unicode Script property gives what script a given character is in,
-and can be matched with the compound form like C<\p{Script=Hebrew}> (short:
-C<\p{sc=hebr}>). Perl furnishes shortcuts for all script names. You can omit
-everything up through the equals (or colon), and simply write C<\p{Latin}> or
-C<\P{Cyrillic}>.
+and the property can be specified with the compound form like
+C<\p{Script=Hebrew}> (short: C<\p{sc=hebr}>). Perl furnishes shortcuts for all
+script names. You can omit everything up through the equals (or colon), and
+simply write C<\p{Latin}> or C<\P{Cyrillic}>.
A complete list of scripts and their shortcuts is in L<perluniprops>.
-=head3 B<Extended property classes>
-
-There are many more property classes than the basic ones described here,
-including some Perl extensions.
-A complete list is in L<perluniprops>.
-The extensions are more fully described in L<perlrecharclass>
-
=head3 B<Use of "Is" Prefix>
For backward compatibility (with Perl 5.6), all properties mentioned
characters. The difference between scripts and blocks is that the
concept of scripts is closer to natural languages, while the concept
of blocks is more of an artificial grouping based on groups of Unicode
-characters with consecutive ordinal values. For example, the C<Basic Latin>
+characters with consecutive ordinal values. For example, the "Basic Latin"
block is all characters whose ordinals are between 0 and 127, inclusive, in
-other words, the ASCII characters. The C<Latin> script contains some letters
-from this block as well as several more, like C<Latin-1 Supplement>,
-C<Latin Extended-A>, I<etc.>, but it does not contain all the characters from
+other words, the ASCII characters. The "Latin" script contains some letters
+from this block as well as several more, like "Latin-1 Supplement",
+"Latin Extended-A", etc., but it does not contain all the characters from
those blocks. It does not, for example, contain digits, because digits are
shared across many scripts. Digits and similar groups, like punctuation, are in
the script called C<Common>. There is also a script called C<Inherited> for
=item 1
It is confusing. There are many naming conflicts, and you may forget some.
-For example, \p{Hebrew} means the I<script> Hebrew, and NOT the I<block>
+For example, C<\p{Hebrew}> means the I<script> Hebrew, and NOT the I<block>
Hebrew. But would you remember that 6 months from now?
=item 2
It is unstable. A new version of Unicode may pre-empt the current meaning by
creating a property with the same name. There was a time in very early Unicode
-releases when \p{Hebrew} would have matched the I<block> Hebrew; now it
+releases when C<\p{Hebrew}> would have matched the I<block> Hebrew; now it
doesn't.
=back
A complete list of blocks and their shortcuts is in L<perluniprops>.
+=head3 B<Other Properties>
+
+There are many more properties than the very basic ones described here.
+A complete list is in L<perluniprops>.
+
+Unicode defines all its properties in the compound form, so all single-form
+properties are Perl extensions. A number of these are just synonyms for the
+Unicode ones, but some are genunine extensions, including a couple that are in
+the compound form. And quite a few of these are actually recommended by Unicode
+(in L<http://www.unicode.org/reports/tr18>).
+
+This section gives some details on all the extensions that aren't synonyms for
+compound-form Unicode properties (for those, you'll have to refer to the
+L<Unicode Standard|http://www.unicode.org/reports/tr44>.
+
+=over
+
+=item B<C<\p{All}>>
+
+This matches any of the 1_114_112 Unicode code points. It is a synonym for
+C<\p{Any}>.
+
+=item B<C<\p{Alnum}>>
+
+This matches any C<\p{Alphabetic}> or C<\p{Decimal_Number}> character.
+
+=item B<C<\p{Any}>>
+
+This matches any of the 1_114_112 Unicode code points. It is a synonym for
+C<\p{All}>.
+
+=item B<C<\p{Assigned}>>
+
+This matches any assigned code point; that is, any code point whose general
+category is not Unassigned (or equivalently, not Cn).
+
+=item B<C<\p{Blank}>>
+
+This is the same as C<\h> and C<\p{HorizSpace}>: A character that changes the
+spacing horizontally.
+
+=item B<C<\p{Decomposition_Type: Non_Canonical}>> (Short: C<\p{Dt=NonCanon}>)
+
+Matches a character that has a non-canonical decomposition.
+
+To understand the use of this rarely used property=value combination, it is
+necessary to know some basics about decomposition.
+Consider a character, say H. It could appear with various marks around it,
+such as an acute accent, or a circumflex, or various hooks, circles, arrows,
+I<etc.>, above, below, to one side and/or the other, etc. There are many
+possibilities among the world's languages. The number of combinations is
+astronomical, and if there were a character for each combination, it would
+soon exhaust Unicode's more than a million possible characters. So Unicode
+took a different approach: there is a character for the base H, and a
+character for each of the possible marks, and they can be combined variously
+to get a final logical character. So a logical character--what appears to be a
+single character--can be a sequence of more than one individual characters.
+This is called an "extended grapheme cluster". (Perl furnishes the C<\X>
+construct to match such sequences.)
+
+But Unicode's intent is to unify the existing character set standards and
+practices, and a number of pre-existing standards have single characters that
+mean the same thing as some of these combinations. An example is ISO-8859-1,
+which has quite a few of these in the Latin-1 range, an example being "LATIN
+CAPITAL LETTER E WITH ACUTE". Because this character was in this pre-existing
+standard, Unicode added it to its repertoire. But this character is considered
+by Unicode to be equivalent to the sequence consisting of first the character
+"LATIN CAPITAL LETTER E", then the character "COMBINING ACUTE ACCENT".
+
+"LATIN CAPITAL LETTER E WITH ACUTE" is called a "pre-composed" character, and
+the equivalence with the sequence is called canonical equivalence. All
+pre-composed characters are said to have a decomposition (into the equivalent
+sequence) and the decomposition type is also called canonical.
+
+However, many more characters have a different type of decomposition, a
+"compatible" or "non-canonical" decomposition. The sequences that form these
+decompositions are not considered canonically equivalent to the pre-composed
+character. An example, again in the Latin-1 range, is the "SUPERSCRIPT ONE".
+It is kind of like a regular digit 1, but not exactly; its decomposition
+into the digit 1 is called a "compatible" decomposition, specifically a
+"super" decomposition. There are several such compatibility
+decompositions (see L<http://www.unicode.org/reports/tr44>), including one
+called "compat" which means some miscellaneous type of decomposition
+that doesn't fit into the decomposition categories that Unicode has chosen.
+
+Note that most Unicode characters don't have a decomposition, so their
+decomposition type is "None".
+
+Perl has added the C<Non_Canonical> type, for your convenience, to mean any of
+the compatibility decompositions.
+
+=item B<C<\p{Graph}>>
+
+Matches any character that is graphic. Theoretically, this means a character
+that on a printer would cause ink to be used.
+
+=item B<C<\p{HorizSpace}>>
+
+This is the same as C<\h> and C<\p{Blank}>: A character that changes the
+spacing horizontally.
+
+=item B<C<\p{In=*}>>
+
+This is a synonym for C<\p{Present_In=*}>
+
+=item B<C<\p{PerlSpace}>>
+
+This is the same as C<\s>, restricted to ASCII, namely C<S<[ \f\n\r\t]>>.
+
+Mnemonic: Perl's (original) space
+
+=item B<C<\p{PerlWord}>>
+
+This is the same as C<\w>, restricted to ASCII, namely C<[A-Za-z0-9_]>
+
+Mnemonic: Perl's (original) word.
+
+=item B<C<\p{PosixAlnum}>>
+
+This matches any alphanumeric character in the ASCII range, namely
+C<[A-Za-z0-9]>.
+
+=item B<C<\p{PosixAlpha}>>
+
+This matches any alphabetic character in the ASCII range, namely C<[A-Za-z]>.
+
+=item B<C<\p{PosixBlank}>>
+
+This matches any blank character in the ASCII range, namely C<S<[ \t]>>.
+
+=item B<C<\p{PosixCntrl}>>
+
+This matches any control character in the ASCII range, namely C<[\x00-\x1F\x7F]>
+
+=item B<C<\p{PosixDigit}>>
+
+This matches any digit character in the ASCII range, namely C<[0-9]>.
+
+=item B<C<\p{PosixGraph}>>
+
+This matches any graphical character in the ASCII range, namely C<[\x21-\x7E]>.
+
+=item B<C<\p{PosixLower}>>
+
+This matches any lowercase character in the ASCII range, namely C<[a-z]>.
+
+=item B<C<\p{PosixPrint}>>
+
+This matches any printable character in the ASCII range, namely C<[\x20-\x7E]>.
+These are the graphical characters plus SPACE.
+
+=item B<C<\p{PosixPunct}>>
+
+This matches any punctuation character in the ASCII range, namely
+C<[\x21-\x2F\x3A-\x40\x5B-\x60\x7B-\x7E]>. These are the
+graphical characters that aren't word characters. Note that the Posix standard
+includes in its definition of punctuation, those characters that Unicode calls
+"symbols."
+
+=item B<C<\p{PosixSpace}>>
+
+This matches any space character in the ASCII range, namely
+C<S<[ \f\n\r\t\x0B]>> (the last being a vertical tab).
+
+=item B<C<\p{PosixUpper}>>
+
+This matches any uppercase character in the ASCII range, namely C<[A-Z]>.
+
+=item B<C<\p{Present_In: *}>> (Short: C<\p{In=*}>)
+
+This property is used when you need to know in what Unicode version(s) a
+character is.
+
+The "*" above stands for some two digit Unicode version number, such as
+C<1.1> or C<4.0>; or the "*" can also be C<Unassigned>. This property will
+match the code points whose final disposition has been settled as of the
+Unicode release given by the version number; C<\p{Present_In: Unassigned}>
+will match those code points whose meaning has yet to be assigned.
+
+For example, C<U+0041> "LATIN CAPITAL LETTER A" was present in the very first
+Unicode release available, which is C<1.1>, so this property is true for all
+valid "*" versions. On the other hand, C<U+1EFF> was not assigned until version
+5.1 when it became "LATIN SMALL LETTER Y WITH LOOP", so the only "*" that
+would match it are 5.1, 5.2, and later.
+
+Unicode furnishes the C<Age> property from which this is derived. The problem
+with Age is that a strict interpretation of it (which Perl takes) has it
+matching the precise release a code point's meaning is introduced in. Thus
+C<U+0041> would match only 1.1; and C<U+1EFF> only 5.1. This is not usually what
+you want.
+
+Some non-Perl implementations of the Age property may change its meaning to be
+the same as the Perl Present_In property; just be aware of that.
+
+Another confusion with both these properties is that the definition is not
+that the code point has been assigned, but that the meaning of the code point
+has been determined. This is because 66 code points will always be
+unassigned, and, so the Age for them is the Unicode version the decision to
+make them so was made in. For example, C<U+FDD0> is to be permanently
+unassigned to a character, and the decision to do that was made in version 3.1,
+so C<\p{Age=3.1}> matches this character and C<\p{Present_In: 3.1}> and up
+matches as well.
+
+=item B<C<\p{Print}>>
+
+This matches any character that is graphical or blank, except controls.
+
+=item B<C<\p{SpacePerl}>>
+
+This is the same as C<\s>, including beyond ASCII.
+
+Mnemonic: Space, as modified by Perl. (It doesn't include the vertical tab
+which both the Posix standard and Unicode consider to be space.)
+
+=item B<C<\p{VertSpace}>>
+
+This is the same as C<\v>: A character that changes the spacing vertically.
+
+=item B<C<\p{Word}>>
+
+This is the same as C<\w>, including beyond ASCII.
+
+=back
+
=head2 User-Defined Character Properties
You can define your own binary character properties by defining subroutines
syllabaries (hiragana and katakana), you can define
sub InKana {
- return <<END;
+ return <<END;
3040\t309F
30A0\t30FF
END
You could also have used the existing block property names:
sub InKana {
- return <<'END';
+ return <<'END';
+utf8::InHiragana
+utf8::InKatakana
END
the non-characters:
sub InKana {
- return <<'END';
+ return <<'END';
+utf8::InHiragana
+utf8::InKatakana
-utf8::IsCn
The negation is useful for defining (surprise!) negated classes.
sub InNotKana {
- return <<'END';
+ return <<'END';
!utf8::InHiragana
-utf8::InKatakana
+utf8::IsCn
END
}
-It's important to remember not to use "&" for the first set -- that
+It's important to remember not to use "&" for the first set; that
would be intersecting with nothing (resulting in an empty set).
=head2 User-Defined Case Mappings
-You can also define your own mappings to be used in the lc(),
-lcfirst(), uc(), and ucfirst() (or their string-inlined versions).
+You can also define your own mappings to be used in C<lc()>,
+C<lcfirst()>, C<uc()>, and C<ucfirst()> (or their string-inlined versions,
+C<\L>, C<\l>, C<\U>, and C<\u>).
The principle is similar to that of user-defined character
properties: to define subroutines
-with names like C<ToLower> (for lc() and lcfirst()), C<ToTitle> (for
-the first character in ucfirst()), and C<ToUpper> (for uc(), and the
-rest of the characters in ucfirst()).
+with names C<ToLower> (for C<lc()> and C<lcfirst()>); C<ToTitle> (for
+C<ucfirst()>); and C<ToUpper> (for C<uc()>).
The string returned by the subroutines needs to be two hexadecimal numbers
separated by two tabulators: the two numbers being, respectively, the source
code point and the destination code point. For example:
sub ToUpper {
- return <<END;
+ return <<END;
0061\t\t0041
END
}
-defines an uc() mapping that causes only the character "a"
+defines a mapping for C<uc()> (and C<\U>) that causes only the character "a"
to be mapped to "A"; all other characters will remain unchanged.
(For serious hackers only) The above means you have to furnish a complete
mapping; you can't just override a couple of characters and leave the rest
-unchanged. You can find all the mappings in the directory
-C<$Config{privlib}>/F<unicore/To/>. The mapping data is returned as the
-here-document, and the C<utf8::ToSpecFoo> are special exception mappings
-derived from <$Config{privlib}>/F<unicore/SpecialCasing.txt>. The C<Digit> and
-C<Fold> mappings that one can see in the directory are not directly
-user-accessible, one can use either the C<Unicode::UCD> module, or just match
-case-insensitively (that's when the C<Fold> mapping is used).
+unchanged. You can find all the official mappings in the directory
+C<$Config{privlib}>F</unicore/To/>. The mapping data is returned as the
+here-document. The C<utf8::ToSpecI<Foo>> hashes in those files are special
+exception mappings derived from
+C<$Config{privlib}>F</unicore/SpecialCasing.txt>. (The "Digit" and
+"Fold" mappings that one can see in the directory are not directly
+user-accessible, one can use either the L<Unicode::UCD> module, or just match
+case-insensitively, which is what uses the "Fold" mapping. Neither are user
+overridable.)
+
+If you have many mappings to change, you can take the official mapping data,
+change by hand the affected code points, and place the whole thing into your
+subroutine. But this will only be valid on Perls that use the same Unicode
+version. Another option would be to have your subroutine read the official
+mapping file(s) and overwrite the affected code points.
+
+If you have only a few mappings to change, starting in 5.14 you can use the
+following trick, here illustrated for Turkish.
+
+ use Config;
+
+ sub ToUpper {
+ my $official = do "$Config{privlib}/unicore/To/Upper.pl";
+ $utf8::ToSpecUpper{'i'} =
+ "\N{LATIN CAPITAL LETTER I WITH DOT ABOVE}";
+ return $official;
+ }
-The mappings will only take effect on scalars that have been marked as having
-Unicode characters, for example by using C<utf8::upgrade()>.
-Old byte-style strings are not affected.
+This takes the official mappings and overrides just one, for "LATIN SMALL
+LETTER I". The keys to the hash must be in UTF-8 (or on EBCDIC platforms,
+UTF-EBCDIC), as illustrated by the inverse function.
+
+ sub ToLower {
+ my $official = do $lower;
+ $utf8::ToSpecLower{"\xc4\xb0"} = "i";
+ return $official;
+ }
+
+This example is for an ASCII platform, and C<\xc4\xb0> is the UTF-8 string that
+represents C<\N{LATIN CAPITAL LETTER I WITH DOT ABOVE}>, C<U+0130>.
+
+(The trick illustrated here does work in earlier releases, but only if all the
+characters you want to override have ordinal values of 256 or higher.)
+
+The mappings are in effect only for the package they are defined in, and only
+on scalars that have been marked as having Unicode characters, for example by
+using C<utf8::upgrade()>. You can get around the latter restriction in the
+scope of a C<S<use subs>>:
+
+ use subs qw(uc ucfirst lc lcfirst);
+
+ sub uc($) {
+ my $string = shift;
+ utf8::upgrade($string);
+ return CORE::uc($string);
+ }
+
+ sub lc($) {
+ my $string = shift;
+ utf8::upgrade($string);
+
+ # Unless an I is before a dot_above, it turns into a dotless i.
+ $string =~
+ s/I (?! [^\p{ccc=0}\p{ccc=Above}]* \x{0307} )/\x{131}/gx;
+
+ # But when the I is followed by a dot_above, remove the
+ # dot_above so the end result will be i.
+ $string =~ s/I ([^\p{ccc=0}\p{ccc=Above}]* ) \x{0307}/i$1/gx;
+ return CORE::lc($string);
+ }
-The mappings are in effect for the package they are defined in.
+These examples (also for Turkish) make sure the input is in UTF-8, and then
+call the corresponding official function, which will use the C<ToUpper()> and
+C<ToLower()> functions you have defined in the package. The C<lc()> example
+shows how you can add context-dependent casing. (For Turkish, there other
+required functions: C<ucfirst>, C<lcfirst>, and C<ToTitle>. These are very
+similar to the ones given above.)
=head2 Character Encodings for Input and Output
Level 1 - Basic Unicode Support
- RL1.1 Hex Notation - done [1]
- RL1.2 Properties - done [2][3]
- RL1.2a Compatibility Properties - done [4]
- RL1.3 Subtraction and Intersection - MISSING [5]
- RL1.4 Simple Word Boundaries - done [6]
- RL1.5 Simple Loose Matches - done [7]
- RL1.6 Line Boundaries - MISSING [8]
- RL1.7 Supplementary Code Points - done [9]
+ RL1.1 Hex Notation - done [1]
+ RL1.2 Properties - done [2][3]
+ RL1.2a Compatibility Properties - done [4]
+ RL1.3 Subtraction and Intersection - MISSING [5]
+ RL1.4 Simple Word Boundaries - done [6]
+ RL1.5 Simple Loose Matches - done [7]
+ RL1.6 Line Boundaries - MISSING [8]
+ RL1.7 Supplementary Code Points - done [9]
[1] \x{...}
[2] \p{...} \P{...}
- [3] supports not only minimal list, but all Unicode character
- properties (see L</Unicode Character Properties>)
+ [3] supports not only minimal list, but all Unicode character
+ properties (see L</Unicode Character Properties>)
[4] \d \D \s \S \w \W \X [:prop:] [:^prop:]
[5] can use regular expression look-ahead [a] or
- user-defined character properties [b] to emulate set operations
+ user-defined character properties [b] to emulate set
+ operations
[6] \b \B
- [7] note that Perl does Full case-folding in matching (but with bugs),
- not Simple: for example U+1F88 is equivalent to U+1F00 U+03B9,
- not with 1F80. This difference matters mainly for certain Greek
- capital letters with certain modifiers: the Full case-folding
- decomposes the letter, while the Simple case-folding would map
- it to a single character.
- [8] should do ^ and $ also on U+000B (\v in C), FF (\f), CR (\r),
- CRLF (\r\n), NEL (U+0085), LS (U+2028), and PS (U+2029);
- should also affect <>, $., and script line numbers;
- should not split lines within CRLF [c] (i.e. there is no empty
- line between \r and \n)
- [9] UTF-8/UTF-EBDDIC used in perl allows not only U+10000 to U+10FFFF
- but also beyond U+10FFFF [d]
+ [7] note that Perl does Full case-folding in matching (but with
+ bugs), not Simple: for example U+1F88 is equivalent to
+ U+1F00 U+03B9, not with 1F80. This difference matters
+ mainly for certain Greek capital letters with certain
+ modifiers: the Full case-folding decomposes the letter,
+ while the Simple case-folding would map it to a single
+ character.
+ [8] should do ^ and $ also on U+000B (\v in C), FF (\f), CR
+ (\r), CRLF (\r\n), NEL (U+0085), LS (U+2028), and PS
+ (U+2029); should also affect <>, $., and script line
+ numbers; should not split lines within CRLF [c] (i.e. there
+ is no empty line between \r and \n)
+ [9] UTF-8/UTF-EBDDIC used in perl allows not only U+10000 to
+ U+10FFFF but also beyond U+10FFFF [d]
[a] You can mimic class subtraction using lookahead.
For example, what UTS#18 might write as
[c] Try the C<:crlf> layer (see L<PerlIO>).
-[d] Avoid C<use warning 'utf8';> (or say C<no warning 'utf8';>) to allow
-U+FFFF (C<\x{FFFF}>).
+[d] U+FFFF will currently generate a warning message if 'utf8' warnings are
+ enabled
=item *
Level 2 - Extended Unicode Support
RL2.1 Canonical Equivalents - MISSING [10][11]
- RL2.2 Default Grapheme Clusters - MISSING [12][13]
+ RL2.2 Default Grapheme Clusters - MISSING [12]
RL2.3 Default Word Boundaries - MISSING [14]
RL2.4 Default Loose Matches - MISSING [15]
RL2.5 Name Properties - MISSING [16]
[17] see UAX#10 "Unicode Collation Algorithms"
[18] have Unicode::Collate but not integrated to regexes
- [19] have (?<=x) and (?=x), but look-aheads or look-behinds should see
- outside of the target substring
- [20] need insensitive matching for linguistic features other than case;
- for example, hiragana to katakana, wide and narrow, simplified Han
- to traditional Han (see UTR#30 "Character Foldings")
+ [19] have (?<=x) and (?=x), but look-aheads or look-behinds
+ should see outside of the target substring
+ [20] need insensitive matching for linguistic features other
+ than case; for example, hiragana to katakana, wide and
+ narrow, simplified Han to traditional Han (see UTR#30
+ "Character Foldings")
=back
The following table is from Unicode 3.2.
- Code Points 1st Byte 2nd Byte 3rd Byte 4th Byte
+ Code Points 1st Byte 2nd Byte 3rd Byte 4th Byte
- U+0000..U+007F 00..7F
+ U+0000..U+007F 00..7F
U+0080..U+07FF * C2..DF 80..BF
- U+0800..U+0FFF E0 * A0..BF 80..BF
+ U+0800..U+0FFF E0 * A0..BF 80..BF
U+1000..U+CFFF E1..EC 80..BF 80..BF
U+D000..U+D7FF ED 80..9F 80..BF
U+D800..U+DFFF +++++++ utf16 surrogates, not legal utf8 +++++++
U+E000..U+FFFF EE..EF 80..BF 80..BF
- U+10000..U+3FFFF F0 * 90..BF 80..BF 80..BF
- U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
- U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
+ U+10000..U+3FFFF F0 * 90..BF 80..BF 80..BF
+ U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
+ U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
Note the gaps before several of the byte entries above marked by '*'. These are
caused by legal UTF-8 avoiding non-shortest encodings: it is technically
ccccbbbbbbaaaaaa 1110cccc 10bbbbbb 10aaaaaa
00000dddccccccbbbbbbaaaaaa 11110ddd 10cccccc 10bbbbbb 10aaaaaa
-As you can see, the continuation bytes all begin with C<10>, and the
+As you can see, the continuation bytes all begin with "10", and the
leading bits of the start byte tell how many bytes there are in the
encoded character.
Surrogates are code points set aside to encode the C<U+10000..U+10FFFF>
range of Unicode code points in pairs of 16-bit units. The I<high
-surrogates> are the range C<U+D800..U+DBFF>, and the I<low surrogates>
+surrogates> are the range C<U+D800..U+DBFF> and the I<low surrogates>
are the range C<U+DC00..U+DFFF>. The surrogate encoding is
- $hi = ($uni - 0x10000) / 0x400 + 0xD800;
- $lo = ($uni - 0x10000) % 0x400 + 0xDC00;
+ $hi = ($uni - 0x10000) / 0x400 + 0xD800;
+ $lo = ($uni - 0x10000) % 0x400 + 0xDC00;
and the decoding is
- $uni = 0x10000 + ($hi - 0xD800) * 0x400 + ($lo - 0xDC00);
+ $uni = 0x10000 + ($hi - 0xD800) * 0x400 + ($lo - 0xDC00);
If you try to generate surrogates (for example by using chr()), you
will get a warning, if warnings are turned on, because those code
=head2 The "Unicode Bug"
The term, the "Unicode bug" has been applied to an inconsistency with the
-Unicode characters whose code points are in the Latin-1 Supplement block, that
+Unicode characters whose ordinals are in the Latin-1 Supplement block, that
is, between 128 and 255. Without a locale specified, unlike all other
characters or code points, these characters have very different semantics in
byte semantics versus character semantics.
0
1
-If there's no \w in s1 or in s2, why does their concatenation have one?
+If there's no C<\w> in C<s1> or in C<s2>, why does their concatenation have one?
This anomaly stems from Perl's attempt to not disturb older programs that
didn't use Unicode, and hence had no semantics for characters outside of the
problematic behaviors in later releases: you can't have one without them all.
In the meantime, a workaround is to always call utf8::upgrade($string), or to
-use the standard modules L<Encode> or L<charnames>.
+use the standard module L<Encode>. Also, a scalar that has any characters
+whose ordinal is above 0x100, or which were specified using either of the
+C<\N{...}> notations will automatically have character semantics.
=head2 Forcing Unicode in Perl (Or Unforcing Unicode in Perl)
Unicode support will also tend to run slower. Use of locales with
Unicode is discouraged.
-=head2 Problems with characters in the C<Latin-1 Supplement> range
+=head2 Problems with characters in the Latin-1 Supplement range
See L</The "Unicode Bug">
There are problems with case-insensitive matches, including those involving
character classes (enclosed in [square brackets]), characters whose fold
-is to multiple characters (such as the single character C<LATIN SMALL LIGATURE
-FFL> matches case-insensitively with the 3-character string C<ffl>), and
-characters in the C<Latin-1 Supplement>.
+is to multiple characters (such as the single character LATIN SMALL LIGATURE
+FFL matches case-insensitively with the 3-character string C<ffl>), and
+characters in the Latin-1 Supplement.
=head2 Interaction with Extensions
Perl's internal representation like so:
sub my_escape_html ($) {
- my($what) = shift;
- return unless defined $what;
- Encode::decode_utf8(Foo::Bar::escape_html(Encode::encode_utf8($what)));
+ my($what) = shift;
+ return unless defined $what;
+ Encode::decode_utf8(Foo::Bar::escape_html(
+ Encode::encode_utf8($what)));
}
Sometimes, when the extension does not convert data but just stores
that is still true.
sub fetchrow {
- my($self, $sth, $what) = @_; # $what is one of fetchrow_{array,hashref}
+ # $what is one of fetchrow_{array,hashref}
+ my($self, $sth, $what) = @_;
if ($] < 5.007) {
return $sth->$what;
} else {
my $ret = $sth->$what;
if (ref $ret) {
for my $k (keys %$ret) {
- defined && /[^\000-\177]/ && Encode::_utf8_on($_) for $ret->{$k};
+ defined
+ && /[^\000-\177]/
+ && Encode::_utf8_on($_) for $ret->{$k};
}
return $ret;
} else {
projects / p5sagit/p5-mst-13.2.git / blobdiff