Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
PCRE2SYNTAX(3)		   Library Functions Manual		PCRE2SYNTAX(3)

NAME
       PCRE2 - Perl-compatible regular expressions (revised API)

PCRE2 REGULAR EXPRESSION SYNTAX	SUMMARY

       The  full  syntax and semantics of the regular expression patterns that
       are supported by	PCRE2 are described in the pcre2pattern	documentation.
       This document contains a	quick-reference	summary	of the pattern	syntax
       followed	by the syntax of replacement strings in	substitution function.
       The full	description of the latter is in	the pcre2api documentation.

QUOTING

	 \x	    where x is non-alphanumeric	is a literal x
	 \Q...\E    treat enclosed characters as literal

       Note that white space inside \Q...\E is always treated as literal, even
       if PCRE2_EXTENDED is set, causing most other white space	to be ignored.
       Note  also  that	 PCRE2's handling of \Q...\E has some differences from
       Perl's. See the pcre2pattern documentation for details.

BRACED ITEMS

       With one	exception, wherever brace characters { and } are  required  to
       enclose	data for constructions such as \g{2} or	\k{name}, space	and/or
       horizontal tab characters that follow { or precede }  are  allowed  and
       are ignored. In the case	of quantifiers,	they may also appear before or
       after  the comma. The exception is \u{...} which	is not Perl-compatible
       and is recognized only when PCRE2_EXTRA_ALT_BSUX	is set.	This is	an EC-
       MAScript	compatibility feature, and follows ECMAScript's	behaviour.

ESCAPED	CHARACTERS

       This table applies to ASCII and Unicode environments.  An  unrecognized
       escape sequence causes an error.

	 \a	    alarm, that	is, the	BEL character (hex 07)
	 \cx	    "control-x", where x is a non-control ASCII	character
	 \e	    escape (hex	1B)
	 \f	    form feed (hex 0C)
	 \n	    newline (hex 0A)
	 \r	    carriage return (hex 0D)
	 \t	    tab	(hex 09)
	 \0dd	    character with octal code 0dd
	 \ddd	    character with octal code ddd, or backreference
	 \o{ddd..}  character with octal code ddd..
	 \N{U+hh..} character with Unicode code	point hh.. (Unicode mode only)
	 \xhh	    character with hex code hh
	 \x{hh..}   character with hex code hh..

       \N{U+hh..} is synonymous	with \x{hh..} but is not supported in environ-
       ments  that  use	 EBCDIC	code (mainly IBM mainframes). Note that	\N not
       followed	by an opening curly bracket has	a different meaning  (see  be-
       low).

       If PCRE2_ALT_BSUX or PCRE2_EXTRA_ALT_BSUX is set	("ALT_BSUX mode"), the
       following are also recognized:

	 \U	    the	character "U"
	 \uhhhh	    character with hex code hhhh
	 \u{hh..}   character with hex code hh.. but only for EXTRA_ALT_BSUX

       When  \x	 is not	followed by {, one or two hexadecimal digits are read,
       but in ALT_BSUX mode \x must be followed	by two hexadecimal  digits  to
       be  recognized  as a hexadecimal	escape;	otherwise it matches a literal
       "x".  Likewise, if \u (in ALT_BSUX mode)	is not followed	by four	 hexa-
       decimal	digits or (in EXTRA_ALT_BSUX mode) a sequence of hex digits in
       curly brackets, it matches a literal "u".

       Note that \0dd is always	an octal code. The treatment of	backslash fol-
       lowed by	a non-zero digit is complicated; for details see  the  section
       "Non-printing  characters" in the pcre2pattern documentation, where de-
       tails of	escape processing in EBCDIC environments are also given.

CHARACTER TYPES

	 .	    any	character except newline;
		      in dotall	mode, any character whatsoever
	 \C	    one	code unit, even	in UTF mode (best avoided)
	 \d	    a decimal digit
	 \D	    a character	that is	not a decimal digit
	 \h	    a horizontal white space character
	 \H	    a character	that is	not a horizontal white space character
	 \N	    a character	that is	not a newline
	 \p{xx}	    a character	with the xx property
	 \P{xx}	    a character	without	the xx property
	 \R	    a newline sequence
	 \s	    a white space character
	 \S	    a character	that is	not a white space character
	 \v	    a vertical white space character
	 \V	    a character	that is	not a vertical white space character
	 \w	    a "word" character
	 \W	    a "non-word" character
	 \X	    a Unicode extended grapheme	cluster

       \C is dangerous because it may leave the	current	matching point in  the
       middle of a UTF-8 or UTF-16 character. The application can lock out the
       use  of	\C  by	setting	the PCRE2_NEVER_BACKSLASH_C option. It is also
       possible	to build PCRE2 with the	use of \C permanently disabled.

       By default, \d, \s, and \w match	only ASCII characters, even  in	 UTF-8
       mode or in the 16-bit and 32-bit	libraries. However, if locale-specific
       matching	 is  happening,	 \s and	\w may also match characters with code
       points in the range 128-255. If the PCRE2_UCP option is set, the	behav-
       iour of these escape sequences is changed to use	Unicode	properties and
       they match many more characters,	but there  are	some  option  settings
       that  can  restrict individual sequences	to matching only ASCII charac-
       ters.

       Property	descriptions in	\p and \P are matched caselessly; hyphens, un-
       derscores, and ASCII white space	characters are ignored,	in  accordance
       with  Unicode's	"loose matching" rules.	For example, \p{Bidi_Class=al}
       is the same as \p{ bidi class = AL }.

GENERAL	CATEGORY PROPERTIES FOR	\p and \P

	 C	    Other
	 Cc	    Control
	 Cf	    Format
	 Cn	    Unassigned
	 Co	    Private use
	 Cs	    Surrogate

	 L	    Letter
	 Lc	    Cased letter, the union of Ll, Lu, and Lt
	 L&	    Synonym of Lc
	 Ll	    Lower case letter
	 Lm	    Modifier letter
	 Lo	    Other letter
	 Lt	    Title case letter
	 Lu	    Upper case letter

	 M	    Mark
	 Mc	    Spacing mark
	 Me	    Enclosing mark
	 Mn	    Non-spacing	mark

	 N	    Number
	 Nd	    Decimal number
	 Nl	    Letter number
	 No	    Other number

	 P	    Punctuation
	 Pc	    Connector punctuation
	 Pd	    Dash punctuation
	 Pe	    Close punctuation
	 Pf	    Final punctuation
	 Pi	    Initial punctuation
	 Po	    Other punctuation
	 Ps	    Open punctuation

	 S	    Symbol
	 Sc	    Currency symbol
	 Sk	    Modifier symbol
	 Sm	    Mathematical symbol
	 So	    Other symbol

	 Z	    Separator
	 Zl	    Line separator
	 Zp	    Paragraph separator
	 Zs	    Space separator

       From release 10.45, when	caseless matching is set, Ll, Lu, and  Lt  are
       all equivalent to Lc.

PCRE2 SPECIAL CATEGORY PROPERTIES FOR \p and \P

	 Xan	    Alphanumeric: union	of properties L	and N
	 Xps	    POSIX space: property Z or tab, NL,	VT, FF,	CR
	 Xsp	    Perl space:	property Z or tab, NL, VT, FF, CR
	 Xuc	    Universally-named character: one that can be
		      represented by a Universal Character Name
	 Xwd	    Perl word: property	Xan or underscore

       Perl and	POSIX space are	now the	same. Perl added VT to its space char-
       acter set at release 5.18.

BINARY PROPERTIES FOR \p AND \P

       Unicode	defines	 a  number  of	binary properties, that	is, properties
       whose only values are true or false. You	can obtain  a  list  of	 those
       that  are  recognized  by \p and	\P, along with their abbreviations, by
       running this command:

	 pcre2test -LP

SCRIPT MATCHING	WITH \p	AND \P

       Many script names and their 4-letter abbreviations  are	recognized  in
       \p{sc:...}  or  \p{scx:...} items, or on	their own with \p (and also \P
       of course). You can obtain a list of these scripts by running this com-
       mand:

	 pcre2test -LS

THE BIDI_CLASS PROPERTY	FOR \p AND \P

	 \p{Bidi_Class:<class>}	  matches a character with the given class
	 \p{BC:<class>}		  matches a character with the given class

       The recognized classes are:

	 AL	     Arabic letter
	 AN	     Arabic number
	 B	     paragraph separator
	 BN	     boundary neutral
	 CS	     common separator
	 EN	     European number
	 ES	     European separator
	 ET	     European terminator
	 FSI	     first strong isolate
	 L	     left-to-right
	 LRE	     left-to-right embedding
	 LRI	     left-to-right isolate
	 LRO	     left-to-right override
	 NSM	     non-spacing mark
	 ON	     other neutral
	 PDF	     pop directional format
	 PDI	     pop directional isolate
	 R	     right-to-left
	 RLE	     right-to-left embedding
	 RLI	     right-to-left isolate
	 RLO	     right-to-left override
	 S	     segment separator
	 WS	     white space

CHARACTER CLASSES

	 [...]	     positive character	class
	 [^...]	     negative character	class
	 [x-y]	     range (can	be used	for hex	characters)
	 [[:xxx:]]   positive POSIX named set
	 [[:^xxx:]]  negative POSIX named set

	 alnum	     alphanumeric
	 alpha	     alphabetic
	 ascii	     0-127
	 blank	     space or tab
	 cntrl	     control character
	 digit	     decimal digit
	 graph	     printing, excluding space
	 lower	     lower case	letter
	 print	     printing, including space
	 punct	     printing, excluding alphanumeric
	 space	     white space
	 upper	     upper case	letter
	 word	     same as \w
	 xdigit	     hexadecimal digit

       In PCRE2, POSIX character set names recognize only ASCII	characters  by
       default,	 but  some of them use Unicode properties if PCRE2_UCP is set.
       You can use \Q...\E inside a character class.

       When PCRE2_ALT_EXTENDED_CLASS is	set, UTS#18 extended character classes
       may be used, allowing nested character classes, combined	using set  op-
       erators.

	 [x&&[^y]]   UTS#18 extended character class

	 x||y	     set union (OR)
	 x&&y	     set intersection (AND)
	 x--y	     set difference (AND NOT)
	 x~~y	     set symmetric difference (XOR)

PERL EXTENDED CHARACTER	CLASSES

	 (?[...])		 Perl extended character class
	 (?[\p{Thai} & \p{Nd}])	 operators; whitespace ignored
	 (?[(x - y) & z])	 parentheses for grouping

	 (?[ [^3] & \p{Nd} ])	 [...] is a nested ordinary class
	 (?[ [:alpha:] - [z] ])	 POSIX set is allowed outside [...]
	 (?[  \d  -  [3]  ])	      backslash-escaped	set is allowed outside
       [...]
	 (?[ !\n & [:ascii:] ])	 backslash-escaped character is	 allowed  out-
       side [...]
			     all  other	 characters or ranges must be enclosed
       in [...]

	 x|y, x+y		 set union (OR)
	 x&y			 set intersection (AND)
	 x-y			 set difference	(AND NOT)
	 x^y			 set symmetric difference (XOR)
	 !x			 set complement	(NOT)

       Inside a	Perl extended character	class, [...] switches mode to  be  in-
       terpreted  as  an  ordinary character class. Outside of a nested	[...],
       the only	items permitted	are backslash-escapes, POSIX sets,  operators,
       and  parentheses. Inside	a nested ordinary class, ^ has its usual mean-
       ing (inverts the	class when used	as the first character); outside of  a
       nested class, ^ is the XOR operator.

QUANTIFIERS

	 ?	     0 or 1, greedy
	 ?+	     0 or 1, possessive
	 ??	     0 or 1, lazy
	 *	     0 or more,	greedy
	 *+	     0 or more,	possessive
	 *?	     0 or more,	lazy
	 +	     1 or more,	greedy
	 ++	     1 or more,	possessive
	 +?	     1 or more,	lazy
	 {n}	     exactly n
	 {n,m}	     at	least n, no more than m, greedy
	 {n,m}+	     at	least n, no more than m, possessive
	 {n,m}?	     at	least n, no more than m, lazy
	 {n,}	     n or more,	greedy
	 {n,}+	     n or more,	possessive
	 {n,}?	     n or more,	lazy
	 {,m}	     zero up to	m, greedy
	 {,m}+	     zero up to	m, possessive
	 {,m}?	     zero up to	m, lazy

ANCHORS	AND SIMPLE ASSERTIONS

	 \b	     word boundary
	 \B	     not a word	boundary
	 ^	     start of subject
		       also after an internal newline in multiline mode
		       (after any newline if PCRE2_ALT_CIRCUMFLEX is set)
	 \A	     start of subject
	 $	     end of subject
		       also before newline at end of subject
		       also before internal newline in multiline mode
	 \Z	     end of subject
		       also before newline at end of subject
	 \z	     end of subject
	 \G	     first matching position in	subject

REPORTED MATCH POINT SETTING

	 \K	     set reported start	of match

       From  release 10.38 \K is not permitted by default in lookaround	asser-
       tions, for compatibility	with Perl.  However,  if  the  PCRE2_EXTRA_AL-
       LOW_LOOKAROUND_BSK option is set, the previous behaviour	is re-enabled.
       When this option	is set,	\K is honoured in positive assertions, but ig-
       nored in	negative ones.

ALTERNATION

	 expr|expr|expr...

CAPTURING

	 (...)		 capture group
	 (?<name>...)	 named capture group (Perl)
	 (?'name'...)	 named capture group (Perl)
	 (?P<name>...)	 named capture group (Python)
	 (?:...)	 non-capture group
	 (?|...)	 non-capture group; reset group	numbers	for
			  capture groups in each alternative

       In  non-UTF  modes, names may contain underscores and ASCII letters and
       digits; in UTF modes, any Unicode letters and  Unicode  decimal	digits
       are permitted. In both cases, a name must not start with	a digit.

ATOMIC GROUPS

	 (?>...)	 atomic	non-capture group
	 (*atomic:...)	 atomic	non-capture group

COMMENT

	 (?#....)	 comment (not nestable)

OPTION SETTING
       Changes	of these options within	a group	are automatically cancelled at
       the end of the group.

	 (?a)		 all ASCII options
	 (?aD)		 restrict \d to	ASCII in UCP mode
	 (?aS)		 restrict \s to	ASCII in UCP mode
	 (?aW)		 restrict \w to	ASCII in UCP mode
	 (?aP)		 restrict all POSIX classes to ASCII in	UCP mode
	 (?aT)		 restrict POSIX	digit classes to ASCII in UCP mode
	 (?i)		 caseless
	 (?J)		 allow duplicate named groups
	 (?m)		 multiline
	 (?n)		 no auto capture
	 (?r)		 restrict caseless to either ASCII or non-ASCII
	 (?s)		 single	line (dotall)
	 (?U)		 default ungreedy (lazy)
	 (?x)		 ignore	white space except in classes or \Q...\E
	 (?xx)		 as (?x) but also ignore space and tab in classes
	 (?-...)	 unset the given option(s)
	 (?^)		 unset imnrsx options

       (?aP) implies (?aT) as well, though this	has no additional effect. How-
       ever, it	means that (?-aP) also implies (?-aT) and disables  all	 ASCII
       restrictions for	POSIX classes.

       Unsetting  x or xx unsets both. Several options may be set at once, and
       a mixture of setting and	unsetting such as (?i-x) is allowed, but there
       may be only one hyphen. Setting (but no unsetting) is allowed after (?^
       for example (?^in). An option setting may appear	at the start of	a non-
       capture group, for example (?i:...).

       The following are recognized only at the	very start of a	pattern	or af-
       ter one of the newline or \R sequences or options with similar  syntax.
       More  than  one of them may appear. For the first three,	d is a decimal
       number.

	 (*LIMIT_DEPTH=d)     set the backtracking limit to d
	 (*LIMIT_HEAP=d)      set the heap size	limit to d * 1024 bytes
	 (*LIMIT_MATCH=d)     set the match limit to d
	 (*CASELESS_RESTRICT) set PCRE2_EXTRA_CASELESS_RESTRICT	when matching
	 (*NOTEMPTY)	      set PCRE2_NOTEMPTY when matching
	 (*NOTEMPTY_ATSTART)  set PCRE2_NOTEMPTY_ATSTART when matching
	 (*NO_AUTO_POSSESS)   no auto-possessification (PCRE2_NO_AUTO_POSSESS)
	 (*NO_DOTSTAR_ANCHOR) no .* anchoring (PCRE2_NO_DOTSTAR_ANCHOR)
	 (*NO_JIT)	      disable JIT optimization
	 (*NO_START_OPT)      no start-match optimization  (PCRE2_NO_START_OP-
       TIMIZE)
	 (*TURKISH_CASING)    set PCRE2_EXTRA_TURKISH_CASING when matching
	 (*UTF)		      set appropriate UTF mode for the library in use
	 (*UCP)		       set  PCRE2_UCP  (use  Unicode properties	for \d
       etc)

       Note that LIMIT_DEPTH, LIMIT_HEAP, and LIMIT_MATCH can only reduce  the
       value   of   the	  limits   set	by  the	 caller	 of  pcre2_match()  or
       pcre2_dfa_match(), not increase them. LIMIT_RECURSION  is  an  obsolete
       synonym for LIMIT_DEPTH.	The application	can lock out the use of	(*UTF)
       and  (*UCP)  by setting the PCRE2_NEVER_UTF or PCRE2_NEVER_UCP options,
       respectively, at	compile	time.

NEWLINE	CONVENTION

       These are recognized only at the	very start of the pattern or after op-
       tion settings with a similar syntax.

	 (*CR)		 carriage return only
	 (*LF)		 linefeed only
	 (*CRLF)	 carriage return followed by linefeed
	 (*ANYCRLF)	 all three of the above
	 (*ANY)		 any Unicode newline sequence
	 (*NUL)		 the NUL character (binary zero)

WHAT \R	MATCHES

       These are recognized only at the	very start of the pattern or after op-
       tion setting with a similar syntax.

	 (*BSR_ANYCRLF)	 CR, LF, or CRLF
	 (*BSR_UNICODE)	 any Unicode newline sequence

LOOKAHEAD AND LOOKBEHIND ASSERTIONS

	 (?=...)		     )
	 (*pla:...)		     ) positive	lookahead
	 (*positive_lookahead:...)   )

	 (?!...)		     )
	 (*nla:...)		     ) negative	lookahead
	 (*negative_lookahead:...)   )

	 (?<=...)		     )
	 (*plb:...)		     ) positive	lookbehind
	 (*positive_lookbehind:...)  )

	 (?<!...)		     )
	 (*nlb:...)		     ) negative	lookbehind
	 (*negative_lookbehind:...)  )

       Each top-level branch of	a lookbehind must have a limit for the	number
       of  characters it matches. If any branch	can match a variable number of
       characters, the maximum for each	branch is limited to a	value  set  by
       the  caller  of	pcre2_compile()	 or defaulted. The default is set when
       PCRE2 is	built (ultimate	default	255). If every branch matches a	 fixed
       number of characters, the limit for each	branch is 65535	characters.

NON-ATOMIC LOOKAROUND ASSERTIONS

       These assertions	are specific to	PCRE2 and are not Perl-compatible.

	 (?*...)				)
	 (*napla:...)				) synonyms
	 (*non_atomic_positive_lookahead:...)	)

	 (?<*...)				)
	 (*naplb:...)				) synonyms
	 (*non_atomic_positive_lookbehind:...)	)

SUBSTRING SCAN ASSERTION
       This feature is not Perl-compatible.

	 (*scan_substring:(grouplist)...)  scan	captured substring
	 (*scs:(grouplist)...)		   scan	captured substring

       The  comma-separated  list  may identify	groups in any of the following
       ways:

	 n	 absolute reference
	 +n	 relative reference
	 -n	 relative reference
	 <name>	 name
	 'name'	 name

SCRIPT RUNS

	 (*script_run:...)	     ) script run, can be backtracked into
	 (*sr:...)		     )

	 (*atomic_script_run:...)    ) atomic script run
	 (*asr:...)		     )

BACKREFERENCES

	 \n		 reference by number (can be ambiguous)
	 \gn		 reference by number
	 \g{n}		 reference by number
	 \g+n		 relative reference by number (PCRE2 extension)
	 \g-n		 relative reference by number
	 \g{+n}		 relative reference by number (PCRE2 extension)
	 \g{-n}		 relative reference by number
	 \k<name>	 reference by name (Perl)
	 \k'name'	 reference by name (Perl)
	 \g{name}	 reference by name (Perl)
	 \k{name}	 reference by name (.NET)
	 (?P=name)	 reference by name (Python)

SUBROUTINE REFERENCES (POSSIBLY	RECURSIVE)

	 (?R)		 recurse whole pattern
	 (?n)		 call subroutine by absolute number
	 (?+n)		 call subroutine by relative number
	 (?-n)		 call subroutine by relative number
	 (?&name)	 call subroutine by name (Perl)
	 (?P>name)	 call subroutine by name (Python)
	 \g<name>	 call subroutine by name (Oniguruma)
	 \g'name'	 call subroutine by name (Oniguruma)
	 \g<n>		 call subroutine by absolute number (Oniguruma)
	 \g'n'		 call subroutine by absolute number (Oniguruma)
	 \g<+n>		 call subroutine by relative number (PCRE2 extension)
	 \g'+n'		 call subroutine by relative number (PCRE2 extension)
	 \g<-n>		 call subroutine by relative number (PCRE2 extension)
	 \g'-n'		 call subroutine by relative number (PCRE2 extension)

CONDITIONAL PATTERNS

	 (?(condition)yes-pattern)
	 (?(condition)yes-pattern|no-pattern)

	 (?(n)		     absolute reference	condition
	 (?(+n)		     relative reference	condition (PCRE2 extension)
	 (?(-n)		     relative reference	condition (PCRE2 extension)
	 (?(<name>)	     named reference condition (Perl)
	 (?('name')	     named reference condition (Perl)
	 (?(name)	     named reference condition (PCRE2, deprecated)
	 (?(R)		     overall recursion condition
	 (?(Rn)		     specific numbered group recursion condition
	 (?(R&name)	     specific named group recursion condition
	 (?(DEFINE)	     define groups for reference
	 (?(VERSION[>]=n.m)  test PCRE2	version
	 (?(assert)	     assertion condition

       Note the	ambiguity of (?(R) and (?(Rn) which might be  named  reference
       conditions  or  recursion  tests.  Such a condition is interpreted as a
       reference condition if the relevant named group exists.

BACKTRACKING CONTROL

       All backtracking	control	verbs may be in	 the  form  (*VERB:NAME).  For
       (*MARK)	the  name is mandatory,	for the	others it is optional. (*SKIP)
       changes its behaviour if	:NAME is present. The others just set  a  name
       for passing back	to the caller, but this	is not a name that (*SKIP) can
       see. The	following act immediately they are reached:

	 (*ACCEPT)	 force successful match
	 (*FAIL)	 force backtrack; synonym (*F)
	 (*MARK:NAME)	 set name to be	passed back; synonym (*:NAME)

       The  following  act only	when a subsequent match	failure	causes a back-
       track to	reach them. They all force a match failure, but	they differ in
       what happens afterwards.	Those that advance the start-of-match point do
       so only if the pattern is not anchored.

	 (*COMMIT)	 overall failure, no advance of	starting point
	 (*PRUNE)	 advance to next starting character
	 (*SKIP)	 advance to current matching position
	 (*SKIP:NAME)	 advance to position corresponding to an earlier
			 (*MARK:NAME); if not found, the (*SKIP) is ignored
	 (*THEN)	 local failure,	backtrack to next alternation

       The effect of one of these verbs	in a group called as a	subroutine  is
       confined	to the subroutine call.

CALLOUTS

	 (?C)		 callout (assumed number 0)
	 (?Cn)		 callout with numerical	data n
	 (?C"text")	 callout with string data

       The allowed string delimiters are ` ' " ^ % # $ (which are the same for
       the  start  and the end), and the starting delimiter { matched with the
       ending delimiter	}. To encode the ending	delimiter within  the  string,
       double it.

REPLACEMENT STRINGS

       If the PCRE2_SUBSTITUTE_LITERAL option is set, a	replacement string for
       pcre2_substitute()  is not interpreted. Otherwise, by default, the only
       special character is the	dollar	character  in  one  of	the  following
       forms:

	 $$		     insert a dollar character
	 $n or ${n}	     insert the	contents of group n
	 $<name>	     insert the	contents of named group
	 $0 or $&	     insert the	entire matched substring
	 $`		     insert the	substring that precedes	the match
	 $'		     insert the	substring that follows the match
	 $_		     insert the	entire input string
	 $*MARK	or ${*MARK}  insert a control verb name

       For  ${n}, n can	be a name or a number. If PCRE2_SUBSTITUTE_EXTENDED is
       set, there is additional	interpretation:

       1. Backslash is an escape character, and	the forms  described  in  "ES-
       CAPED CHARACTERS" above are recognized. Also:

	 \Q...\E   can be used to suppress interpretation
	 \l	   force the next character to lower case
	 \u	   force the next character to upper case
	 \L	   force subsequent characters to lower	case
	 \U	   force subsequent characters to upper	case
	 \u\L	   force next character	to upper case, then all	lower
	 \l\U	   force next character	to lower case, then all	upper
	 \E	   end \L or \U	case forcing
	 \b	    backspace  character  (note: as in character class in pat-
       tern)
	 \v	   vertical tab	character (note: not the same as in a pattern)

       2. The Python form \g<n>, where the angle brackets are part of the syn-
       tax and n is either a group name	or a number, is	recognized as  an  al-
       ternative way of	inserting the contents of a group, for example \g<3>.

       3. Capture substitution supports	the following additional forms:

	 ${n:-string}		  default for unset group
	 ${n:+string1:string2}	  values for set/unset group

       The substitution	strings	themselves are expanded. Backslash can be used
       to escape colons	and closing curly brackets.

SEE ALSO

       pcre2pattern(3),	   pcre2api(3),	  pcre2callout(3),   pcre2matching(3),
       pcre2(3).

AUTHOR

       Philip Hazel
       Retired from University Computing Service
       Cambridge, England.

REVISION

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

PCRE2 10.45		       27 November 2024			PCRE2SYNTAX(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=pcre2syntax&sektion=3&manpath=FreeBSD+Ports+14.3.quarterly>

home | help