doc/regexprops-generic.texi

   1 @c Copyright (C) 1994, 1996, 1998, 2000-2001, 2003-2007, 2009-2014 Free
   2 @c Software Foundation, Inc.
   3 @c
   4 @c Permission is granted to copy, distribute and/or modify this document
   5 @c under the terms of the GNU Free Documentation License, Version 1.3 or
   6 @c any later version published by the Free Software Foundation; with no
   7 @c Invariant Sections, with no Front-Cover Texts, and with no Back-Cover
   8 @c Texts.  A copy of the license is included in the ``GNU Free
   9 @c Documentation License'' file as part of this distribution.
  10
  11 @c this regular expression description is for: generic
  12
  13 @menu
  14 * awk regular expression syntax::
  15 * egrep regular expression syntax::
  16 * ed regular expression syntax::
  17 * emacs regular expression syntax::
  18 * gnu-awk regular expression syntax::
  19 * grep regular expression syntax::
  20 * posix-awk regular expression syntax::
  21 * posix-basic regular expression syntax::
  22 * posix-egrep regular expression syntax::
  23 * posix-extended regular expression syntax::
  24 * posix-minimal-basic regular expression syntax::
  25 * sed regular expression syntax::
  26 @end menu
  27
  28 @node awk regular expression syntax
  29 @subsection @samp{awk} regular expression syntax
  30
  31
  32 The character @samp{.} matches any single character except the null character.
  33
  34
  35 @table @samp
  36
  37 @item +
  38 indicates that the regular expression should match one or more occurrences of the previous atom or regexp.
  39 @item ?
  40 indicates that the regular expression should match zero or one occurrence of the previous atom or regexp.
  41 @item \+
  42 matches a @samp{+}
  43 @item \?
  44 matches a @samp{?}.
  45 @end table
  46
  47
  48 Bracket expressions are used to match ranges of characters.  Bracket expressions where the range is backward, for example @samp{[z-a]}, are invalid.  Within square brackets, @samp{\} can be used to quote the following character.  Character classes are not supported, so for example you would need to use @samp{[0-9]} instead of @samp{[[:digit:]]}.
  49
  50 GNU extensions are not supported and so @samp{\w}, @samp{\W}, @samp{\<}, @samp{\>}, @samp{\b}, @samp{\B}, @samp{\`}, and @samp{\'} match @samp{w}, @samp{W}, @samp{<}, @samp{>}, @samp{b}, @samp{B}, @samp{`}, and @samp{'} respectively.
  51
  52 Grouping is performed with parentheses @samp{()}.  An unmatched @samp{)} matches just itself.  A backslash followed by a digit matches that digit.
  53
  54 The alternation operator is @samp{|}.
  55
  56 The characters @samp{^} and @samp{$} always represent the beginning and end of a string respectively, except within square brackets.  Within brackets, @samp{^} can be used to invert the membership of the character class being specified.
  57
  58 @samp{*}, @samp{+} and @samp{?} are special at any point in a regular expression except:
  59 @enumerate
  60
  61 @item At the beginning of a regular expression
  62
  63 @item After an open-group, signified by
  64 @samp{(}
  65 @item After the alternation operator @samp{|}
  66
  67 @end enumerate
  68
  69
  70
  71
  72 The longest possible match is returned; this applies to the regular expression as a whole and (subject to this constraint) to subexpressions within groups.
  73
  74
  75 @node egrep regular expression syntax
  76 @subsection @samp{egrep} regular expression syntax
  77
  78
  79 The character @samp{.} matches any single character except newline.
  80
  81
  82 @table @samp
  83
  84 @item +
  85 indicates that the regular expression should match one or more occurrences of the previous atom or regexp.
  86 @item ?
  87 indicates that the regular expression should match zero or one occurrence of the previous atom or regexp.
  88 @item \+
  89 matches a @samp{+}
  90 @item \?
  91 matches a @samp{?}.
  92 @end table
  93
  94
  95 Bracket expressions are used to match ranges of characters.  Bracket expressions where the range is backward, for example @samp{[z-a]}, are ignored.  Within square brackets, @samp{\} is taken literally.  Character classes are supported; for example @samp{[[:digit:]]} will match a single decimal digit.  Non-matching lists @samp{[^@dots{}]} do not ever match newline.
  96
  97 GNU extensions are supported:
  98 @enumerate
  99
 100 @item @samp{\w} matches a character within a word
 101
 102 @item @samp{\W} matches a character which is not within a word
 103
 104 @item @samp{\<} matches the beginning of a word
 105
 106 @item @samp{\>} matches the end of a word
 107
 108 @item @samp{\b} matches a word boundary
 109
 110 @item @samp{\B} matches characters which are not a word boundary
 111
 112 @item @samp{\`} matches the beginning of the whole input
 113
 114 @item @samp{\'} matches the end of the whole input
 115
 116 @end enumerate
 117
 118
 119 Grouping is performed with parentheses @samp{()}.  A backslash followed by a digit acts as a back-reference and matches the same thing as the previous grouped expression indicated by that number.  For example @samp{\2} matches the second group expression.  The order of group expressions is determined by the position of their opening parenthesis @samp{(}.
 120
 121 The alternation operator is @samp{|}.
 122
 123 The characters @samp{^} and @samp{$} always represent the beginning and end of a string respectively, except within square brackets.  Within brackets, @samp{^} can be used to invert the membership of the character class being specified.
 124
 125 The characters @samp{*}, @samp{+} and @samp{?} are special anywhere in a regular expression.
 126
 127
 128
 129 The longest possible match is returned; this applies to the regular expression as a whole and (subject to this constraint) to subexpressions within groups.
 130
 131
 132 @node ed regular expression syntax
 133 @subsection @samp{ed} regular expression syntax
 134
 135
 136 The character @samp{.} matches any single character except the null character.
 137
 138
 139 @table @samp
 140
 141 @item \+
 142 indicates that the regular expression should match one or more occurrences of the previous atom or regexp.
 143 @item \?
 144 indicates that the regular expression should match zero or one occurrence of the previous atom or regexp.
 145 @item + and ?
 146 match themselves.
 147 @end table
 148
 149
 150 Bracket expressions are used to match ranges of characters.  Bracket expressions where the range is backward, for example @samp{[z-a]}, are invalid.  Within square brackets, @samp{\} is taken literally.  Character classes are supported; for example @samp{[[:digit:]]} will match a single decimal digit.
 151
 152 GNU extensions are supported:
 153 @enumerate
 154
 155 @item @samp{\w} matches a character within a word
 156
 157 @item @samp{\W} matches a character which is not within a word
 158
 159 @item @samp{\<} matches the beginning of a word
 160
 161 @item @samp{\>} matches the end of a word
 162
 163 @item @samp{\b} matches a word boundary
 164
 165 @item @samp{\B} matches characters which are not a word boundary
 166
 167 @item @samp{\`} matches the beginning of the whole input
 168
 169 @item @samp{\'} matches the end of the whole input
 170
 171 @end enumerate
 172
 173
 174 Grouping is performed with backslashes followed by parentheses @samp{\(}, @samp{\)}.  A backslash followed by a digit acts as a back-reference and matches the same thing as the previous grouped expression indicated by that number.  For example @samp{\2} matches the second group expression.  The order of group expressions is determined by the position of their opening parenthesis @samp{\(}.
 175
 176 The alternation operator is @samp{\|}.
 177
 178 The character @samp{^} only represents the beginning of a string when it appears:
 179 @enumerate
 180
 181 @item
 182 At the beginning of a regular expression
 183
 184 @item After an open-group, signified by
 185 @samp{\(}
 186
 187 @item After the alternation operator @samp{\|}
 188
 189 @end enumerate
 190
 191
 192 The character @samp{$} only represents the end of a string when it appears:
 193 @enumerate
 194
 195 @item At the end of a regular expression
 196
 197 @item Before a close-group, signified by
 198 @samp{\)}
 199 @item Before the alternation operator @samp{\|}
 200
 201 @end enumerate
 202
 203
 204 @samp{\*}, @samp{\+} and @samp{\?} are special at any point in a regular expression except:
 205 @enumerate
 206
 207 @item At the beginning of a regular expression
 208
 209 @item After an open-group, signified by
 210 @samp{\(}
 211 @item After the alternation operator @samp{\|}
 212
 213 @end enumerate
 214
 215
 216 Intervals are specified by @samp{\@{} and @samp{\@}}.  Invalid intervals such as @samp{a\@{1z} are not accepted.
 217
 218 The longest possible match is returned; this applies to the regular expression as a whole and (subject to this constraint) to subexpressions within groups.
 219
 220
 221 @node emacs regular expression syntax
 222 @subsection @samp{emacs} regular expression syntax
 223
 224
 225 The character @samp{.} matches any single character except newline.
 226
 227
 228 @table @samp
 229
 230 @item +
 231 indicates that the regular expression should match one or more occurrences of the previous atom or regexp.
 232 @item ?
 233 indicates that the regular expression should match zero or one occurrence of the previous atom or regexp.
 234 @item \+
 235 matches a @samp{+}
 236 @item \?
 237 matches a @samp{?}.
 238 @end table
 239
 240
 241 Bracket expressions are used to match ranges of characters.  Bracket expressions where the range is backward, for example @samp{[z-a]}, are ignored.  Within square brackets, @samp{\} is taken literally.  Character classes are not supported, so for example you would need to use @samp{[0-9]} instead of @samp{[[:digit:]]}.
 242
 243 GNU extensions are supported:
 244 @enumerate
 245
 246 @item @samp{\w} matches a character within a word
 247
 248 @item @samp{\W} matches a character which is not within a word
 249
 250 @item @samp{\<} matches the beginning of a word
 251
 252 @item @samp{\>} matches the end of a word
 253
 254 @item @samp{\b} matches a word boundary
 255
 256 @item @samp{\B} matches characters which are not a word boundary
 257
 258 @item @samp{\`} matches the beginning of the whole input
 259
 260 @item @samp{\'} matches the end of the whole input
 261
 262 @end enumerate
 263
 264
 265 Grouping is performed with backslashes followed by parentheses @samp{\(}, @samp{\)}.  A backslash followed by a digit acts as a back-reference and matches the same thing as the previous grouped expression indicated by that number.  For example @samp{\2} matches the second group expression.  The order of group expressions is determined by the position of their opening parenthesis @samp{\(}.
 266
 267 The alternation operator is @samp{\|}.
 268
 269 The character @samp{^} only represents the beginning of a string when it appears:
 270 @enumerate
 271
 272 @item
 273 At the beginning of a regular expression
 274
 275 @item After an open-group, signified by
 276 @samp{\(}
 277
 278 @item After the alternation operator @samp{\|}
 279
 280 @end enumerate
 281
 282
 283 The character @samp{$} only represents the end of a string when it appears:
 284 @enumerate
 285
 286 @item At the end of a regular expression
 287
 288 @item Before a close-group, signified by
 289 @samp{\)}
 290 @item Before the alternation operator @samp{\|}
 291
 292 @end enumerate
 293
 294
 295 @samp{*}, @samp{+} and @samp{?} are special at any point in a regular expression except:
 296 @enumerate
 297
 298 @item At the beginning of a regular expression
 299
 300 @item After an open-group, signified by
 301 @samp{\(}
 302 @item After the alternation operator @samp{\|}
 303
 304 @end enumerate
 305
 306
 307
 308
 309 The longest possible match is returned; this applies to the regular expression as a whole and (subject to this constraint) to subexpressions within groups.
 310
 311
 312 @node gnu-awk regular expression syntax
 313 @subsection @samp{gnu-awk} regular expression syntax
 314
 315
 316 The character @samp{.} matches any single character.
 317
 318
 319 @table @samp
 320
 321 @item +
 322 indicates that the regular expression should match one or more occurrences of the previous atom or regexp.
 323 @item ?
 324 indicates that the regular expression should match zero or one occurrence of the previous atom or regexp.
 325 @item \+
 326 matches a @samp{+}
 327 @item \?
 328 matches a @samp{?}.
 329 @end table
 330
 331
 332 Bracket expressions are used to match ranges of characters.  Bracket expressions where the range is backward, for example @samp{[z-a]}, are invalid.  Within square brackets, @samp{\} can be used to quote the following character.  Character classes are supported; for example @samp{[[:digit:]]} will match a single decimal digit.
 333
 334 GNU extensions are supported:
 335 @enumerate
 336
 337 @item @samp{\w} matches a character within a word
 338
 339 @item @samp{\W} matches a character which is not within a word
 340
 341 @item @samp{\<} matches the beginning of a word
 342
 343 @item @samp{\>} matches the end of a word
 344
 345 @item @samp{\b} matches a word boundary
 346
 347 @item @samp{\B} matches characters which are not a word boundary
 348
 349 @item @samp{\`} matches the beginning of the whole input
 350
 351 @item @samp{\'} matches the end of the whole input
 352
 353 @end enumerate
 354
 355
 356 Grouping is performed with parentheses @samp{()}.  An unmatched @samp{)} matches just itself.  A backslash followed by a digit acts as a back-reference and matches the same thing as the previous grouped expression indicated by that number.  For example @samp{\2} matches the second group expression.  The order of group expressions is determined by the position of their opening parenthesis @samp{(}.
 357
 358 The alternation operator is @samp{|}.
 359
 360 The characters @samp{^} and @samp{$} always represent the beginning and end of a string respectively, except within square brackets.  Within brackets, @samp{^} can be used to invert the membership of the character class being specified.
 361
 362 @samp{*}, @samp{+} and @samp{?} are special at any point in a regular expression except:
 363 @enumerate
 364
 365 @item At the beginning of a regular expression
 366
 367 @item After an open-group, signified by
 368 @samp{(}
 369 @item After the alternation operator @samp{|}
 370
 371 @end enumerate
 372
 373
 374
 375
 376 The longest possible match is returned; this applies to the regular expression as a whole and (subject to this constraint) to subexpressions within groups.
 377
 378
 379 @node grep regular expression syntax
 380 @subsection @samp{grep} regular expression syntax
 381
 382
 383 The character @samp{.} matches any single character except newline.
 384
 385
 386 @table @samp
 387
 388 @item \+
 389 indicates that the regular expression should match one or more occurrences of the previous atom or regexp.
 390 @item \?
 391 indicates that the regular expression should match zero or one occurrence of the previous atom or regexp.
 392 @item + and ?
 393 match themselves.
 394 @end table
 395
 396
 397 Bracket expressions are used to match ranges of characters.  Bracket expressions where the range is backward, for example @samp{[z-a]}, are ignored.  Within square brackets, @samp{\} is taken literally.  Character classes are supported; for example @samp{[[:digit:]]} will match a single decimal digit.  Non-matching lists @samp{[^@dots{}]} do not ever match newline.
 398
 399 GNU extensions are supported:
 400 @enumerate
 401
 402 @item @samp{\w} matches a character within a word
 403
 404 @item @samp{\W} matches a character which is not within a word
 405
 406 @item @samp{\<} matches the beginning of a word
 407
 408 @item @samp{\>} matches the end of a word
 409
 410 @item @samp{\b} matches a word boundary
 411
 412 @item @samp{\B} matches characters which are not a word boundary
 413
 414 @item @samp{\`} matches the beginning of the whole input
 415
 416 @item @samp{\'} matches the end of the whole input
 417
 418 @end enumerate
 419
 420
 421 Grouping is performed with backslashes followed by parentheses @samp{\(}, @samp{\)}.  A backslash followed by a digit acts as a back-reference and matches the same thing as the previous grouped expression indicated by that number.  For example @samp{\2} matches the second group expression.  The order of group expressions is determined by the position of their opening parenthesis @samp{\(}.
 422
 423 The alternation operator is @samp{\|}.
 424
 425 The character @samp{^} only represents the beginning of a string when it appears:
 426 @enumerate
 427
 428 @item
 429 At the beginning of a regular expression
 430
 431 @item After an open-group, signified by
 432 @samp{\(}
 433
 434 @item After a newline
 435
 436 @item After the alternation operator @samp{\|}
 437
 438 @end enumerate
 439
 440
 441 The character @samp{$} only represents the end of a string when it appears:
 442 @enumerate
 443
 444 @item At the end of a regular expression
 445
 446 @item Before a close-group, signified by
 447 @samp{\)}
 448 @item Before a newline
 449
 450 @item Before the alternation operator @samp{\|}
 451
 452 @end enumerate
 453
 454
 455 @samp{\*}, @samp{\+} and @samp{\?} are special at any point in a regular expression except:
 456 @enumerate
 457
 458 @item At the beginning of a regular expression
 459
 460 @item After an open-group, signified by
 461 @samp{\(}
 462 @item After a newline
 463
 464 @item After the alternation operator @samp{\|}
 465
 466 @end enumerate
 467
 468
 469 Intervals are specified by @samp{\@{} and @samp{\@}}.  Invalid intervals such as @samp{a\@{1z} are not accepted.
 470
 471 The longest possible match is returned; this applies to the regular expression as a whole and (subject to this constraint) to subexpressions within groups.
 472
 473
 474 @node posix-awk regular expression syntax
 475 @subsection @samp{posix-awk} regular expression syntax
 476
 477
 478 The character @samp{.} matches any single character except the null character.
 479
 480
 481 @table @samp
 482
 483 @item +
 484 indicates that the regular expression should match one or more occurrences of the previous atom or regexp.
 485 @item ?
 486 indicates that the regular expression should match zero or one occurrence of the previous atom or regexp.
 487 @item \+
 488 matches a @samp{+}
 489 @item \?
 490 matches a @samp{?}.
 491 @end table
 492
 493
 494 Bracket expressions are used to match ranges of characters.  Bracket expressions where the range is backward, for example @samp{[z-a]}, are invalid.  Within square brackets, @samp{\} can be used to quote the following character.  Character classes are supported; for example @samp{[[:digit:]]} will match a single decimal digit.
 495
 496 GNU extensions are not supported and so @samp{\w}, @samp{\W}, @samp{\<}, @samp{\>}, @samp{\b}, @samp{\B}, @samp{\`}, and @samp{\'} match @samp{w}, @samp{W}, @samp{<}, @samp{>}, @samp{b}, @samp{B}, @samp{`}, and @samp{'} respectively.
 497
 498 Grouping is performed with parentheses @samp{()}.  An unmatched @samp{)} matches just itself.  A backslash followed by a digit acts as a back-reference and matches the same thing as the previous grouped expression indicated by that number.  For example @samp{\2} matches the second group expression.  The order of group expressions is determined by the position of their opening parenthesis @samp{(}.
 499
 500 The alternation operator is @samp{|}.
 501
 502 The characters @samp{^} and @samp{$} always represent the beginning and end of a string respectively, except within square brackets.  Within brackets, @samp{^} can be used to invert the membership of the character class being specified.
 503
 504 @samp{*}, @samp{+} and @samp{?} are special at any point in a regular expression except the following places, where they are not allowed:
 505 @enumerate
 506
 507 @item At the beginning of a regular expression
 508
 509 @item After an open-group, signified by
 510 @samp{(}
 511 @item After the alternation operator @samp{|}
 512
 513 @end enumerate
 514
 515
 516 Intervals are specified by @samp{@{} and @samp{@}}.  Invalid intervals such as @samp{a@{1z} are not accepted.
 517
 518 The longest possible match is returned; this applies to the regular expression as a whole and (subject to this constraint) to subexpressions within groups.
 519
 520
 521 @node posix-basic regular expression syntax
 522 @subsection @samp{posix-basic} regular expression syntax
 523 This is a synonym for ed.
 524 @node posix-egrep regular expression syntax
 525 @subsection @samp{posix-egrep} regular expression syntax
 526
 527
 528 The character @samp{.} matches any single character except newline.
 529
 530
 531 @table @samp
 532
 533 @item +
 534 indicates that the regular expression should match one or more occurrences of the previous atom or regexp.
 535 @item ?
 536 indicates that the regular expression should match zero or one occurrence of the previous atom or regexp.
 537 @item \+
 538 matches a @samp{+}
 539 @item \?
 540 matches a @samp{?}.
 541 @end table
 542
 543
 544 Bracket expressions are used to match ranges of characters.  Bracket expressions where the range is backward, for example @samp{[z-a]}, are ignored.  Within square brackets, @samp{\} is taken literally.  Character classes are supported; for example @samp{[[:digit:]]} will match a single decimal digit.  Non-matching lists @samp{[^@dots{}]} do not ever match newline.
 545
 546 GNU extensions are supported:
 547 @enumerate
 548
 549 @item @samp{\w} matches a character within a word
 550
 551 @item @samp{\W} matches a character which is not within a word
 552
 553 @item @samp{\<} matches the beginning of a word
 554
 555 @item @samp{\>} matches the end of a word
 556
 557 @item @samp{\b} matches a word boundary
 558
 559 @item @samp{\B} matches characters which are not a word boundary
 560
 561 @item @samp{\`} matches the beginning of the whole input
 562
 563 @item @samp{\'} matches the end of the whole input
 564
 565 @end enumerate
 566
 567
 568 Grouping is performed with parentheses @samp{()}.  A backslash followed by a digit acts as a back-reference and matches the same thing as the previous grouped expression indicated by that number.  For example @samp{\2} matches the second group expression.  The order of group expressions is determined by the position of their opening parenthesis @samp{(}.
 569
 570 The alternation operator is @samp{|}.
 571
 572 The characters @samp{^} and @samp{$} always represent the beginning and end of a string respectively, except within square brackets.  Within brackets, @samp{^} can be used to invert the membership of the character class being specified.
 573
 574 The characters @samp{*}, @samp{+} and @samp{?} are special anywhere in a regular expression.
 575
 576 Intervals are specified by @samp{@{} and @samp{@}}.  Invalid intervals are treated as literals, for example @samp{a@{1} is treated as @samp{a\@{1}
 577
 578 The longest possible match is returned; this applies to the regular expression as a whole and (subject to this constraint) to subexpressions within groups.
 579
 580
 581 @node posix-extended regular expression syntax
 582 @subsection @samp{posix-extended} regular expression syntax
 583
 584
 585 The character @samp{.} matches any single character except the null character.
 586
 587
 588 @table @samp
 589
 590 @item +
 591 indicates that the regular expression should match one or more occurrences of the previous atom or regexp.
 592 @item ?
 593 indicates that the regular expression should match zero or one occurrence of the previous atom or regexp.
 594 @item \+
 595 matches a @samp{+}
 596 @item \?
 597 matches a @samp{?}.
 598 @end table
 599
 600
 601 Bracket expressions are used to match ranges of characters.  Bracket expressions where the range is backward, for example @samp{[z-a]}, are invalid.  Within square brackets, @samp{\} is taken literally.  Character classes are supported; for example @samp{[[:digit:]]} will match a single decimal digit.
 602
 603 GNU extensions are supported:
 604 @enumerate
 605
 606 @item @samp{\w} matches a character within a word
 607
 608 @item @samp{\W} matches a character which is not within a word
 609
 610 @item @samp{\<} matches the beginning of a word
 611
 612 @item @samp{\>} matches the end of a word
 613
 614 @item @samp{\b} matches a word boundary
 615
 616 @item @samp{\B} matches characters which are not a word boundary
 617
 618 @item @samp{\`} matches the beginning of the whole input
 619
 620 @item @samp{\'} matches the end of the whole input
 621
 622 @end enumerate
 623
 624
 625 Grouping is performed with parentheses @samp{()}.  An unmatched @samp{)} matches just itself.  A backslash followed by a digit acts as a back-reference and matches the same thing as the previous grouped expression indicated by that number.  For example @samp{\2} matches the second group expression.  The order of group expressions is determined by the position of their opening parenthesis @samp{(}.
 626
 627 The alternation operator is @samp{|}.
 628
 629 The characters @samp{^} and @samp{$} always represent the beginning and end of a string respectively, except within square brackets.  Within brackets, @samp{^} can be used to invert the membership of the character class being specified.
 630
 631 @samp{*}, @samp{+} and @samp{?} are special at any point in a regular expression except the following places, where they are not allowed:
 632 @enumerate
 633
 634 @item At the beginning of a regular expression
 635
 636 @item After an open-group, signified by
 637 @samp{(}
 638 @item After the alternation operator @samp{|}
 639
 640 @end enumerate
 641
 642
 643 Intervals are specified by @samp{@{} and @samp{@}}.  Invalid intervals such as @samp{a@{1z} are not accepted.
 644
 645 The longest possible match is returned; this applies to the regular expression as a whole and (subject to this constraint) to subexpressions within groups.
 646
 647
 648 @node posix-minimal-basic regular expression syntax
 649 @subsection @samp{posix-minimal-basic} regular expression syntax
 650
 651
 652 The character @samp{.} matches any single character except the null character.
 653
 654
 655
 656 Bracket expressions are used to match ranges of characters.  Bracket expressions where the range is backward, for example @samp{[z-a]}, are invalid.  Within square brackets, @samp{\} is taken literally.  Character classes are supported; for example @samp{[[:digit:]]} will match a single decimal digit.
 657
 658 GNU extensions are supported:
 659 @enumerate
 660
 661 @item @samp{\w} matches a character within a word
 662
 663 @item @samp{\W} matches a character which is not within a word
 664
 665 @item @samp{\<} matches the beginning of a word
 666
 667 @item @samp{\>} matches the end of a word
 668
 669 @item @samp{\b} matches a word boundary
 670
 671 @item @samp{\B} matches characters which are not a word boundary
 672
 673 @item @samp{\`} matches the beginning of the whole input
 674
 675 @item @samp{\'} matches the end of the whole input
 676
 677 @end enumerate
 678
 679
 680 Grouping is performed with backslashes followed by parentheses @samp{\(}, @samp{\)}.  A backslash followed by a digit acts as a back-reference and matches the same thing as the previous grouped expression indicated by that number.  For example @samp{\2} matches the second group expression.  The order of group expressions is determined by the position of their opening parenthesis @samp{\(}.
 681
 682
 683
 684 The character @samp{^} only represents the beginning of a string when it appears:
 685 @enumerate
 686
 687 @item
 688 At the beginning of a regular expression
 689
 690 @item After an open-group, signified by
 691 @samp{\(}
 692
 693 @end enumerate
 694
 695
 696 The character @samp{$} only represents the end of a string when it appears:
 697 @enumerate
 698
 699 @item At the end of a regular expression
 700
 701 @item Before a close-group, signified by
 702 @samp{\)}
 703 @end enumerate
 704
 705
 706
 707
 708 Intervals are specified by @samp{\@{} and @samp{\@}}.  Invalid intervals such as @samp{a\@{1z} are not accepted.
 709
 710 The longest possible match is returned; this applies to the regular expression as a whole and (subject to this constraint) to subexpressions within groups.
 711
 712
 713 @node sed regular expression syntax
 714 @subsection @samp{sed} regular expression syntax
 715 This is a synonym for ed.