# pcre2unicode

## NAME



           PCRE2 - Perl-compatible regular expressions (revised API)
    


## UNICODE AND UTF SUPPORT



    
           PCRE2 is normally built with Unicode support, though if you do not
           need it, you can build it without, in which case the library will
           be smaller. With Unicode support, PCRE2 has knowledge of Unicode
           character properties and can process strings of text in UTF-8,
           UTF-16, and UTF-32 format (depending on the code unit width), but
           this is not the default. Unless specifically requested, PCRE2
           treats each code unit in a string as one character.
    
           There are two ways of telling PCRE2 to switch to UTF mode, where
           characters may consist of more than one code unit and the range of
           values is constrained. The program can call **pcre2_compile()** with
           the PCRE2_UTF option, or the pattern may start with the sequence
           (*UTF).  However, the latter facility can be locked out by the
           PCRE2_NEVER_UTF option.  That is, the programmer can prevent the
           supplier of the pattern from switching to UTF mode.
    
           Note that the PCRE2_MATCH_INVALID_UTF option (see below) forces
           PCRE2_UTF to be set.
    
           In UTF mode, both the pattern and any subject strings that are
           matched against it are treated as UTF strings instead of strings
           of individual one-code-unit characters. There are also some other
           changes to the way characters are handled, as documented below.
    


## UNICODE PROPERTY SUPPORT



    
           When PCRE2 is built with Unicode support, the escape sequences
           \p{..}, \P{..}, and \X can be used. This is not dependent on the
           PCRE2_UTF setting.  The Unicode properties that can be tested are
           a subset of those that Perl supports. Currently they are limited
           to the general category properties such as Lu for an upper case
           letter or Nd for a decimal number, the derived properties Any and
           Lc (synonym L&), the Unicode script names such as Arabic or Han,
           Bidi_Class, Bidi_Control, and a few binary properties.
    
           The full lists are given in the **pcre2pattern** and **pcre2syntax**
           documentation. In general, only the short names for properties are
           supported.  For example, \p{L} matches a letter. Its longer
           synonym, \p{Letter}, is not supported. Furthermore, in Perl, many
           properties may optionally be prefixed by "Is", for compatibility
           with Perl 5.6. PCRE2 does not support this.
    


## WIDE CHARACTERS AND UTF MODES



    
           Code points less than 256 can be specified in patterns by either
           braced or unbraced hexadecimal escape sequences (for example,
           \x{b3} or \xb3). Larger values have to use braced sequences.
           Unbraced octal code points up to \777 are also recognized; larger
           ones can be coded using \o{...}.
    
           The escape sequence \N{U+<hex digits>} is recognized as another
           way of specifying a Unicode character by code point in a UTF mode.
           It is not allowed in non-UTF mode.
    
           In UTF mode, repeat quantifiers apply to complete UTF characters,
           not to individual code units.
    
           In UTF mode, the dot metacharacter matches one UTF character
           instead of a single code unit.
    
           In UTF mode, capture group names are not restricted to ASCII, and
           may contain any Unicode letters and decimal digits, as well as
           underscore.
    
           The escape sequence \C can be used to match a single code unit in
           UTF mode, but its use can lead to some strange effects because it
           breaks up multi-unit characters (see the description of \C in the
           **pcre2pattern** documentation). For this reason, there is a build-
           time option that disables support for \C completely. There is also
           a less draconian compile-time option for locking out the use of \C
           when a pattern is compiled.
    
           The use of \C is not supported by the alternative matching
           function **pcre2_dfa_match()** when in UTF-8 or UTF-16 mode, that is,
           when a character may consist of more than one code unit. The use
           of \C in these modes provokes a match-time error. Also, the JIT
           optimization does not support \C in these modes. If JIT
           optimization is requested for a UTF-8 or UTF-16 pattern that
           contains \C, it will not succeed, and so when **pcre2_match()** is
           called, the matching will be carried out by the interpretive
           function.
    
           The character escapes \b, \B, \d, \D, \s, \S, \w, and \W correctly
           test characters of any code value, but, by default, the characters
           that PCRE2 recognizes as digits, spaces, or word characters remain
           the same set as in non-UTF mode, all with code points less than
           256. This remains true even when PCRE2 is built to include Unicode
           support, because to do otherwise would slow down matching in many
           common cases. Note that this also applies to \b and \B, because
           they are defined in terms of \w and \W. If you want to test for a
           wider sense of, say, "digit", you can use explicit Unicode
           property tests such as \p{Nd}. Alternatively, if you set the
           PCRE2_UCP option, the way that the character escapes work is
           changed so that Unicode properties are used to determine which
           characters match, though there are some options that suppress this
           for individual escapes. For details see the section on generic
           character types in the **pcre2pattern** documentation.
    
           Like the escapes, characters that match the POSIX named character
           classes are all low-valued characters unless the PCRE2_UCP option
           is set, but there is an option to override this.
    
           In contrast to the character escapes and character classes, the
           special horizontal and vertical white space escapes (\h, \H, \v,
           and \V) do match all the appropriate Unicode characters, whether
           or not PCRE2_UCP is set.
    


## UNICODE CASE-EQUIVALENCE



    
           If either PCRE2_UTF or PCRE2_UCP is set, upper/lower case
           processing makes use of Unicode properties except for characters
           whose code points are less than 128 and that have at most two
           case-equivalent values. For these, a direct table lookup is used
           for speed. A few Unicode characters such as Greek sigma have more
           than two code points that are case-equivalent, and these are
           treated specially. Setting PCRE2_UCP without PCRE2_UTF allows
           Unicode-style case processing for non-UTF character encodings such
           as UCS-2.
    
           There are two ASCII characters (S and K) that, in addition to
           their ASCII lower case equivalents, have a non-ASCII one as well
           (long S and Kelvin sign).  Recognition of these non-ASCII
           characters as case-equivalent to their ASCII counterparts can be
           disabled by setting the PCRE2_EXTRA_CASELESS_RESTRICT option. When
           this is set, all characters in a case equivalence must either be
           ASCII or non-ASCII; there can be no mixing.
    
               Without PCRE2_EXTRA_CASELESS_RESTRICT:
                 'k' = 'K' = U+212A (Kelvin sign)
                 's' = 'S' = U+017F (long S)
               With PCRE2_EXTRA_CASELESS_RESTRICT:
                 'k' = 'K'
                 U+212A (Kelvin sign)  only case-equivalent to itself
                 's' = 'S'
                 U+017F (long S)       only case-equivalent to itself
    
           One language family, Turkish and Azeri, has its own case-
           insensitivity rules, which can be selected by setting
           PCRE2_EXTRA_TURKISH_CASING. This alters the behaviour of the 'i',
           'I', U+0130 (capital I with dot above), and U+0131 (small dotless
           i) characters.
    
               Without PCRE2_EXTRA_TURKISH_CASING:
                 'i' = 'I'
                 U+0130 (capital I with dot above)  only case-equivalent to
           itself
                 U+0131 (small dotless i)           only case-equivalent to
           itself
               With PCRE2_EXTRA_TURKISH_CASING:
                 'i' = U+0130 (capital I with dot above)
                 U+0131 (small dotless i) = 'I'
    
           It is not allowed to specify both PCRE2_EXTRA_CASELESS_RESTRICT
           and PCRE2_EXTRA_TURKISH_CASING together.
    
           From release 10.45 the Unicode letter properties Lu (upper case),
           Ll (lower case), and Lt (title case) are all treated as Lc (cased
           letter) when caseless matching is set by the PCRE2_CASELESS option
           or (?i) within the pattern.
    


## SCRIPT RUNS



    
           The pattern constructs (*script_run:...) and
           (*atomic_script_run:...), with synonyms (*sr:...) and (*asr:...),
           verify that the string matched within the parentheses is a script
           run. In concept, a script run is a sequence of characters that are
           all from the same Unicode script. However, because some scripts
           are commonly used together, and because some diacritical and other
           marks are used with multiple scripts, it is not that simple.
    
           Every Unicode character has a Script property, mostly with a value
           corresponding to the name of a script, such as Latin, Greek, or
           Cyrillic. There are also three special values:
    
           "Unknown" is used for code points that have not been assigned, and
           also for the surrogate code points. In the PCRE2 32-bit library,
           characters whose code points are greater than the Unicode maximum
           (U+10FFFF), which are accessible only in non-UTF mode, are
           assigned the Unknown script.
    
           "Common" is used for characters that are used with many scripts.
           These include punctuation, emoji, mathematical, musical, and
           currency symbols, and the ASCII digits 0 to 9.
    
           "Inherited" is used for characters such as diacritical marks that
           modify a previous character. These are considered to take on the
           script of the character that they modify.
    
           Some Inherited characters are used with many scripts, but many of
           them are only normally used with a small number of scripts. For
           example, U+102E0 (Coptic Epact thousands mark) is used only with
           Arabic and Coptic. In order to make it possible to check this, a
           Unicode property called Script Extension exists. Its value is a
           list of scripts that apply to the character. For the majority of
           characters, the list contains just one script, the same one as the
           Script property. However, for characters such as U+102E0 more than
           one Script is listed. There are also some Common characters that
           have a single, non-Common script in their Script Extension list.
    
           The next section describes the basic rules for deciding whether a
           given string of characters is a script run. Note, however, that
           there are some special cases involving the Chinese Han script, and
           an additional constraint for decimal digits. These are covered in
           subsequent sections.
    
       **Basic script run rules**
    
           A string that is less than two characters long is a script run.
           This is the only case in which an Unknown character can be part of
           a script run. Longer strings are checked using only the Script
           Extensions property, not the basic Script property.
    
           If a character's Script Extension property is the single value
           "Inherited", it is always accepted as part of a script run. This
           is also true for the property "Common", subject to the checking of
           decimal digits described below. All the remaining characters in a
           script run must have at least one script in common in their Script
           Extension lists. In set-theoretic terminology, the intersection of
           all the sets of scripts must not be empty.
    
           A simple example is an Internet name such as "google.com". The
           letters are all in the Latin script, and the dot is Common, so
           this string is a script run.  However, the Cyrillic letter "o"
           looks exactly the same as the Latin "o"; a string that looks the
           same, but with Cyrillic "o"s is not a script run.
    
           More interesting examples involve characters with more than one
           script in their Script Extension. Consider the following
           characters:
    
             U+060C  Arabic comma
             U+06D4  Arabic full stop
    
           The first has the Script Extension list Arabic, Hanifi Rohingya,
           Syriac, and Thaana; the second has just Arabic and Hanifi
           Rohingya. Both of them could appear in script runs of either
           Arabic or Hanifi Rohingya. The first could also appear in Syriac
           or Thaana script runs, but the second could not.
    
       **The Chinese Han script**
    
           The Chinese Han script is commonly used in conjunction with other
           scripts for writing certain languages. Japanese uses the Hiragana
           and Katakana scripts together with Han; Korean uses Hangul and
           Han; Taiwanese Mandarin uses Bopomofo and Han. These three
           combinations are treated as special cases when checking script
           runs and are, in effect, "virtual scripts". Thus, a script run may
           contain a mixture of Hiragana, Katakana, and Han, or a mixture of
           Hangul and Han, or a mixture of Bopomofo and Han, but not, for
           example, a mixture of Hangul and Bopomofo and Han. PCRE2 (like
           Perl) follows Unicode's Technical Standard 39 ("Unicode Security
           Mechanisms", http://unicode.org/reports/tr39/) in allowing such
           mixtures.
    
       **Decimal digits**
    
           Unicode contains many sets of 10 decimal digits in different
           scripts, and some scripts (including the Common script) contain
           more than one set. Some of these decimal digits them are visually
           indistinguishable from the common ASCII digits. In addition to the
           script checking described above, if a script run contains any
           decimal digits, they must all come from the same set of 10
           adjacent characters.
    


## VALIDITY OF UTF STRINGS



    
           When the PCRE2_UTF option is set, the strings passed as patterns
           and subjects are (by default) checked for validity on entry to the
           relevant functions. If an invalid UTF string is passed, a negative
           error code is returned. The code unit offset to the offending
           character can be extracted from the match data block by calling
           **pcre2_get_startchar()** , which is used for this purpose after a UTF
           error.
    
           In some situations, you may already know that your strings are
           valid, and therefore want to skip these checks in order to improve
           performance, for example in the case of a long subject string that
           is being scanned repeatedly.  If you set the PCRE2_NO_UTF_CHECK
           option at compile time or at match time, PCRE2 assumes that the
           pattern or subject it is given (respectively) contains only valid
           UTF code unit sequences.
    
           If you pass an invalid UTF string when PCRE2_NO_UTF_CHECK is set,
           the result is undefined and your program may crash or loop
           indefinitely or give incorrect results. There is, however, one
           mode of matching that can handle invalid UTF subject strings. This
           is enabled by passing PCRE2_MATCH_INVALID_UTF to **pcre2_compile()**
           and is discussed below in the next section. The rest of this
           section covers the case when PCRE2_MATCH_INVALID_UTF is not set.
    
           Passing PCRE2_NO_UTF_CHECK to **pcre2_compile()** just disables the
           UTF check for the pattern; it does not also apply to subject
           strings. If you want to disable the check for a subject string you
           must pass this same option to **pcre2_match()** or **pcre2_dfa_match()**.
    
           UTF-16 and UTF-32 strings can indicate their endianness by special
           code knows as a byte-order mark (BOM). The PCRE2 functions do not
           handle this, expecting strings to be in host byte order.
    
           Unless PCRE2_NO_UTF_CHECK is set, a UTF string is checked before
           any other processing takes place. In the case of **pcre2_match()** and
           **pcre2_dfa_match()** calls with a non-zero starting offset, the check
           is applied only to that part of the subject that could be
           inspected during matching, and there is a check that the starting
           offset points to the first code unit of a character or to the end
           of the subject. If there are no lookbehind assertions in the
           pattern, the check starts at the starting offset.  Otherwise, it
           starts at the length of the longest lookbehind before the starting
           offset, or at the start of the subject if there are not that many
           characters before the starting offset. Note that the sequences \b
           and \B are one-character lookbehinds.
    
           In addition to checking the format of the string, there is a check
           to ensure that all code points lie in the range U+0 to U+10FFFF,
           excluding the surrogate area. The so-called "non-character" code
           points are not excluded because Unicode corrigendum #9 makes it
           clear that they should not be.
    
           Characters in the "Surrogate Area" of Unicode are reserved for use
           by UTF-16, where they are used in pairs to encode code points with
           values greater than 0xFFFF. The code points that are encoded by
           UTF-16 pairs are available independently in the UTF-8 and UTF-32
           encodings. (In other words, the whole surrogate thing is a fudge
           for UTF-16 which unfortunately messes up UTF-8 and UTF-32.)
    
           Setting PCRE2_NO_UTF_CHECK at compile time does not disable the
           error that is given if an escape sequence for an invalid Unicode
           code point is encountered in the pattern. If you want to allow
           escape sequences such as \x{d800} (a surrogate code point) you can
           set the PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES extra option. However,
           this is possible only in UTF-8 and UTF-32 modes, because these
           values are not representable in UTF-16.
    
       **Errors in UTF-8 strings**
    
           The following negative error codes are given for invalid UTF-8
           strings:
    
             PCRE2_ERROR_UTF8_ERR1
             PCRE2_ERROR_UTF8_ERR2
             PCRE2_ERROR_UTF8_ERR3
             PCRE2_ERROR_UTF8_ERR4
             PCRE2_ERROR_UTF8_ERR5
    
           The string ends with a truncated UTF-8 character; the code
           specifies how many bytes are missing (1 to 5). Although RFC 3629
           restricts UTF-8 characters to be no longer than 4 bytes, the
           encoding scheme (originally defined by RFC 2279) allows for up to
           6 bytes, and this is checked first; hence the possibility of 4 or
           5 missing bytes.
    
             PCRE2_ERROR_UTF8_ERR6
             PCRE2_ERROR_UTF8_ERR7
             PCRE2_ERROR_UTF8_ERR8
             PCRE2_ERROR_UTF8_ERR9
             PCRE2_ERROR_UTF8_ERR10
    
           The two most significant bits of the 2nd, 3rd, 4th, 5th, or 6th
           byte of the character do not have the binary value 0b10 (that is,
           either the most significant bit is 0, or the next bit is 1).
    
             PCRE2_ERROR_UTF8_ERR11
             PCRE2_ERROR_UTF8_ERR12
    
           A character that is valid by the RFC 2279 rules is either 5 or 6
           bytes long; these code points are excluded by RFC 3629.
    
             PCRE2_ERROR_UTF8_ERR13
    
           A 4-byte character has a value greater than 0x10ffff; these code
           points are excluded by RFC 3629.
    
             PCRE2_ERROR_UTF8_ERR14
    
           A 3-byte character has a value in the range 0xd800 to 0xdfff; this
           range of code points are reserved by RFC 3629 for use with UTF-16,
           and so are excluded from UTF-8.
    
             PCRE2_ERROR_UTF8_ERR15
             PCRE2_ERROR_UTF8_ERR16
             PCRE2_ERROR_UTF8_ERR17
             PCRE2_ERROR_UTF8_ERR18
             PCRE2_ERROR_UTF8_ERR19
    
           A 2-, 3-, 4-, 5-, or 6-byte character is "overlong", that is, it
           codes for a value that can be represented by fewer bytes, which is
           invalid. For example, the two bytes 0xc0, 0xae give the value
           0x2e, whose correct coding uses just one byte.
    
             PCRE2_ERROR_UTF8_ERR20
    
           The two most significant bits of the first byte of a character
           have the binary value 0b10 (that is, the most significant bit is 1
           and the second is 0). Such a byte can only validly occur as the
           second or subsequent byte of a multi-byte character.
    
             PCRE2_ERROR_UTF8_ERR21
    
           The first byte of a character has the value 0xfe or 0xff. These
           values can never occur in a valid UTF-8 string.
    
       **Errors in UTF-16 strings**
    
           The following negative error codes are given for invalid UTF-16
           strings:
    
             PCRE2_ERROR_UTF16_ERR1  Missing low surrogate at end of string
             PCRE2_ERROR_UTF16_ERR2  Invalid low surrogate follows high
           surrogate
             PCRE2_ERROR_UTF16_ERR3  Isolated low surrogate
    
       **Errors in UTF-32 strings**
    
           The following negative error codes are given for invalid UTF-32
           strings:
    
             PCRE2_ERROR_UTF32_ERR1  Surrogate character (0xd800 to 0xdfff)
             PCRE2_ERROR_UTF32_ERR2  Code point is greater than 0x10ffff
    


## MATCHING IN INVALID UTF STRINGS



    
           You can run pattern matches on subject strings that may contain
           invalid UTF sequences if you call **pcre2_compile()** with the
           PCRE2_MATCH_INVALID_UTF option. This is supported by
           **pcre2_match()** , including JIT matching, but not by
           **pcre2_dfa_match()**. When PCRE2_MATCH_INVALID_UTF is set, it forces
           PCRE2_UTF to be set as well. Note, however, that the pattern
           itself must be a valid UTF string.
    
           If you do not set PCRE2_MATCH_INVALID_UTF when calling
           **pcre2_compile** , and you are not certain that your subject strings
           are valid UTF sequences, you should not make use of the JIT "fast
           path" function **pcre2_jit_match()** because it bypasses sanity
           checks, including the one for UTF validity. An invalid string may
           cause undefined behaviour, including looping, crashing, or giving
           the wrong answer.
    
           Setting PCRE2_MATCH_INVALID_UTF does not affect what
           **pcre2_compile()** generates, but if **pcre2_jit_compile()** is
           subsequently called, it does generate different code. If JIT is
           not used, the option affects the behaviour of the interpretive
           code in **pcre2_match()**. When PCRE2_MATCH_INVALID_UTF is set at
           compile time, PCRE2_NO_UTF_CHECK is ignored at match time.
    
           In this mode, an invalid code unit sequence in the subject never
           matches any pattern item. It does not match dot, it does not match
           \p{Any}, it does not even match negative items such as [^X]. A
           lookbehind assertion fails if it encounters an invalid sequence
           while moving the current point backwards. In other words, an
           invalid UTF code unit sequence acts as a barrier which no match
           can cross.
    
           You can also think of this as the subject being split up into
           fragments of valid UTF, delimited internally by invalid code unit
           sequences. The pattern is matched fragment by fragment. The result
           of a successful match, however, is given as code unit offsets in
           the entire subject string in the usual way. There are a few points
           to consider:
    
           The internal boundaries are not interpreted as the beginnings or
           ends of lines and so do not match circumflex or dollar characters
           in the pattern.
    
           If **pcre2_match()** is called with an offset that points to an
           invalid UTF-sequence, that sequence is skipped, and the match
           starts at the next valid UTF character, or the end of the subject.
    
           At internal fragment boundaries, \b and \B behave in the same way
           as at the beginning and end of the subject. For example, a
           sequence such as \bWORD\b would match an instance of WORD that is
           surrounded by invalid UTF code units.
    
           Using PCRE2_MATCH_INVALID_UTF, an application can run matches on
           arbitrary data, knowing that any matched strings that are returned
           are valid UTF. This can be useful when searching for UTF text in
           executable or other binary files.
    
           Note, however, that the 16-bit and 32-bit PCRE2 libraries process
           strings as sequences of uint16_t or uint32_t code points. They
           cannot find valid UTF sequences within an arbitrary string of
           bytes unless such sequences are suitably aligned.
    


## REVISION



    
           Last updated: 27 November 2024
           Copyright (c) 1997-2024 University of Cambridge.
    


* * *