Annotation of embedaddon/php/ext/ereg/regex/regex.7, revision 1.1
1.1 ! misho 1: .TH REGEX 7 "7 Feb 1994"
! 2: .BY "Henry Spencer"
! 3: .SH NAME
! 4: regex \- POSIX 1003.2 regular expressions
! 5: .SH DESCRIPTION
! 6: Regular expressions (``RE''s),
! 7: as defined in POSIX 1003.2, come in two forms:
! 8: modern REs (roughly those of
! 9: .IR egrep ;
! 10: 1003.2 calls these ``extended'' REs)
! 11: and obsolete REs (roughly those of
! 12: .IR ed ;
! 13: 1003.2 ``basic'' REs).
! 14: Obsolete REs mostly exist for backward compatibility in some old programs;
! 15: they will be discussed at the end.
! 16: 1003.2 leaves some aspects of RE syntax and semantics open;
! 17: `\(dg' marks decisions on these aspects that
! 18: may not be fully portable to other 1003.2 implementations.
! 19: .PP
! 20: A (modern) RE is one\(dg or more non-empty\(dg \fIbranches\fR,
! 21: separated by `|'.
! 22: It matches anything that matches one of the branches.
! 23: .PP
! 24: A branch is one\(dg or more \fIpieces\fR, concatenated.
! 25: It matches a match for the first, followed by a match for the second, etc.
! 26: .PP
! 27: A piece is an \fIatom\fR possibly followed
! 28: by a single\(dg `*', `+', `?', or \fIbound\fR.
! 29: An atom followed by `*' matches a sequence of 0 or more matches of the atom.
! 30: An atom followed by `+' matches a sequence of 1 or more matches of the atom.
! 31: An atom followed by `?' matches a sequence of 0 or 1 matches of the atom.
! 32: .PP
! 33: A \fIbound\fR is `{' followed by an unsigned decimal integer,
! 34: possibly followed by `,'
! 35: possibly followed by another unsigned decimal integer,
! 36: always followed by `}'.
! 37: The integers must lie between 0 and RE_DUP_MAX (255\(dg) inclusive,
! 38: and if there are two of them, the first may not exceed the second.
! 39: An atom followed by a bound containing one integer \fIi\fR
! 40: and no comma matches
! 41: a sequence of exactly \fIi\fR matches of the atom.
! 42: An atom followed by a bound
! 43: containing one integer \fIi\fR and a comma matches
! 44: a sequence of \fIi\fR or more matches of the atom.
! 45: An atom followed by a bound
! 46: containing two integers \fIi\fR and \fIj\fR matches
! 47: a sequence of \fIi\fR through \fIj\fR (inclusive) matches of the atom.
! 48: .PP
! 49: An atom is a regular expression enclosed in `()' (matching a match for the
! 50: regular expression),
! 51: an empty set of `()' (matching the null string)\(dg,
! 52: a \fIbracket expression\fR (see below), `.'
! 53: (matching any single character), `^' (matching the null string at the
! 54: beginning of a line), `$' (matching the null string at the
! 55: end of a line), a `\e' followed by one of the characters
! 56: `^.[$()|*+?{\e'
! 57: (matching that character taken as an ordinary character),
! 58: a `\e' followed by any other character\(dg
! 59: (matching that character taken as an ordinary character,
! 60: as if the `\e' had not been present\(dg),
! 61: or a single character with no other significance (matching that character).
! 62: A `{' followed by a character other than a digit is an ordinary
! 63: character, not the beginning of a bound\(dg.
! 64: It is illegal to end an RE with `\e'.
! 65: .PP
! 66: A \fIbracket expression\fR is a list of characters enclosed in `[]'.
! 67: It normally matches any single character from the list (but see below).
! 68: If the list begins with `^',
! 69: it matches any single character
! 70: (but see below) \fInot\fR from the rest of the list.
! 71: If two characters in the list are separated by `\-', this is shorthand
! 72: for the full \fIrange\fR of characters between those two (inclusive) in the
! 73: collating sequence,
! 74: e.g. `[0-9]' in ASCII matches any decimal digit.
! 75: It is illegal\(dg for two ranges to share an
! 76: endpoint, e.g. `a-c-e'.
! 77: Ranges are very collating-sequence-dependent,
! 78: and portable programs should avoid relying on them.
! 79: .PP
! 80: To include a literal `]' in the list, make it the first character
! 81: (following a possible `^').
! 82: To include a literal `\-', make it the first or last character,
! 83: or the second endpoint of a range.
! 84: To use a literal `\-' as the first endpoint of a range,
! 85: enclose it in `[.' and `.]' to make it a collating element (see below).
! 86: With the exception of these and some combinations using `[' (see next
! 87: paragraphs), all other special characters, including `\e', lose their
! 88: special significance within a bracket expression.
! 89: .PP
! 90: Within a bracket expression, a collating element (a character,
! 91: a multi-character sequence that collates as if it were a single character,
! 92: or a collating-sequence name for either)
! 93: enclosed in `[.' and `.]' stands for the
! 94: sequence of characters of that collating element.
! 95: The sequence is a single element of the bracket expression's list.
! 96: A bracket expression containing a multi-character collating element
! 97: can thus match more than one character,
! 98: e.g. if the collating sequence includes a `ch' collating element,
! 99: then the RE `[[.ch.]]*c' matches the first five characters
! 100: of `chchcc'.
! 101: .PP
! 102: Within a bracket expression, a collating element enclosed in `[=' and
! 103: `=]' is an equivalence class, standing for the sequences of characters
! 104: of all collating elements equivalent to that one, including itself.
! 105: (If there are no other equivalent collating elements,
! 106: the treatment is as if the enclosing delimiters were `[.' and `.]'.)
! 107: For example, if o and \o'o^' are the members of an equivalence class,
! 108: then `[[=o=]]', `[[=\o'o^'=]]', and `[o\o'o^']' are all synonymous.
! 109: An equivalence class may not\(dg be an endpoint
! 110: of a range.
! 111: .PP
! 112: Within a bracket expression, the name of a \fIcharacter class\fR enclosed
! 113: in `[:' and `:]' stands for the list of all characters belonging to that
! 114: class.
! 115: Standard character class names are:
! 116: .PP
! 117: .RS
! 118: .nf
! 119: .ta 3c 6c 9c
! 120: alnum digit punct
! 121: alpha graph space
! 122: blank lower upper
! 123: cntrl print xdigit
! 124: .fi
! 125: .RE
! 126: .PP
! 127: These stand for the character classes defined in
! 128: .IR ctype (3).
! 129: A locale may provide others.
! 130: A character class may not be used as an endpoint of a range.
! 131: .PP
! 132: There are two special cases\(dg of bracket expressions:
! 133: the bracket expressions `[[:<:]]' and `[[:>:]]' match the null string at
! 134: the beginning and end of a word respectively.
! 135: A word is defined as a sequence of
! 136: word characters
! 137: which is neither preceded nor followed by
! 138: word characters.
! 139: A word character is an
! 140: .I alnum
! 141: character (as defined by
! 142: .IR ctype (3))
! 143: or an underscore.
! 144: This is an extension,
! 145: compatible with but not specified by POSIX 1003.2,
! 146: and should be used with
! 147: caution in software intended to be portable to other systems.
! 148: .PP
! 149: In the event that an RE could match more than one substring of a given
! 150: string,
! 151: the RE matches the one starting earliest in the string.
! 152: If the RE could match more than one substring starting at that point,
! 153: it matches the longest.
! 154: Subexpressions also match the longest possible substrings, subject to
! 155: the constraint that the whole match be as long as possible,
! 156: with subexpressions starting earlier in the RE taking priority over
! 157: ones starting later.
! 158: Note that higher-level subexpressions thus take priority over
! 159: their lower-level component subexpressions.
! 160: .PP
! 161: Match lengths are measured in characters, not collating elements.
! 162: A null string is considered longer than no match at all.
! 163: For example,
! 164: `bb*' matches the three middle characters of `abbbc',
! 165: `(wee|week)(knights|nights)' matches all ten characters of `weeknights',
! 166: when `(.*).*' is matched against `abc' the parenthesized subexpression
! 167: matches all three characters, and
! 168: when `(a*)*' is matched against `bc' both the whole RE and the parenthesized
! 169: subexpression match the null string.
! 170: .PP
! 171: If case-independent matching is specified,
! 172: the effect is much as if all case distinctions had vanished from the
! 173: alphabet.
! 174: When an alphabetic that exists in multiple cases appears as an
! 175: ordinary character outside a bracket expression, it is effectively
! 176: transformed into a bracket expression containing both cases,
! 177: e.g. `x' becomes `[xX]'.
! 178: When it appears inside a bracket expression, all case counterparts
! 179: of it are added to the bracket expression, so that (e.g.) `[x]'
! 180: becomes `[xX]' and `[^x]' becomes `[^xX]'.
! 181: .PP
! 182: No particular limit is imposed on the length of REs\(dg.
! 183: Programs intended to be portable should not employ REs longer
! 184: than 256 bytes,
! 185: as an implementation can refuse to accept such REs and remain
! 186: POSIX-compliant.
! 187: .PP
! 188: Obsolete (``basic'') regular expressions differ in several respects.
! 189: `|', `+', and `?' are ordinary characters and there is no equivalent
! 190: for their functionality.
! 191: The delimiters for bounds are `\e{' and `\e}',
! 192: with `{' and `}' by themselves ordinary characters.
! 193: The parentheses for nested subexpressions are `\e(' and `\e)',
! 194: with `(' and `)' by themselves ordinary characters.
! 195: `^' is an ordinary character except at the beginning of the
! 196: RE or\(dg the beginning of a parenthesized subexpression,
! 197: `$' is an ordinary character except at the end of the
! 198: RE or\(dg the end of a parenthesized subexpression,
! 199: and `*' is an ordinary character if it appears at the beginning of the
! 200: RE or the beginning of a parenthesized subexpression
! 201: (after a possible leading `^').
! 202: Finally, there is one new type of atom, a \fIback reference\fR:
! 203: `\e' followed by a non-zero decimal digit \fId\fR
! 204: matches the same sequence of characters
! 205: matched by the \fId\fRth parenthesized subexpression
! 206: (numbering subexpressions by the positions of their opening parentheses,
! 207: left to right),
! 208: so that (e.g.) `\e([bc]\e)\e1' matches `bb' or `cc' but not `bc'.
! 209: .SH SEE ALSO
! 210: regex(3)
! 211: .PP
! 212: POSIX 1003.2, section 2.8 (Regular Expression Notation).
! 213: .SH BUGS
! 214: Having two kinds of REs is a botch.
! 215: .PP
! 216: The current 1003.2 spec says that `)' is an ordinary character in
! 217: the absence of an unmatched `(';
! 218: this was an unintentional result of a wording error,
! 219: and change is likely.
! 220: Avoid relying on it.
! 221: .PP
! 222: Back references are a dreadful botch,
! 223: posing major problems for efficient implementations.
! 224: They are also somewhat vaguely defined
! 225: (does
! 226: `a\e(\e(b\e)*\e2\e)*d' match `abbbd'?).
! 227: Avoid using them.
! 228: .PP
! 229: 1003.2's specification of case-independent matching is vague.
! 230: The ``one case implies all cases'' definition given above
! 231: is current consensus among implementors as to the right interpretation.
! 232: .PP
! 233: The syntax for word boundaries is incredibly ugly.
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to regex.7 CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / ereg / regex