doc/regexprops-generic.texi

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