Provided by: libpcre2-dev_10.34-7_amd64 bug

NAME

       PCRE - 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 text strings in UTF-8, UTF-16,
       or 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 limited to the general category properties such as  Lu  for  an  upper  case
       letter or Nd for a decimal number, the Unicode script names such as Arabic or Han, and the
       derived properties Any and L&. Full lists are given in the  pcre2pattern  and  pcre2syntax
       documentation.  Only  the  short  names  for  properties are supported. For example, \p{L}
       matches a letter. Its Perl 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. There are
       more details in the section on generic character types in the pcre2pattern documentation.

       Similarly,  characters  that  match  the  POSIX named character classes are all low-valued
       characters, unless the PCRE2_UCP option is set.

       However, the special horizontal and vertical white space matching escapes (\h, \H, \v, and
       \V) do match all the appropriate Unicode characters, whether or not PCRE2_UCP is set.

CASE-EQUIVALENCE IN UTF MODE


       Case-insensitive  matching  in  UTF  mode  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.

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.

       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.

AUTHOR


       Philip Hazel
       University Computing Service
       Cambridge, England.

REVISION


       Last updated: 24 May 2019
       Copyright (c) 1997-2019 University of Cambridge.