File: re_format.doc

package info (click to toggle)
alpine 1.10%2Bdfsg-3
  • links: PTS
  • area: main
  • in suites: lenny
  • size: 26,036 kB
  • ctags: 21,767
  • sloc: ansic: 308,814; tcl: 19,749; sh: 9,822; makefile: 1,926; perl: 189; exp: 69; csh: 48; sed: 16
file content (264 lines) | stat: -rw-r--r-- 11,281 bytes parent folder | download | duplicates (11)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264



RE_FORMAT(7)      Device and Network Interfaces      RE_FORMAT(7)



NAME
     re_format - POSIX 1003.2 regular expressions

DESCRIPTION
     Regular expressions (``RE''s), as defined in  POSIX  1003.2,
     come  in  two  forms:   modern  REs (roughly those of egrep;
     1003.2  calls  these  ``extended''  REs)  and  obsolete  REs
     (roughly  those  of ed; 1003.2 ``basic'' REs).  Obsolete REs
     mostly exist for backward compatibility  in  some  old  pro-
     grams;  they  will  be  discussed at the end.  1003.2 leaves
     some aspects of RE syntax and semantics  open;  ` - '  marks
     decisions on these aspects that may not be fully portable to
     other 1003.2 implementations.

     A (modern) RE is one- or more non-empty- branches, separated
     by  `|'.   It  matches  anything  that  matches  one  of the
     branches.

     A branch is one- or more pieces, concatenated.  It matches a
     match  for  the  first,  followed by a match for the second,
     etc.

     A piece is an atom possibly followed by a single- `*',  `+',
     `?',  or  bound.  An atom followed by `*' matches a sequence
     of 0 or more matches of the atom.  An atom followed  by  `+'
     matches  a  sequence  of  1 or more matches of the atom.  An
     atom followed by `?' matches a sequence of 0 or 1 matches of
     the atom.

     A bound is `{' followed by an unsigned decimal integer, pos-
     sibly  followed by `,' possibly followed by another unsigned
     decimal integer, always followed by `}'.  The integers  must
     lie  between 0 and RE_DUP_MAX (255-) inclusive, and if there
     are two of them, the first may not exceed  the  second.   An
     atom  followed  by  a  bound containing one integer i and no
     comma matches a sequence of exactly i matches of  the  atom.
     An  atom  followed by a bound containing one integer i and a
     comma matches a sequence of i or more matches of  the  atom.
     An  atom followed by a bound containing two integers i and j
     matches a sequence of i through j (inclusive) matches of the
     atom.

     An atom is a regular expression enclosed in `()' (matching a
     match  for  the  regular  expression),  an empty set of `()'
     (matching the null string) - ,  a  bracket  expression  (see
     below),  `.'  (matching any single character), `^' (matching
     the null string at the beginning of a line),  `$'  (matching
     the null string at the end of a line), a `\' followed by one
     of the characters `^.[$()|*+?{\'  (matching  that  character
     taken as an ordinary character), a `\' followed by any other
     character- (matching that character  taken  as  an  ordinary
     character, as if the `\' had not been present-), or a single



SunOS 5.5          Last change: March 20, 1994                  1






RE_FORMAT(7)      Device and Network Interfaces      RE_FORMAT(7)



     character with no other significance (matching that  charac-
     ter).   A  `{' followed by a character other than a digit is
     an ordinary character, not the beginning of a bound-.  It is
     illegal to end an RE with `\'.

     A bracket expression is a list  of  characters  enclosed  in
     `[]'.   It  normally  matches  any single character from the
     list (but see below).  If  the  list  begins  with  `^',  it
     matches  any  single  character (but see below) not from the
     rest of the  list.   If  two  characters  in  the  list  are
     separated  by  ` -', this is shorthand for the full range of
     characters between those two (inclusive)  in  the  collating
     sequence,  e.g.  `[0-9]' in ASCII matches any decimal digit.
     It is illegal- for two ranges to  share  an  endpoint,  e.g.
     `a-c-e'.   Ranges are very collating-sequence-dependent, and
     portable programs should avoid relying on them.

     To include a literal `]' in the  list,  make  it  the  first
     character  (following a possible `^').  To include a literal
     `-', make it the first or last character, or the second end-
     point  of  a  range.  To use a literal `-' as the first end-
     point of a range, enclose it in `[.' and `.]' to make  it  a
     collating  element (see below).  With the exception of these
     and some combinations using `[' (see next  paragraphs),  all
     other  special characters, including `\', lose their special
     significance within a bracket expression.

     Within a bracket expression, a collating element (a  charac-
     ter,  a multi-character sequence that collates as if it were
     a single character, or a collating-sequence name for either)
     enclosed in `[.' and `.]' stands for the sequence of charac-
     ters of that collating element.  The sequence  is  a  single
     element of the bracket expression's list.  A bracket expres-
     sion containing a multi-character collating element can thus
     match  more  than  one  character,  e.g.  if  the  collating
     sequence includes a `ch'  collating  element,  then  the  RE
     `[[.ch.]]*c' matches the first five characters of `chchcc'.

     Within a bracket expression, a collating element enclosed in
     `[='  and  `=]'  is  an  equivalence class, standing for the
     sequences of characters of all collating elements equivalent
     to  that  one,  including  itself.   (If  there are no other
     equivalent collating elements, the treatment is  as  if  the
     enclosing delimiters were `[.' and `.]'.)  For example, if o
     and  ^  are  the  members  of  an  equivalence  class,  then
     `[[=o=]]',  `[[=^=]]',  and  `[o^]'  are all synonymous.  An
     equivalence class may not- be an endpoint of a range.

     Within a bracket expression, the name of a  character  class
     enclosed in `[:' and `:]' stands for the list of all charac-
     ters belonging to  that  class.   Standard  character  class
     names are:



SunOS 5.5          Last change: March 20, 1994                  2






RE_FORMAT(7)      Device and Network Interfaces      RE_FORMAT(7)



          alnum       digit       punct
          alpha       graph       space
          blank       lower       upper
          cntrl       print       xdigit

     These stand for the character classes defined  in  ctype(3).
     A  locale  may provide others.  A character class may not be
     used as an endpoint of a range.

     There are two special cases- of  bracket  expressions:   the
     bracket  expressions  `[[:<:]]' and `[[:>:]]' match the null
     string at the beginning and end of a word  respectively.   A
     word  is  defined  as a sequence of word characters which is
     neither preceded nor followed by word  characters.   A  word
     character  is an alnum character (as defined by ctype(3)) or
     an underscore.  This is an extension,  compatible  with  but
     not  specified by POSIX 1003.2, and should be used with cau-
     tion in software intended to be portable to other systems.

     In the event that an RE could match more than one  substring
     of  a given string, the RE matches the one starting earliest
     in the string.  If the RE could match  more  than  one  sub-
     string  starting  at  that  point,  it  matches the longest.
     Subexpressions also match the longest  possible  substrings,
     subject to the constraint that the whole match be as long as
     possible, with subexpressions starting  earlier  in  the  RE
     taking   priority  over  ones  starting  later.   Note  that
     higher-level subexpressions thus take  priority  over  their
     lower-level component subexpressions.

     Match lengths are measured in characters, not collating ele-
     ments.   A null string is considered longer than no match at
     all.  For example, `bb*' matches the three middle characters
     of  `abbbc',  `(wee|week)(knights|nights)'  matches  all ten
     characters of `weeknights', when `(.*).*' is matched against
     `abc'  the  parenthesized  subexpression  matches  all three
     characters, and when `(a*)*' is matched  against  `bc'  both
     the  whole  RE and the parenthesized subexpression match the
     null string.

     If case-independent matching is  specified,  the  effect  is
     much  as  if  all  case  distinctions  had vanished from the
     alphabet.  When an alphabetic that exists in multiple  cases
     appears  as  an ordinary character outside a bracket expres-
     sion, it is effectively transformed into a  bracket  expres-
     sion  containing  both cases, e.g. `x' becomes `[xX]'.  When
     it appears inside a bracket expression,  all  case  counter-
     parts  of  it  are  added to the bracket expression, so that
     (e.g.) `[x]' becomes `[xX]' and `[^x]' becomes `[^xX]'.

     No particular limit is imposed on the length of REs-.   Pro-
     grams  intended  to be portable should not employ REs longer



SunOS 5.5          Last change: March 20, 1994                  3






RE_FORMAT(7)      Device and Network Interfaces      RE_FORMAT(7)



     than 256 bytes, as an implementation can  refuse  to  accept
     such REs and remain POSIX-compliant.

     Obsolete (``basic'') regular expressions differ  in  several
     respects.   `|',  `+',  and  `?' are ordinary characters and
     there is no equivalent for their functionality.  The  delim-
     iters  for  bounds  are  `\{'  and `\}', with `{' and `}' by
     themselves ordinary characters.  The parentheses for  nested
     subexpressions  are `\(' and `\)', with `(' and `)' by them-
     selves ordinary characters.  `^' is  an  ordinary  character
     except  at  the  beginning  of the RE or- the beginning of a
     parenthesized subexpression, `$' is  an  ordinary  character
     except  at  the end of the RE or- the end of a parenthesized
     subexpression, and  `*'  is  an  ordinary  character  if  it
     appears  at  the  beginning  of the RE or the beginning of a
     parenthesized subexpression (after a possible leading  `^').
     Finally,  there  is  one new type of atom, a back reference:
     `\' followed by a non-zero decimal digit d matches the  same
     sequence  of  characters  matched  by  the dth parenthesized
     subexpression (numbering subexpressions by the positions  of
     their  opening  parentheses,  left to right), so that (e.g.)
     `\([bc]\)\1' matches `bb' or `cc' but not `bc'.

SEE ALSO
     regex(3)

     POSIX 1003.2, section 2.8 (Regular Expression Notation).

BUGS
     Having two kinds of REs is a botch.

     The current 1003.2 spec says that `)' is an ordinary charac-
     ter in the absence of an unmatched `('; this was an uninten-
     tional result of a wording  error,  and  change  is  likely.
     Avoid relying on it.

     Back references are a dreadful botch, posing major  problems
     for  efficient  implementations.   They  are  also  somewhat
     vaguely defined  (does  `a\(\(b\)*\2\)*d'  match  `abbbd'?).
     Avoid using them.

     1003.2's  specification  of  case-independent  matching   is
     vague.   The ``one case implies all cases'' definition given
     above is current consensus  among  implementors  as  to  the
     right interpretation.

     The syntax for word boundaries is incredibly ugly.








SunOS 5.5          Last change: March 20, 1994                  4